From c7fe425ef3c5e8804f2f5de3d8fffedf5e2f1131 Mon Sep 17 00:00:00 2001 From: hardythe1 Date: Tue, 7 Apr 2015 15:58:05 +0530 Subject: added books --- Elements_of_Power_system/Chapter_10.ipynb | 732 +++++++++++++ Elements_of_Power_system/Chapter_11.ipynb | 907 ++++++++++++++++ Elements_of_Power_system/Chapter_12.ipynb | 101 ++ Elements_of_Power_system/Chapter_2.ipynb | 273 +++++ Elements_of_Power_system/Chapter_3.ipynb | 368 +++++++ Elements_of_Power_system/Chapter_4.ipynb | 1168 ++++++++++++++++++++ Elements_of_Power_system/Chapter_5.ipynb | 1386 ++++++++++++++++++++++++ Elements_of_Power_system/Chapter_6.ipynb | 343 ++++++ Elements_of_Power_system/Chapter_7.ipynb | 454 ++++++++ Elements_of_Power_system/Chapter_8.ipynb | 123 +++ Elements_of_Power_system/Chapter_9.ipynb | 569 ++++++++++ Elements_of_Power_system/chapter_1.ipynb | 200 ++++ Elements_of_Power_system/screenshots/chap5.png | Bin 0 -> 85286 bytes Elements_of_Power_system/screenshots/chap6.png | Bin 0 -> 62526 bytes Elements_of_Power_system/screenshots/chap7.png | Bin 0 -> 66223 bytes 15 files changed, 6624 insertions(+) create mode 100755 Elements_of_Power_system/Chapter_10.ipynb create mode 100755 Elements_of_Power_system/Chapter_11.ipynb create mode 100755 Elements_of_Power_system/Chapter_12.ipynb create mode 100755 Elements_of_Power_system/Chapter_2.ipynb create mode 100755 Elements_of_Power_system/Chapter_3.ipynb create mode 100755 Elements_of_Power_system/Chapter_4.ipynb create mode 100755 Elements_of_Power_system/Chapter_5.ipynb create mode 100755 Elements_of_Power_system/Chapter_6.ipynb create mode 100755 Elements_of_Power_system/Chapter_7.ipynb create mode 100755 Elements_of_Power_system/Chapter_8.ipynb create mode 100755 Elements_of_Power_system/Chapter_9.ipynb create mode 100755 Elements_of_Power_system/chapter_1.ipynb create mode 100755 Elements_of_Power_system/screenshots/chap5.png create mode 100755 Elements_of_Power_system/screenshots/chap6.png create mode 100755 Elements_of_Power_system/screenshots/chap7.png (limited to 'Elements_of_Power_system') diff --git a/Elements_of_Power_system/Chapter_10.ipynb b/Elements_of_Power_system/Chapter_10.ipynb new file mode 100755 index 00000000..b172aba8 --- /dev/null +++ b/Elements_of_Power_system/Chapter_10.ipynb @@ -0,0 +1,732 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:1ed2c66761e5c24becdae0bef9d3fd6079b2eecb8e7b4c62bdcfe4d4af9edc70" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 10 - MECHANICAL DESIGN OF TRANSMISISON LINES" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E1 - Pg 246" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate maximum sag\n", + "import math\n", + "#Given data :\n", + "L=200.#**m\n", + "w=0.7#**kg\n", + "T=1400.#**kg\n", + "S=w*L**2./(8.*T)#**,m\n", + "print '%s %.2f' %(\"maximum sag(m) :\",S)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "maximum sag(m) : 2.50\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E2 - Pg 247" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Height above the ground\n", + "import math\n", + "#Given data :\n", + "W=680.##kg/km\n", + "L=260.##m\n", + "U_strength=3100.##kg\n", + "SF=2.##safety factor\n", + "Clearance=10.##m\n", + "T=U_strength/SF##kg\n", + "w=W/1000.##kg\n", + "S=w*L**2./(8.*T)##,m\n", + "h=Clearance+S##m\n", + "print '%s %.1f' %(\"Height above the ground(m) :\",h)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Height above the ground(m) : 13.7\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E3 - Pg 247" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Horizontal component of tension,Maximum sag,Sag will be half at the point where x coordinate(in m) will be\n", + "import math\n", + "import numpy \n", + "from numpy import roots\n", + "#Given data :\n", + "w=700./1000.##kg/m\n", + "L=300.##m\n", + "Tmax=3500.##kg\n", + "\n", + "S_T0=w*L**2./8.##,m\n", + "#Tmax=T0+w*S\n", + "#T0**2-T0*Tmax-w*S_T0=0\n", + "polynomial=([1, -Tmax, -w*S_T0])#\n", + "T0=numpy.roots(polynomial)##kg\n", + "T0=T0[0]##+ve sign taken\n", + "print '%s %.2f' %(\"Horizontal component of tension in kg is : \",T0)#\n", + "S=S_T0/T0##m\n", + "print '%s %.4f' %(\"Maximum sag in m : \",S)#\n", + "y=S/2.##m\n", + "x=math.sqrt(2.*y*T0/w)##m\n", + "print '%s %.f' %(\"Sag will be half at the point where x coordinate(in m) will be : \",x)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Horizontal component of tension in kg is : 3501.57\n", + "Maximum sag in m : 2.2490\n", + "Sag will be half at the point where x coordinate(in m) will be : 106\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E4 - Pg 248" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Maximum sag \n", + "import math\n", + "#Given data :\n", + "L=150.##m\n", + "wc=1.##kg\n", + "A=1.25##cm**2\n", + "U_stress=4200.##kg/cm**2\n", + "Pw=100.##kg/m**2(Wind pressure)\n", + "SF=4.##factor of safety\n", + "W_stress=U_stress/SF##kg/cm**2\n", + "T=W_stress*A##kg\n", + "d=math.sqrt(A/(math.pi/4.))##cm\n", + "w_w=Pw*d*10.**-2##kg\n", + "wr=math.sqrt(wc**2.+w_w**2.)##kg\n", + "S=wr*L**2./8./T##m\n", + "print '%s %.2f' %(\"Maximum sag(m)\",S)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Maximum sag(m) 3.45\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E5 - Pg 248" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Sag(meter)\n", + "import math\n", + "#Given data :\n", + "L=160.##m\n", + "d=0.95##cm\n", + "wc=0.65##kg/m\n", + "U_stress=4250.##kg/cm**2\n", + "Pw=40.##kg/m**2(Wind pressure)\n", + "SF=5.##factor of safety\n", + "W_stress=U_stress/SF##kg/cm**2\n", + "T=W_stress*math.pi/4.*d**2.##kg\n", + "w_w=Pw*d*10.**-2##kg\n", + "wr=math.sqrt(wc**2.+w_w**2.)##kg\n", + "S=wr*L**2./8./T##m\n", + "print '%s %.2f' %(\"Sag(meter)\",round(S))#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Sag(meter) 4.00\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E6 - Pg 248" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Sag in still air,Maximum Sag\n", + "import math\n", + "#Given data :\n", + "L=180.##m\n", + "D=1.27##cm\n", + "Pw=33.7##kg/m**2(Wind pressure)\n", + "r=1.25##cm\n", + "wc=1.13##kg/cm**2\n", + "U_stress=4220.##kg/cm**2\n", + "SF=5.##factor of safety\n", + "W_stress=U_stress/SF##kg/cm**2\n", + "T=W_stress*math.pi/4.*D**2.##kg\n", + "S=wc*L**2./8./T##msag in air\n", + "print '%s %.2f' %(\"Sag in still air(meter)\",S)#\n", + "w1=2890.3*r*10.**-2*(D+r)*10.**-2##kg/m\n", + "w_w=Pw*(D+2.*r)*10.**-2##kg\n", + "wr=math.sqrt((wc+w1)**2.+w_w**2.)##kg\n", + "Smax=wr*L**2./8./T##msag in air\n", + "print '%s %.3f' %(\"Maximum Sag(meter)\",Smax)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Sag in still air(meter) 4.28\n", + "Maximum Sag(meter) 9.105\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E7 - Pg 249" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Maximum Sag \n", + "import math\n", + "#Given data :\n", + "D=19.5##mm\n", + "wc=0.85##kg/m\n", + "L=275.##m\n", + "Pw=39.##kg/m**2(Wind pressure)\n", + "r=13.##mm\n", + "U_stress=8000.##kg/cm**2\n", + "SF=2.##factor of safety\n", + "rho_i=910.##kg/m**3(density of ice)\n", + "T=U_stress/SF##kg\n", + "wi=rho_i*math.pi*r*10.**-3*(D+r)*10.**-3##kg\n", + "w_w=Pw*(D+2.*r)*10.**-3##kg\n", + "wr=math.sqrt((wc+wi)**2.+w_w**2)##kg\n", + "Smax=wr*L**2./8./T##msag in air\n", + "print '%s %.3f' %(\"Maximum Sag(meter)\",Smax)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Maximum Sag(meter) 6.422\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E8 - Pg 249" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate \n", + "import math\n", + "#Given data :\n", + "wc=1.##kg/m\n", + "L=280.##m\n", + "D=20.##mm\n", + "r=10.##mm\n", + "Pw=40.##kg/m**2(Wind pressure)\n", + "rho_i=910.##kg/m**3(density of ice)\n", + "U_stress=10000.##kg/cm**2\n", + "SF=2.##factor of safety\n", + "wi=rho_i*math.pi*r*10.**-3*(D+r)*10.**-3##kg\n", + "w_w=Pw*(D+2.*r)*10.**-3##kg\n", + "wr=math.sqrt((wc+wi)**2.+w_w**2.)##kg(Resultant force per m length of conductor)\n", + "T=U_stress/SF##kg\n", + "Smax=wr*L**2./8./T##msag in air\n", + "print '%s %.1f' %(\"Maximum Sag(meter)\",Smax)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Maximum Sag(meter) 4.8\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E9 - Pg 250" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Sag in inclined direction,Sag in vertical direction,Height of lowest cross arm\n", + "import math\n", + "#Given data :\n", + "L=250.##m\n", + "D=1.42##cm\n", + "wc=1.09##kg/m\n", + "Pw=37.8##kg/m**2(Wind pressure)\n", + "r=1.25##cm\n", + "Lis=1.43##m(insulator string length)\n", + "Clearance=7.62##m\n", + "rho_i=913.5##kg/m**3(density of ice)\n", + "stress=1050.##kg/cm**2\n", + "T=stress*math.pi/4.*D**2##kg\n", + "wi=rho_i*math.pi*r*10.**-2*(D+r)*10.**-2##kg\n", + "w_w=Pw*(D+2.*r)*10.**-2##kg\n", + "wr=math.sqrt((wc+wi)**2+w_w**2.)##kg(Resultant force per m length of conductor)\n", + "Smax=wr*L**2./8./T##max sag in air\n", + "print '%s %.4f' %(\"Sag in inclined direction(meter)\",Smax)#\n", + "Sdash=Smax*(wc+wi)/wr##max sag in air\n", + "print '%s %.2f' %(\"Sag in vertical direction(meter)\",Sdash)#\n", + "h=Clearance+Sdash+Lis##m\n", + "print '%s %.2f' %(\"Height of lowest cross arm(m)\",h)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Sag in inclined direction(meter) 11.8756\n", + "Sag in vertical direction(meter) 9.62\n", + "Height of lowest cross arm(m) 18.67\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E10 - Pg 250" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Distance of lowest point,minimum point of catenary above the ground\n", + "import math\n", + "#Given data :\n", + "wc=0.35##kg/m\n", + "stress=800.##kg/cm**2\n", + "L=160.##m\n", + "SF=2.##safety factor\n", + "h=70.-65.##m\n", + "T=stress/SF##kg\n", + "x=L/2.+T*h/(wc*L)##m\n", + "print '%s %.2f' %(\"Distance of lowest point(m)\",x)#\n", + "S1=wc*x**2/SF/T##max sag in air\n", + "xmin=70.-S1##m\n", + "print '%s %.4f' %(\"minimum point of catenary above the ground(m)\",xmin)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Distance of lowest point(m) 115.71\n", + "minimum point of catenary above the ground(m) 64.1420\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E11 - Pg 251" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Slant sag,Vertical Sag\n", + "import math\n", + "#Given data :\n", + "L=200.##m\n", + "h=10.##m\n", + "D=2.##cm\n", + "wc=2.3##kg/m\n", + "Pw=57.5##kg/m**2(wind pressure)\n", + "SF=4.##safety factor\n", + "stress=4220.##kg/cm**2\n", + "w_w=Pw*D*10.**-2##kg\n", + "wr=math.sqrt(wc**2.+w_w**2.)##kg\n", + "f=stress/SF##kg/cm**2\n", + "T=f*math.pi/4.*D**2.##kg\n", + "x=L/2.-T*h/(wr*L)##m\n", + "S1=wr*x**2./2./T##max sag in air\n", + "print '%s %.4f' %(\"Slant sag(m)\",S1)#\n", + "Sdash=wc*x**2./2./T##vertical sag\n", + "print '%s %.4f' %(\"Vertical Sag(meter)\",Sdash)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Slant sag(m) 0.4904\n", + "Vertical Sag(meter) 0.4386\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E12 - Pg 251" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Vertical Sag\n", + "import math\n", + "#Given data :\n", + "wc=1.925##kg/m\n", + "A=2.2##cm**2\n", + "f=8000.##kg/cm**2\n", + "L=600.##m\n", + "h=15.##m\n", + "D=2.##cm\n", + "SF=5.##safety factor\n", + "wi=1.##kg(load)\n", + "w=wi+wc##kg\n", + "T=f*A/SF##kg\n", + "x=L/2.-T*h/(w*L)##m\n", + "S2=w*(L-x)**2./2./T##m\n", + "print '%s %.2f' %(\"Vertical Sag(meter)\",S2)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Vertical Sag(meter) 45.27\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E13 - Pg 252" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Mid point P is \"+string(Point_P)+\" meter below point B or \"+string(80-Point_P)+\" meter above the water level\n", + "import math\n", + "#Given data :\n", + "h=80.-50.##m\n", + "L=300.##m\n", + "T=2000.##kg\n", + "w=0.844##kg/m\n", + "x=L/2.-T*h/(w*L)##m\n", + "d_PO=L/2.-x##m\n", + "d_BO=L-x##m\n", + "Smid=w*(L/2.-x)**2./2./T##m\n", + "S2=w*(L-x)**2./2./T##m\n", + "Point_P=S2-Smid##m\n", + "print '%s %.3f %s %.3f %s' %(\"Mid point P is \",Point_P,\" meter below point B or \",80-Point_P,\" meter above the water level.\")#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Mid point P is 19.747 meter below point B or 60.253 meter above the water level.\n" + ] + } + ], + "prompt_number": 12 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E14 - Pg 252" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Stringing Tension\n", + "import math\n", + "#Given data :\n", + "S1=25.##m\n", + "S2=75.##m\n", + "Point_P=45.##m\n", + "L1=250.##m\n", + "L2=125.##m(mid point)\n", + "w=0.7##kg/m\n", + "h1=S2-S1##m(for points A & B)\n", + "h2=Point_P-S1##m(for points A & B)\n", + "#h1=w*L1/2/T*[L1-2*x]\n", + "#h2=w*L2/2/T*[L2-2*x]\n", + "x=(L1-h1/h2/L1*L2*L2)/(-h1/h2/L1*L2*2.+2.)##m\n", + "T=(L1-2.*x)/(h1/w/L1*2.)##kg\n", + "print '%s %.2f' %(\"Stringing Tension(kg)\",T)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Stringing Tension(kg) 1093.75\n" + ] + } + ], + "prompt_number": 13 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E15 - Pg 253" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Clearance of the lowest point from ground,Minimum clearance\n", + "import math\n", + "#Given data :\n", + "L=300.##m\n", + "slope=1./20.#\n", + "w=0.80##kg/m\n", + "hl=30.##m\n", + "T0=1500.##kg\n", + "CD=L##m\n", + "tan_alfa=slope#\n", + "ED=CD*tan_alfa##m\n", + "AC=hl##m\n", + "BE=hl##m\n", + "BD=BE+ED##m\n", + "#S1=w*x1**2/2/T0##m\n", + "#S2=w*(L-x1)**2/2/T0##m\n", + "h=15.##m\n", + "ED=h##m\n", + "x1=L/2.-T0*h/w/L##m\n", + "S1=w*x1**2./2./T0##m\n", + "S2=w*(L-x1)**2./2./T0##m\n", + "OG=AC-S1-x1*tan_alfa##m\n", + "Clearance=OG##m\n", + "print '%s %.5f' %(\"Clearance of the lowest point from ground(m)\",Clearance)#\n", + "#y=x*tan_alfa-OG##m\n", + "#C1=w*x**2/2/T0-(x/20-OG)\n", + "x=T0/20./w##m(Byy putting dC1/dx=0)\n", + "C1=w*x**2./2./T0-(x/20.-OG)##m\n", + "print '%s %.2f' %(\"Minimum clearance(m)\",C1)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Clearance of the lowest point from ground(m) 26.34375\n", + "Minimum clearance(m) 24.00\n" + ] + } + ], + "prompt_number": 14 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E16 - Pg 255" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Sag at erection\n", + "import math\n", + "import numpy\n", + "from numpy import roots\n", + "#Given data :\n", + "L=250.##m\n", + "D=19.5##mm\n", + "A=2.25*10.**-4##m**2.\n", + "wc=0.85##kg/m\n", + "t1=35.##degree C\n", + "t2=5.##degree C\n", + "Pw=38.5##kg/m**2\n", + "alfa=18.44*10.**-6##per degree C\n", + "E=9320.##kg/mm**2\n", + "E=9320.*10.**6.##kg/m**2\n", + "Breaking_Load=8000.##kg\n", + "SF=2.##Safety factor\n", + "T1=Breaking_Load/SF##kg\n", + "f1=T1/A##kg/m**2\n", + "w_w=Pw*D*10.**-2##kg\n", + "w1=math.sqrt(wc**2.+w_w**2.)##kg\n", + "w2=wc#\n", + "#f2**2.*[(f2-f1)+w1*L**2.*E/24./f1**2./A**2.+(t2-t1)*E]=w2*L**2.*E/24./A**2.\n", + "#f2**3-f2**2.*f1-w2*L**2.*E/24./A**2.=0\n", + "P=([1, -1.0674*10.**7, 0, -3463.84*10.**17.])#\n", + "f2=numpy.roots(P)#\n", + "f2=numpy.real(f2[0])##kg/m**2\n", + "S=w2*L**2./8./f2/A##m\n", + "print '%s %.1f' %(\"Sag at erection(m)\",S)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Sag at erection(m) 2.3\n" + ] + } + ], + "prompt_number": 15 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Elements_of_Power_system/Chapter_11.ipynb b/Elements_of_Power_system/Chapter_11.ipynb new file mode 100755 index 00000000..6d51d69c --- /dev/null +++ b/Elements_of_Power_system/Chapter_11.ipynb @@ -0,0 +1,907 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:7b666e4f5f0e7854294a9805411c57beda0a7d1ca3061910d81bfa32dc9c6672" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 11 - INSULATED CABLES " + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E1 - Pg 273" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Insulation resistance of cable\n", + "#Given data :\n", + "import math\n", + "rho=5.*10.**14.*10.**-2##ohm-m\n", + "l=5.*1000.##m\n", + "r1=1.25##m\n", + "r2=r1+1.##m\n", + "R_ins=rho/(2.*math.pi*l)*math.log(r2/r1)##ohm\n", + "print '%s %.2f' %(\"Insulation resistance of cable(Mohm) :\",R_ins/10.**6.)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Insulation resistance of cable(Mohm) : 93.55\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E2 - Pg 274" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Insulation resistance of cable\n", + "#Given data :\n", + "import math\n", + "rho=5.*10.**14.*10.**-2##ohm-m\n", + "l=5.*1000.##m\n", + "r1=2.5##m\n", + "r2=r1+1.##m\n", + "R_ins=rho/(2.*math.pi*l)*math.log(r2/r1)##ohm\n", + "print '%s %.2f' %(\"Insulation resistance of cable(Mohm) :\",R_ins/10.**6.)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Insulation resistance of cable(Mohm) : 53.55\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E3 - Pg 274" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Resistivity\n", + "#Given data :\n", + "import math\n", + "l=3000.##cm\n", + "d1=1.5##cm\n", + "r1=d1/2.##cm\n", + "d2=5.##cm\n", + "r2=d2/2.##cm\n", + "R_INS=1800.##Mohm\n", + "rho=R_INS*10**6*(2*math.pi*l)/math.log(r2/r1)##ohm-m\n", + "print '%s %.2e' %(\"Resistivity (ohm-m) :\",rho)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Resistivity (ohm-m) : 2.82e+13\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E4 - Pg 276" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Maximum electrostatic stress,Minimum electrostatic stress,Capacitance per km length,Charging Current per phase per km length\n", + "#Given data :\n", + "import math\n", + "V1=11000.##Volt\n", + "f=50.##Hz\n", + "a=0.645##cm**2\n", + "d=math.sqrt(4.*a/math.pi)##cm\n", + "d=d/100.##m\n", + "D=2.18/100.##m\n", + "epsilon_r=3.5##relative permitivity\n", + "V=V1*math.sqrt(2.)/math.sqrt(3.)##V(assuming 3 phase system)\n", + "gmax=2.*V/d/math.log(D/d)##V/m\n", + "gmax=gmax/10.**5.##KV/cm\n", + "print '%s %.2f' %(\"Maximum electrostatic stress(kV/cm)\",gmax)#\n", + "gmin=2.*V/D/math.log(D/d)##V/m\n", + "gmin=gmin/10.**5.##kV/cm\n", + "print '%s %.3f' %(\"Minimum electrostatic stress(kV/cm)\",gmin)#\n", + "C=0.024*epsilon_r/math.log10(D/d)##micro F\n", + "print '%s %.2e' %(\"Capacitance per km length(F)\",C*10.**-6)##\n", + "Vp=V1/math.sqrt(3.)##V\n", + "Ic=2.*math.pi*f*C*10.**-6*Vp##A\n", + "print '%s %.2f' %(\"Charging Current per phase per km length(A)\",Ic)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Maximum electrostatic stress(kV/cm) 22.58\n", + "Minimum electrostatic stress(kV/cm) 9.387\n", + "Capacitance per km length(F) 2.20e-07\n", + "Charging Current per phase per km length(A) 0.44\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E5 - Pg 277" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Maximum electrostatic stress,Total charging\n", + "import math\n", + "#Given data :\n", + "VL=33.*1000.##Volt\n", + "f=50.##Hz\n", + "l=3.4##km\n", + "d=2.5##cm\n", + "radial_thick=0.6##cm\n", + "epsilon_r=3.1##relative permitivity\n", + "V=VL*math.sqrt(2.)/math.sqrt(3.)##V(assuming 3 phase system)\n", + "D=d+2.*radial_thick##cm\n", + "D=D/100.##cm\n", + "d=d/100.##m\n", + "gmax=2.*V/d/math.log(D/d)##V/m\n", + "print '%s %.2e' %(\"Maximum electrostatic stress(V/m)\",gmax)#\n", + "C=0.024*epsilon_r*l/math.log10(D/d)##micro F\n", + "Vp=VL/math.sqrt(3.)##V\n", + "Ic=2.*math.pi*f*C*10.**-6*Vp##A\n", + "kVA=math.sqrt(3.)*VL*Ic*10.**-3##kVAR\n", + "print '%s %.2f' %(\"Total charging kVA(kVAR)\",kVA)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Maximum electrostatic stress(V/m) 5.50e+06\n", + "Total charging kVA(kVAR) 508.29\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E6 - Pg 278" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Diameter of conductor,Internal diameter of sheath\n", + "import math\n", + "#Given data :\n", + "VL=10.*1000.##Volt\n", + "Emax=23.##kV/cm\n", + "gmax=Emax*10.**5.##V/m\n", + "d=2.*VL/gmax##m\n", + "print '%s %.1f' %(\"Diameter of conductor(mm)\",d*10.**3.)#\n", + "D=math.e*d##m\n", + "print '%s %.2f' %(\"Internal diameter of sheath(mm)\",D*10.**3.)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Diameter of conductor(mm) 8.7\n", + "Internal diameter of sheath(mm) 23.64\n" + ] + } + ], + "prompt_number": 23 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E7 - Pg 278" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Diameter of conductor,Internal diameter of sheath\n", + "import math\n", + "#Given data :\n", + "VL=132.*1000.##Volt\n", + "gmax=60.##kV/cm(peak)\n", + "gmax=gmax/math.sqrt(2.)*10.**5.##V/m(rms)\n", + "V=VL/math.sqrt(3.)##Volt\n", + "d=2.*V/gmax##m\n", + "print '%s %.1f' %(\"Diameter of conductor(mm)\",d*10.**3.)#\n", + "D=math.e*d##m\n", + "print '%s %.2f' %(\"Internal diameter of sheath(mm)\",D*10.**3.)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Diameter of conductor(mm) 35.9\n", + "Internal diameter of sheath(mm) 97.66\n" + ] + } + ], + "prompt_number": 24 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E8 - Pg 280" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate RMS value of max safe working voltage\n", + "import math\n", + "#Given data :\n", + "r=0.5##cm\n", + "R=3.5##cm\n", + "r1=1.##cm\n", + "g1max=34.##kV/cm(peak)\n", + "epsilon_r=5.##relative permitivity\n", + "g2max=g1max*r/r1/epsilon_r##kV/cm(peak)\n", + "Vpeak=r*g1max*math.log(r1/r)+r1*g2max*math.log(R/r1)##kV\n", + "Vrms=Vpeak/math.sqrt(2.)##kV\n", + "print '%s %.2f' %(\"RMS value of max safe working voltage(kV)\",Vrms)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "RMS value of max safe working voltage(kV) 11.34\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E9 - Pg 281" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "##calculate Radial thickness of inner dielectric,Radial thickness of outer dielectric,Maximum working voltage\n", + "import math\n", + "#Given data :\n", + "g1max=60.##kV/cm\n", + "g2max=50.##kV/cm\n", + "epsilon_r1=4.##relative permitivity\n", + "epsilon_r2=2.5##relative permitivity\n", + "D=5.##cm(sheat inside diameter)\n", + "d=1.##cm\n", + "#g1max/g2max=epsilon_r2*d1/(epsilon_r1*d)\n", + "d1=g1max/g2max/epsilon_r2*(epsilon_r1*d)##cm\n", + "t_inner=(d1-d)/2.##cm\n", + "print '%s %.1f' %(\"Radial thickness of inner dielectric(mm)\",t_inner*10.)#\n", + "t_outer=(D-d1)/2.##cm\n", + "print '%s %.1f' %(\"Radial thickness of outer dielectric(mm)\",t_outer*10.)#\n", + "Vpeak=g1max/2.*d*math.log(d1/d)+g2max/2*d1*math.log(D/d1)##kV\n", + "Vrms=Vpeak/math.sqrt(2.)##kV\n", + "print '%s %.2f' %(\"Maximum working voltage(rms in kV)\",Vrms)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Radial thickness of inner dielectric(mm) 4.6\n", + "Radial thickness of outer dielectric(mm) 15.4\n", + "Maximum working voltage(rms in kV) 46.32\n" + ] + } + ], + "prompt_number": 25 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E10 - Pg 281" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "##calculate Working voltage(rms) for the cable\n", + "#Given data :\n", + "import math\n", + "r=1.##cm\n", + "R=2.5##cm\n", + "d=2.*r##cm\n", + "D=2.*R##cm\n", + "epsilon_r1=5.##relative permitivity\n", + "epsilon_r2=4.##relative permitivity\n", + "epsilon_r3=3.##relative permitivity\n", + "gmax=40.##KV/cm\n", + "#epsilon_r1*d=epsilon_r2*d1=epsilon_r3*d2\n", + "d1=(epsilon_r1/epsilon_r2)*d##cm\n", + "d2=(epsilon_r1/epsilon_r3)*d##cm\n", + "Vpeak=gmax/2.*(d*math.log(d1/d)+d1*math.log(d2/d1)+d2*math.log(D/d2))##kV\n", + "Vrms=Vpeak/math.sqrt(2.)##kV\n", + "print '%s %.1f' %(\"Working voltage(rms) for the cable (kV)\",Vrms)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Working voltage(rms) for the cable (kV) 35.6\n" + ] + } + ], + "prompt_number": 26 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E11 - Pg 282" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Potential gradient at the surface of conductor,Maximum stress in the outer dielectric,Stress at the surface of outer dielectric\n", + "import math\n", + "#Given data :\n", + "Vs=66.##kV\n", + "d=1.##cm\n", + "d1=1.+2.*1.##cm\n", + "D=3.+2.*1.##cm\n", + "epsilon_r1=3.##relative permitivity\n", + "epsilon_r2=2.5##relative permitivity\n", + "g2maxBYg1max=d*epsilon_r1/(d1*epsilon_r2)#\n", + "Vmax=Vs*math.sqrt(2.)/math.sqrt(3.)##kV\n", + "#Vmax=g1max*d/2*log(d1/d)+g2max*d1/2*log(D/d1)##kV\n", + "g1max=Vmax/(d/2.*math.log(d1/d)+g2maxBYg1max*d1/2.*math.log(D/d1))##kV/cm\n", + "print '%s %.f' %(\"Potential gradient at the surface of conductor(kV/cm)\",g1max)#\n", + "g2max=g1max*g2maxBYg1max##kV/cm\n", + "print '%s %.1f' %(\"Maximum stress in the outer dielectric(kV/cm)\",g2max)#\n", + "Stress=g2max*d1/D##kV/cm\n", + "print '%s %.2f' %(\"Stress at the surface of outer dielectric(kV/cm)\",Stress)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Potential gradient at the surface of conductor(kV/cm) 63\n", + "Maximum stress in the outer dielectric(kV/cm) 25.2\n", + "Stress at the surface of outer dielectric(kV/cm) 15.11\n" + ] + } + ], + "prompt_number": 27 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E12 - Pg 282" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Potential gradient at the surface of conductor,Maximum stress in the outer dielectric\n", + "import math\n", + "#Given data :\n", + "Vs=66.##kV\n", + "d=2.##cm\n", + "d1=2.+2.*1.##cm\n", + "D=4.+2.*1.##cm\n", + "epsilon_r1=5.##relative permitivity\n", + "epsilon_r2=3.##relative permitivity\n", + "g2maxBYg1max=d*epsilon_r1/(d1*epsilon_r2)#\n", + "Vmax=Vs*math.sqrt(2.)/math.sqrt(3.)##kV\n", + "#Vmax=g1max*d/2*log(d1/d)+g2max*d1/2*log(D/d1)##kV\n", + "g1max=Vmax/(d/2.*math.log(d1/d)+g2maxBYg1max*d1/2.*math.log(D/d1))##kV/cm\n", + "print '%s %.2f' %(\"Potential gradient at the surface of conductor(kV/cm)\",g1max)#\n", + "g2max=g1max*g2maxBYg1max##kV/cm\n", + "print '%s %.1f' %(\"Maximum stress in the outer dielectric(kV/cm)\",g2max)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Potential gradient at the surface of conductor(kV/cm) 39.37\n", + "Maximum stress in the outer dielectric(kV/cm) 32.8\n" + ] + } + ], + "prompt_number": 28 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E13 - Pg 283" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Inner diameter of lead sheath\n", + "import math\n", + "#Given data :\n", + "Vs=66.##kV\n", + "r=0.5##cm\n", + "g1max=50.##kV/cm\n", + "g2max=40.##kV/cm\n", + "g3max=30.##kV/cm\n", + "epsilon_r1=4.##relative permitivity\n", + "epsilon_r2=4.##relative permitivity\n", + "epsilon_r3=2.5##relative permitivity\n", + "#Q=2*%pi*epsilon0*epsilon_r1*r*g1max=2*%pi*epsilon0*epsilon_r2*r*g2max=2*%pi*epsilon0*epsilon_r3*r*g3max\n", + "r1=epsilon_r1*r*g1max/(epsilon_r2*g2max)##cm\n", + "r2=epsilon_r2*r1*g2max/(epsilon_r3*g3max)##cm\n", + "Vmax=Vs*math.sqrt(2.)##kV\n", + "#Vmax=g1max*r*log(r1/r)+g2max*r1*log(r2/r1)+g3max*r2*log(R/r2)##kV\n", + "R=math.exp((Vmax-g1max*r*math.log(r1/r)-g2max*r1*math.log(r2/r1))/g3max/r2)*r2##cm\n", + "D=2.*R##cm\n", + "print '%s %.1f' %(\"Inner diameter of lead sheath(cm)\",D)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Inner diameter of lead sheath(cm) 14.9\n" + ] + } + ], + "prompt_number": 29 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E14 - Pg 283" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Voltage between sheath & intersheath\n", + "import math \n", + "#Given data :\n", + "Vrms=66.##kV\n", + "Vmax=Vrms*math.sqrt(2.)##kV\n", + "gmax=60.##kV/cm\n", + "d=2.*Vmax/math.e/gmax##cm\n", + "d1=math.e*d##cm\n", + "V1=Vrms/math.e##kV\n", + "dV=Vrms-V1##kV(Voltage between sheath & intersheath)\n", + "print '%s %.2f' %(\"Voltage between sheath & intersheath(kV)\",dV)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Voltage between sheath & intersheath(kV) 41.72\n" + ] + } + ], + "prompt_number": 14 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E15 - Pg 284" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Maximum stress without intersheath,Peak voltage on 1st intersheath,Peak voltage on 2nd intersheath\n", + "import math\n", + "#Given data :\n", + "Vs=66.##kV\n", + "Vmax=Vs*math.sqrt(2.)/math.sqrt(3.)##kV\n", + "D=6.##cm\n", + "d=2.5##cm\n", + "d1=math.e*d##cm\n", + "gmax=2.*Vmax/d/math.log(D/d)##kV/cm\n", + "print '%s %.2f' %(\"Maximum stress without intersheath(kV/cm)\",gmax)#\n", + "#d1/d=d2/d1=D/d2=alfa(say)\n", + "alfa=(D/d)**(1./3.)#\n", + "d1=alfa*d##cm\n", + "d2=alfa*d1##cm\n", + "gmax=Vmax/(d/2*math.log(d1/d)+d1/2.*math.log(d2/d1)+d2/2.*math.log(D/d2))##kV/cm\n", + "V1max=gmax*d/2.*math.log(d1/d)##kV\n", + "V2max=gmax*d1/2.*math.log(d2/d1)##kV\n", + "Vpeak1=Vmax-V1max##kV\n", + "print '%s %.4f' %(\"Peak voltage on 1st intersheath(kV)\",Vpeak1)#\n", + "Vpeak2=Vpeak1-V2max##kV\n", + "print '%s %.4f' %(\"Peak voltage on 2nd intersheath(kV)\",Vpeak2)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Maximum stress without intersheath(kV/cm) 49.24\n", + "Peak voltage on 1st intersheath(kV) 40.8452\n", + "Peak voltage on 2nd intersheath(kV) 23.3815\n" + ] + } + ], + "prompt_number": 15 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E16 - Pg 286" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Capacitance of core to neutral,Capacitance between any two core,Charging current per phase\n", + "import math\n", + "#Given data :\n", + "Vs=11.##kV\n", + "f=50.##Hz\n", + "l=2.5*1000.##m\n", + "C_all3=1.8##micro F\n", + "Cdash=1.5##micro F(2*Cc+Cs)\n", + "Cs=C_all3/3.##micro F\n", + "Cc=(Cdash-Cs)/2.##micro F\n", + "C_N=3.*Cc+Cs##micro F\n", + "print '%s %.2f' %(\"Capacitance of core to neutral(micro F)\",C_N)#\n", + "C_2=C_N/2.##micro F\n", + "print '%s %.3f' %(\"Capacitance between any two core(micro F)\",C_2)#\n", + "Vp=Vs*1000./math.sqrt(3.)##Volt\n", + "Ic=2.*math.pi*f*Vp*C_N*10.**-6##A\n", + "print '%s %.2f' %(\"Charging current per phase(A)\",Ic)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Capacitance of core to neutral(micro F) 1.95\n", + "Capacitance between any two core(micro F) 0.975\n", + "Charging current per phase(A) 3.89\n" + ] + } + ], + "prompt_number": 16 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E17 - Pg 287" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate kVA taken by the cable\n", + "import math\n", + "#Given data :\n", + "l=10.##km\n", + "Vs=10.##kV\n", + "f=50.##Hz\n", + "C=0.3##micro F/km(between any two core)\n", + "C2=l*C##micro F(between any two core)\n", + "C_N=2.*C2##micro F\n", + "Vp=Vs*1000./math.sqrt(3.)##Volt\n", + "Ic=2.*math.pi*f*Vp*C_N*10.**-6##A\n", + "kVA=3.*Vp*Ic/1000.##kVAR\n", + "print '%s %.1f' %(\"kVA taken by the cable(kVAR)\",kVA)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "kVA taken by the cable(kVAR) 188.5\n" + ] + } + ], + "prompt_number": 30 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E18 - Pg 287" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Capacitance between any two cores,Capacitance between any two shorted conductors and third conductor\n", + "import math\n", + "#Given data :\n", + "Cs3=1.##micro F/km(between shorted conductor)\n", + "Cs=Cs3/3.##micro F\n", + "Cdash=0.6##micro F(Cdash=2*Cc+Cs : between two shorted conductor)\n", + "Cc=(Cdash-Cs)/2.##micro F\n", + "C2=1./2.*(3*Cc+Cs)##micro F\n", + "print '%s %.4f' %(\"Capacitance between any two cores(micro F)\",C2)#\n", + "C2dash=2.*Cc+2./3.*Cs##micro F\n", + "print '%s %.3f' %(\"Capacitance between any two shorted conductors and third conductor(micro F)\",C2dash)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Capacitance between any two cores(micro F) 0.3667\n", + "Capacitance between any two shorted conductors and third conductor(micro F) 0.489\n" + ] + } + ], + "prompt_number": 31 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E19 - Pg 287" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Total charging kVAR,Maximum stress in the cable\n", + "import math\n", + "#Given data :\n", + "Vs=33.##kV\n", + "f=50.##Hz\n", + "l=3.4##km\n", + "d=2.5##cm\n", + "D=d+2.*0.6##cm\n", + "epsilon_r=3.1##relative permitivity\n", + "C=0.024*epsilon_r/math.log10(D/d)*l*1000.*1000.*10.**-6## F/phase\n", + "Vp=Vs*1000./math.sqrt(3.)##Volt\n", + "Ic=2.*math.pi*f*C*10.**-6*Vp##A\n", + "kVAR=3.*Vp*Ic*10.**-3##kVAR\n", + "print '%s %.2f' %(\"Total charging kVAR : \",kVAR)#\n", + "Emax=Vp/(d/2.*math.log(D/d))*10.**-3##kV/cm\n", + "print '%s %.2f' %(\"Maximum stress in the cable(kV/cm) \",Emax)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Total charging kVAR : 508.29\n", + "Maximum stress in the cable(kV/cm) 38.88\n" + ] + } + ], + "prompt_number": 19 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E20 - Pg 291" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Capacitance of the cable,Charging current,Dielectric loss,Equivalent insulation resistance\n", + "import math\n", + "#Given data :\n", + "Vs=11.##kV\n", + "f=50.##Hz\n", + "D=2.##cm\n", + "d=0.5##cm\n", + "epsilon_r=3.5##relative permitivity\n", + "pf=0.05##power factor\n", + "C=0.024*epsilon_r/math.log10(D/d)*10.**-6## F/km\n", + "print '%s %.4f' %(\"Capacitance of the cable(micro F)\",C*10.**6.)#\n", + "Vp=Vs*1000./math.sqrt(3.)##Volt\n", + "Ic=2.*math.pi*f*C*Vp##A\n", + "print '%s %.3f' %(\"Charging current(A)\",Ic)#\n", + "fi=math.acos(pf) *180./math.pi##degree\n", + "dela= 90.-fi##degree(Dielectric loss angle)\n", + "loss_dielectric=2*math.pi*f*C*Vp**2*math.tan(dela*math.pi/180.)##W\n", + "print '%s %.1f' %(\"Dielectric loss(W)\",loss_dielectric)#\n", + "R_INS=Vp**2./loss_dielectric##ohm\n", + "print '%s %.3f' %(\"Equivalent insulation resistance(Mohm)\",R_INS/10.**6.)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Capacitance of the cable(micro F) 0.1395\n", + "Charging current(A) 0.278\n", + "Dielectric loss(W) 88.5\n", + "Equivalent insulation resistance(Mohm) 0.456\n" + ] + } + ], + "prompt_number": 21 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E21 - Pg 292" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Loss angle,No load current drawn by cable\n", + "import math \n", + "#Given data :\n", + "Vs=11.##kV\n", + "f=50.##Hz\n", + "C_N_by_2=2.5##micro F(between 2 core 1 core shorted)\n", + "C_N=C_N_by_2*2.##micro F\n", + "Vp=Vs*1000./math.sqrt(3.)##Volt\n", + "Ic=2.*math.pi*f*Vp*C_N*10.**-6##A\n", + "R_INS2=810.##kohm\n", + "R_INS=R_INS2/2.##kohm\n", + "dela=math.atan(1./(R_INS*10.**3.*2.*math.pi*f*C_N*10.**-6)) *180/math.pi##degree\n", + "print '%s %.2f' %(\"Loss angle(degree)\",dela)#\n", + "Ie=Vp/R_INS/1000.##A\n", + "I=math.sqrt(Ic**2.+Ie**2.)##A\n", + "print '%s %.3f' %(\"No load current drawn by cable(A)\",I)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Loss angle(degree) 0.09\n", + "No load current drawn by cable(A) 9.976\n" + ] + } + ], + "prompt_number": 22 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Elements_of_Power_system/Chapter_12.ipynb b/Elements_of_Power_system/Chapter_12.ipynb new file mode 100755 index 00000000..a83c113d --- /dev/null +++ b/Elements_of_Power_system/Chapter_12.ipynb @@ -0,0 +1,101 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:c04662c5bd4f38db1beb13d324aa5f4b0617ec914f453499de17aa02ac050633" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 12 - NEUTRAL GROUNDING" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Ecample E1 - Pg 311" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Reactance of coil\n", + "#Given data :\n", + "import math\n", + "f=50.##Supply frequency in Hz\n", + "C=4.5*10.**-6##in Farad\n", + "Omega_L=1./3./2./math.pi/f/C##in ohm\n", + "print '%s %.2f' %(\"Reactance of coil (ohm) :\",Omega_L)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Reactance of coil (ohm) : 235.79\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Ecample E2 - Pg 311" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Necessary Inductance of peterson coil,Rating of supressor coil in MVA\n", + "#Given data :\n", + "import math\n", + "V=132.*1000.##V\n", + "f=50.##Hz\n", + "r=10./1000.##m\n", + "d1=4.##m\n", + "d2=4.##m\n", + "d3=d1+d2##m\n", + "epsilon_o=8.854*10.**-12##constant\n", + "l_tl=192.*1000.##length of transmission line in m\n", + "C=2.*math.pi*epsilon_o/math.log((d1*d2*d3)**(1./3.)/r)*l_tl##in Farad\n", + "L=1./3./(2.*math.pi*f)**2./C##H\n", + "print '%s %.3f' %(\"Necessary Inductance of peterson coil in H : \",L)#\n", + "VP=V/math.sqrt(3.)##V\n", + "IL=VP/(2.*math.pi*f)/L##A\n", + "Rating=VP*IL/1000.##kVA\n", + "print '%s %.2f' %(\"Rating of supressor coil in MVA :\",Rating/1000)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Necessary Inductance of peterson coil in H : 1.968\n", + "Rating of supressor coil in MVA : 9.40\n" + ] + } + ], + "prompt_number": 2 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Elements_of_Power_system/Chapter_2.ipynb b/Elements_of_Power_system/Chapter_2.ipynb new file mode 100755 index 00000000..528910b1 --- /dev/null +++ b/Elements_of_Power_system/Chapter_2.ipynb @@ -0,0 +1,273 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:58c36c7b9784275db9287ae8c79867925c020abc46926776ba50c0c166f1d15f" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 2 - SUPPLY SYSTEM" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E1 - Pg 40" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate saving in copper\n", + "#Given data :\n", + "VL1=220.##Volts\n", + "VL2=400.##Volts\n", + "print '%s' %(\"We know, W=I**2*2*R=(P/VL)**2*2*rho*l/a\")#\n", + "print '%s ' %(\"a=(P/VL)**2*2*rho*l/(I**2*2*R)\")#\n", + "print '%s' %(\"v=2*(P/VL)**2*2*rho*l/(I1**2*2)*l\")#\n", + "saving=(2./(VL1)**2.-2./(VL2)**2.)/(2./(VL1)**2.)*100.##%\n", + "print '%s %.2f' %(\"% saving in copper : \",saving)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "We know, W=I**2*2*R=(P/VL)**2*2*rho*l/a\n", + "a=(P/VL)**2*2*rho*l/(I**2*2*R) \n", + "v=2*(P/VL)**2*2*rho*l/(I1**2*2)*l\n", + "% saving in copper : 69.75\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E2 - pg 51" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate 3-phase four wire system material required\n", + "print '%s' %(\"Two wire dc system : \")#\n", + "print '%s' %(\"I1=P/V & W=2*I1**2*R1=2*P**2*rho*l/V**2/a1\")#\n", + "print '%s' %(\"Therefore, Volume required, v1 is 2*a1*l=4*P**2*rho*l**2/V**2/W\")#\n", + "print '%s ' %(\"Three phase four wire system : \")#\n", + "print '%s ' %(\"I2=P/3/Vas Power by each phase is P/3 & W=3*I1**2*R2=P**2*rho*l/3/V**2/a2\")#\n", + "print '%s ' %(\"Therefore, Volume required, v2 is 3.5*a2*l=3.5*P**2*rho*l**2/3/V**2/W\")#\n", + "v2BYv1=3.5/3./4.##\n", + "print '%s %.3f %s' %(\"For 3-phase four wire system material required is \",v2BYv1,\" times the material required in two wire system.\")#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Two wire dc system : \n", + "I1=P/V & W=2*I1**2*R1=2*P**2*rho*l/V**2/a1\n", + "Therefore, Volume required, v1 is 2*a1*l=4*P**2*rho*l**2/V**2/W\n", + "Three phase four wire system : \n", + "I2=P/3/Vas Power by each phase is P/3 & W=3*I1**2*R2=P**2*rho*l/3/V**2/a2 \n", + "Therefore, Volume required, v2 is 3.5*a2*l=3.5*P**2*rho*l**2/3/V**2/W \n", + "For 3-phase four wire system material required is 0.292 times the material required in two wire system.\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E3 - Pg 52" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Additional load that can be tranmitted by converting sigle to 3-phase line\n", + "import math\n", + "print '%s ' %(\"For single phase ac system, P1=V*I1*cosd(fi) watts & W1=2*I1**2*R watts\")#\n", + "print '%s ' %(\"Line losses=W1/P1*100=2*I1**2*R*100/V/I1/cosd(fi)\")#\n", + "print '%s ' %(\"For three phase ac system, P2=sqrt(3)*V*I2*cosd(fi) watts & W2=3*I2**2*R watts\")#\n", + "print '%s ' %(\"Line losses=W2/P2*100=3*I2**2*R*100/sqrt(3)/V/I2/cosd(fi)\")#\n", + "#on equating W1/P1*100.=W2/P2*100.\n", + "I2BYI1=2*math.sqrt(3.)/3.#\n", + "P1=100\n", + "P2=2*P1#\n", + "Add_load=P2-P1#\n", + "Percent_add_load=(P2-P1)/P1*100##%\n", + "print '%s %.2f' %(\"Additional load that can be tranmitted by converting sigle to 3-phase line in %\",Percent_add_load)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "For single phase ac system, P1=V*I1*cosd(fi) watts & W1=2*I1**2*R watts \n", + "Line losses=W1/P1*100=2*I1**2*R*100/V/I1/cosd(fi) \n", + "For three phase ac system, P2=sqrt(3)*V*I2*cosd(fi) watts & W2=3*I2**2*R watts \n", + "Line losses=W2/P2*100=3*I2**2*R*100/sqrt(3)/V/I2/cosd(fi) \n", + "Additional load that can be tranmitted by converting sigle to 3-phase line in % 100.00\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E4 - Pg 53 " + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Extra power that can be supplied\n", + "print '%s' %(\"For three wire dc system, line current I1=(VS-VL)/R & P1=2*VL*I1=2*VL*(VS-VL)/R\")#\n", + "print '%s' %(\"For four wire three phase ac system, line current I2=(VS-VL)/R & P2=3*VL*I2*pf=3*VL*(VS-VL)/R\")#\n", + "#P2=3/2*2*VL*(VS-VL)/R##It implies that P2=3/2*P1\n", + "P1=100#\n", + "P2=3./2.*P1#\n", + "Diff=P2-P1#\n", + "Percent_Diff=(Diff/P1*100)##%\n", + "print '%s %.2f' %(\"Extra power that can be supplied in %\",Percent_Diff)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "For three wire dc system, line current I1=(VS-VL)/R & P1=2*VL*I1=2*VL*(VS-VL)/R\n", + "For four wire three phase ac system, line current I2=(VS-VL)/R & P2=3*VL*I2*pf=3*VL*(VS-VL)/R\n", + "Extra power that can be supplied in % 50.00\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E5 - Pg 53" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Additional load\n", + "pf=0.9##power factor\n", + "print '%s' %(\"Three wire dc system : \")#\n", + "print '%s' %(\"P1=2*I1*V & %P1loss=2*I1**2*R/(2*I1*V)*100=100*I1*R/V\")#\n", + "print '%s' %(\"Three phase 4-wire ac system : \")#\n", + "print '%s' %(\"P2=3*I1**2*V*pf & %P2loss=3*I2**2*R/(3*I2*V*pf)*100=100*I12*R/pf/V\")#\n", + "#on equating P1loss=P2loss#\n", + "I2BYI1=100*pf/100##ratio\n", + "#P2=3*I2*V*pf\n", + "P2BYI1V=3.*pf*I2BYI1#\n", + "P2BYP1=P2BYI1V/2.#\n", + "#LoadIncrease=(P2-P1)*100/P1#\n", + "LoadIncrease=(P2BYP1-1.)*100.##%\n", + "print '%s %.2f' %(\"% Additional load : \",LoadIncrease)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Three wire dc system : \n", + "P1=2*I1*V & %P1loss=2*I1**2*R/(2*I1*V)*100=100*I1*R/V\n", + "Three phase 4-wire ac system : \n", + "P2=3*I1**2*V*pf & %P2loss=3*I2**2*R/(3*I2*V*pf)*100=100*I12*R/pf/V\n", + "% Additional load : 21.50\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E6 - Pg 57" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Weight of copper required for 3 conductors of 100 km length\n", + "#Given data :\n", + "import math\n", + "Pin=100.##MW\n", + "VL=380.##kV\n", + "d=100.##km\n", + "R=0.045##ohm/cm**2/km\n", + "w=0.01##kg/cm**3\n", + "Eta=90.##efficiency %\n", + "cosfi=1.#\n", + "IL=Pin*10.**6./math.sqrt(3.)/VL/10.**3./cosfi##Ampere\n", + "W=Pin*(1-Eta/100)##MW\n", + "LineLoss=W*10**6/3##Watts/conductor\n", + "R1=LineLoss/IL**2##in ohm\n", + "R2=R1/d##resistance per conductor per km\n", + "a=R/R2##in cm**2\n", + "volume=a*d*1000##cm**3 per km run\n", + "weight=w*volume##kg per km run\n", + "w3=3.*d*weight##kg(weight of copper required for 3 conductors for 100 km)\n", + "print '%s %.2f' %(\"Weight of copper required for 3 conductors of 100 km length(in kg) : \",w3)#\n", + "#Answer in the book is not accurate.\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Weight of copper required for 3 conductors of 100 km length(in kg) : 9349.03\n" + ] + } + ], + "prompt_number": 6 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Elements_of_Power_system/Chapter_3.ipynb b/Elements_of_Power_system/Chapter_3.ipynb new file mode 100755 index 00000000..81522bb9 --- /dev/null +++ b/Elements_of_Power_system/Chapter_3.ipynb @@ -0,0 +1,368 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:8ef5a6db25d3ca5636ebb9bdfef72dd38c306363688bdeed8ee7c50c70ef98c0" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 3 - TRANSMISSION LINES" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E1 - Pg 66" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Weight of copper required,Alluminium required\n", + "#Given data :\n", + "import math\n", + "P=30.*10.**6.##W\n", + "pf=0.8##lagging power factor\n", + "VL=132.*1000.##V\n", + "l=120.*1000.##m\n", + "Eta=90./100.##Efficiency\n", + "rho_Cu=1.78*10.**-8.##ohm-m\n", + "D_Cu=8.9*10.**3.##kg/m**3\n", + "rho_Al=2.6*10.**-8.##ohm-m\n", + "D_Al=2.*10.**3.##kg/m**3\n", + "IL=P/(math.sqrt(3.)*VL*pf)##A\n", + "#W=3.*IL**2.*rho*l/a=(1-Eta)*P\n", + "a_Cu=(3.*IL**2.*rho_Cu*l)/(1.-Eta)/P##m**2\n", + "V_Cu=3.*a_Cu*l##m**3\n", + "Wt_Cu=V_Cu*D_Cu##kg\n", + "print '%s %.2f' %(\"Weight of copper required(kg)\",Wt_Cu)#\n", + "a_Al=(3.*IL**2.*rho_Al*l)/(1.-Eta)/P##m**2\n", + "V_Al=3.*a_Al*l## m**3\n", + "Wt_Al=V_Al*D_Al##kg\n", + "print '%s %.2f' %(\"Weight of Alluminium required(kg)\",Wt_Al)#\n", + "#Answer in the textbook is not accurate.\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Weight of copper required(kg) 184114.15\n", + "Weight of Alluminium required(kg) 60433.88\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E2 - Pg 70" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Most economical cross sectional area\n", + "#Given data :\n", + "import math\n", + "a=100.#\n", + "cost=90.*a+20.##Rs./m\n", + "i=10.##%(interest and depreciation)\n", + "l=2.##km\n", + "cost_E=4.##paise/unit\n", + "Im=250.##A\n", + "a=1.##cm**2\n", + "rho_c=0.173##ohm/km/cm**2\n", + "l2=1.*1000.##km\n", + "R=rho_c*l/a##ohm\n", + "W=2.*Im**2.*R##W\n", + "Eloss=W/1000.*365.*24./2.##per annum(kWh)\n", + "P3BYa=cost_E/100.*Eloss##Rs\n", + "Cc=90.*a*l*1000.##Rs(capital cost of feeder cable)\n", + "P2a=Cc*i/100.##Rs\n", + "#P2a=P3BYa##For most economical cross section\n", + "a=math.sqrt(P3BYa*a/(P2a/a))##cm**2\n", + "print '%s %.3f' %(\"Most economical cross sectional area in cm**2 : \",a)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Most economical cross sectional area in cm**2 : 0.649\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E3 - Pg 71" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Best current density\n", + "#Given data :\n", + "import math\n", + "t=2600.##hour\n", + "Con_Cost=3.##Rs/kg(conductor cost)\n", + "R=1.78*10.**-8.##ohm-m\n", + "D=6200.##kg/m**3\n", + "E_Cost=10./100.##Rs/unit(energy cost)\n", + "i=12.##%(interest and depreciation)\n", + "a=100.##mm**2 ##cross sectional area\n", + "W=a*1000.*D/1000./1000.##kg/km(Weight of conductor of 1km length)\n", + "cost=Con_Cost*W##Rs./km(cost of conductor of 1km length)\n", + "In_Dep=cost*i/100.##Rs(Annual interest and depreciation per conductor per km)\n", + "In_DepBYa=In_Dep/a#\n", + "I=100.##A\n", + "E_lost_aBY_Isqr=R*1000./10.**-6.*t/1000.##Energy lost/annum/km/conductor\n", + "E_lost_cost_aBY_Isqr=E_Cost*E_lost_aBY_Isqr##Rs/annum\n", + "#In_Dep=E_lost_cost##For most economical cross section\n", + "IBYa=math.sqrt((In_DepBYa))/(E_lost_cost_aBY_Isqr)##cm**2\n", + "print '%s %.2f' %(\"Best current density in A/mm**2 : \",IBYa)#\n", + "#Answer in the textbook is not accurate.\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Best current density in A/mm**2 : 0.32\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E4 - Pg 71" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Diameter of conductor,Most economical current density\n", + "#Given data :\n", + "import math\n", + "V=11.##kV\n", + "P=1500.##kW\n", + "pf=0.8##lagging power factor\n", + "t=300.*8.##hours\n", + "a=100.##cross section area\n", + "Cc=8000.+20000.*a#Rs/km\n", + "R=0.173/a##ohm/km\n", + "E_lost_cost=2./100.##Rs/unit\n", + "i=12.##%(interest and depreciation)\n", + "Cc_var=20000.*a#Rs/km(variable cost)\n", + "P2a=Cc_var*i/100.##Rs/km\n", + "P2=P2a/a#\n", + "I=P/math.sqrt(3.)/V/pf##A\n", + "W=3.*I**2.*R##W\n", + "E_loss=W/1000.*t##kWh\n", + "P3BYa=E_lost_cost*E_loss##Rs\n", + "#P2a=P3BYa##For most economical cross section\n", + "a=math.sqrt((P3BYa))/(P2)##cm**2\n", + "d=math.sqrt(4.*a/math.pi)##cm\n", + "dela=I/a;##A/cm**2\n", + "print '%s %.2f' %(\"Diameter of conductor in cm : \",d)#\n", + "print '%s %.2f' %(\"Most economical current density in A/cm**2 : \",dela)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Diameter of conductor in cm : 0.03\n", + "Most economical current density in A/cm**2 : 152057.18\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E5 - Pg 72" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Exa 3.5\n", + "#Given data :\n", + "import math\n", + "a=100.##cross section area\n", + "I=100.##Current\n", + "Cc=500.+2000.*a#Rs/km\n", + "i=12.##%(interest and depreciation)\n", + "E_lost_cost=5./100.##Rs/kWh\n", + "rho=1.78*10.**-8.##ohm-cm\n", + "load_factor=0.12#\n", + "Cc_var=2000.*a#Rs/km(variable cost)\n", + "P2a=Cc_var*i/100.##Rs/km\n", + "P2=P2a/a#\n", + "R_into_a=rho*1000./(10.**-4.)##ohm\n", + "W_into_a=I**2*R_into_a##W\n", + "E_loss_into_a=W_into_a*load_factor/1000.*8760.##kWh\n", + "P3BYIsqr=E_lost_cost*E_loss_into_a/I**2##Rs\n", + "#P2a=P3BYa##For most economical cross section\n", + "IBYa=math.sqrt((P2))/(P3BYIsqr)##cm**2\n", + "print '%s %.2f' %(\"Most economical current density in A/cm**2 : \",IBYa)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Most economical current density in A/cm**2 : 1655.89\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E6 - Pg 73" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Exa 3.6\n", + "#Given data :\n", + "import math\n", + "A=100.##cross section area\n", + "I=100.##Current\n", + "Cc=500.+2000.*A#Rs/km\n", + "load_factor=0.12#\n", + "i=12.##%(depreciation)\n", + "E_lost_cost=0.05##Rs/kWh\n", + "R=0.17/A##ohm/km\n", + "Cc_var=2000.*A#Rs/km(variable cost)\n", + "P2A=Cc_var*i/100.##Rs/km\n", + "P2=P2A/A#\n", + "R_into_A=R*A##ohm\n", + "W_into_A_BY_Isqr=R_into_A##W\n", + "E_loss_into_A_BY_Isqr=W_into_A_BY_Isqr*load_factor/1000.*8760.##kWh\n", + "P3BYIsqr=E_lost_cost*E_loss_into_A_BY_Isqr##Rs\n", + "#P2a=P3BYa##For most economical cross section\n", + "IBYa=math.sqrt((P2))/(P3BYIsqr)##cm**2\n", + "print '%s %.2f' %(\"Most economical current density in A/cm**2 : \",IBYa)#\n", + "#Answer in the textbook is wrong.\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Most economical current density in A/cm**2 : 1733.81\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E7 - Pg 73" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Most economical cross sectional area\n", + "#Given data :\n", + "import math\n", + "P1=1000.##kW\n", + "pf1=0.8##\n", + "t1=10.##hours\n", + "P2=500.##kW\n", + "pf2=0.9##\n", + "t2=8.##hours\n", + "P3=100.##kW\n", + "pf3=1.##\n", + "t3=6.##hours\n", + "a=100.##cross section area\n", + "I=100.##Current\n", + "L=100.##length in km\n", + "CcBYL=(8000.*a+1500.)#Rs/km(variable cost)\n", + "i=10.##%(depreciation)\n", + "E_lost_cost=80./100.##Rs/kWh\n", + "rho=1.72*10.**-6.##ohm-cm\n", + "Cc_varBYL=8000.*a*i/100.#Rs/km(variable cost)\n", + "I1=P1*1000./math.sqrt(3.)/10000./pf1##A\n", + "I2=P2*1000./math.sqrt(3.)/10000./pf2##A\n", + "I3=P3*1000./math.sqrt(3.)/10000./pf3##A\n", + "R_into_a_BY_L=rho*1000.*100.##ohm\n", + "W_into_A_BY_Isqr=R_into_a_BY_L##W\n", + "E_loss_into_A_BY_L=3*R_into_a_BY_L*(I1**2*t1+I2**2*t2+I3**2*t3)*365./1000.##kWh\n", + "E_loss_cost_into_A_BY_L=E_loss_into_A_BY_L*E_lost_cost##Rs\n", + "#Cc_var=E_loss_cost##For most economical cross section\n", + "a=math.sqrt((E_loss_cost_into_A_BY_L))/(Cc_varBYL/a)##cm**2\n", + "print '%s %.2f' %(\"Most economical cross sectional area in cm**2 : \",a)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Most economical cross sectional area in cm**2 : 0.12\n" + ] + } + ], + "prompt_number": 7 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Elements_of_Power_system/Chapter_4.ipynb b/Elements_of_Power_system/Chapter_4.ipynb new file mode 100755 index 00000000..db67cdfa --- /dev/null +++ b/Elements_of_Power_system/Chapter_4.ipynb @@ -0,0 +1,1168 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:818ef23f34385ee54f8d5672494c60336bc18fcc46f244fceb4d0fa90c810f66" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 4 - INDUCTANCE AND CAPACITANCE OF TRANSMISSION LINES" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E1 - Pg 85" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Loop inductance,Reactance of transmission line\n", + "#Given data :\n", + "import math\n", + "f=50.##Hz\n", + "d=1.*100.##cm\n", + "r=1.25/2.##cm\n", + "r_dash=r*0.7788##cm\n", + "L=0.4*math.log(d/r_dash)##mH\n", + "print '%s %.2f' %(\"Loop inductance per km(mH)\",L)#\n", + "XL=2.*math.pi*f*L*10.**-3.##ohm/Km\n", + "print '%s %.3f' %(\"Reactance of transmission line(ohm/km)\",XL)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Loop inductance per km(mH) 2.13\n", + "Reactance of transmission line(ohm/km) 0.669\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E2 - Pg 85" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Loop inductance\n", + "#Given data :\n", + "import math\n", + "f=50.##Hz\n", + "a=10.##cm**2\n", + "l=500./1000.##km\n", + "r=math.sqrt(a/math.pi)##cm\n", + "d=5.*100.##cm\n", + "r_dash=r*0.7788##cm\n", + "L=0.4*math.log(d/r_dash)*l##mH\n", + "print '%s %.3f' %(\"Loop inductance per km(mH)\",L)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Loop inductance per km(mH) 1.177\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E3 - Pg 85" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Loop inductance per km of copper conductor line,Loop inductance per km of steel conductor line\n", + "#Given data :\n", + "import math\n", + "r=1./2.##cm\n", + "d=1.*100.##cm\n", + "mu=50.##relative permeability\n", + "r_dash=r*0.7788##cm\n", + "L_cu=.1+0.4*math.log(d/r)##mH\n", + "print '%s %.2f' %(\"Loop inductance per km of copper conductor line(mH)\",L_cu)#\n", + "L_steel=(mu+4.*math.log(d/r))*10.**-7.*10.**3.##mH\n", + "print '%s %.2f' %(\"Loop inductance per km of steel conductor line(mH)\",L_steel*10**3)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Loop inductance per km of copper conductor line(mH) 2.22\n", + "Loop inductance per km of steel conductor line(mH) 7.12\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E4 - Pg 86" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Geometric mean radius\n", + "#Given data :\n", + "import math\n", + "r=3.##mm\n", + "d11=r##mm\n", + "d12=2.*r##mm\n", + "d34=2.*r##mm\n", + "d16=2.*r##mm\n", + "d17=2.*r##mm\n", + "d14=4.*r##mm\n", + "d13=math.sqrt(d14**2.-d34**2.)##mm\n", + "d15=d13##mm\n", + "Ds1=(0.7788*d11*d12*d13*d14*d15*d16*d17)**(1./7.)##mm\n", + "Ds2=Ds1##mm\n", + "Ds3=Ds1##mm\n", + "Ds4=Ds1##mm\n", + "Ds5=Ds1##mm\n", + "Ds6=Ds1##mm\n", + "Ds7=(2.*r*0.7788*d11*d12*d13*2.*r*2.*r)**(1./7.)##mm\n", + "Ds=(Ds1*Ds2*Ds3*Ds4*Ds5*Ds6*Ds7)**(1./7.)##mm\n", + "print '%s %.3f' %(\"Geometric mean radius(mm)\",Ds)#\n", + "#Answer in the book is wrong\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Geometric mean radius(mm) 6.367\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E5 - Pg 86" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Loop inductance of line\n", + "#Given data :\n", + "import math\n", + "r=1.2##cm\n", + "rdash=0.7788*r##cm\n", + "d12=0.12*100.##cm\n", + "d11dash=(0.2+1.2)*100.##cm\n", + "d22dash=(0.2+1.2)*100.##cm\n", + "d12dash=(0.2+1.2+0.2)*100.##cm\n", + "d21dash=(1.2)*100.##cm\n", + "Dm=(d11dash*d12dash*d21dash*d22dash)**(1./4.)##cm\n", + "d11=0.93456##cm\n", + "d22=0.93456##cm\n", + "d12=20.##cm\n", + "d21=20.##cm\n", + "Ds=(d11*d12*d21*d22)**(1./4.)##cm\n", + "L=0.4*math.log(Dm/Ds)##mH/km\n", + "print '%s %.3f' %(\"Loop inductance of line(mH/km)\",L)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Loop inductance of line(mH/km) 1.389\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E6 - Pg 87" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Loop inductance of line\n", + "#Given data :\n", + "import math\n", + "r=2./2.##cm\n", + "rdash=0.7788*r##cm\n", + "d12=0.12*100##cm\n", + "d11dash=300.##cm\n", + "d12dash=math.sqrt(300.**2.+100.**2.)##cm\n", + "d21dash=d12dash##cm\n", + "d22dash=d11dash##cm\n", + "d11=rdash##cm\n", + "d22=rdash##cm\n", + "d12=100.##cm\n", + "d21=100.##cm\n", + "Dm=(d11dash*d12dash*d21dash*d22dash)**(1./4.)##cm\n", + "Ds=(d11*d12*d21*d22)**(1./4.)##cm\n", + "L=0.4*math.log(Dm/Ds)##mH/km\n", + "print '%s %.3f' %(\"Loop inductance of line(mH/km)\",L)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Loop inductance of line(mH/km) 1.421\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + " Example E7 - Pg 89" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Inductance per phase \n", + "#Given data :\n", + "import math\n", + "r=1.24/2##cm\n", + "rdash=0.7788*r##cm\n", + "d=2.*100.##cm\n", + "L=0.2*math.log(d/rdash)##mH\n", + "print '%s %.3f' %(\"Inductance per phase per km(mH)\",L)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Inductance per phase per km(mH) 1.205\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E8 - Pg 89" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Inductance per phase\n", + "#Given data :\n", + "import math\n", + "r=(20./2.)/10.##cm\n", + "d1=4.*100.##cm\n", + "d2=5.*100.##cm\n", + "d3=6.*100.##cm\n", + "rdash=0.7788*r##cm\n", + "L=0.2*math.log((d1*d2*d3)**(1./3.)/rdash)##mH\n", + "print '%s %.2f' %(\"Inductance per phase(mH)\",L)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Inductance per phase(mH) 1.29\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E9 - Pg 90" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Inductance per km of phase1,phase2,phase3\n", + "#Given data :\n", + "import math\n", + "r=4./2.##cm\n", + "rdash=0.7788*r##cm\n", + "d=300.##cm\n", + "d3=6.*100.##cm\n", + "LAr=0.2*(math.log(d/rdash)+1./2.*math.log(2.))\n", + "LAi=0.866*math.log(2.)##mH\n", + "print '%s' %(\"Inductance per km of phase1(mH)\")#\n", + "print '%.4f %s %.2f' %(LAr,'-j',LAi)\n", + "LB=0.2*math.log(d/rdash)##mH\n", + "print '%s %.3f' %(\"Inductance per km of phase2(mH)\",LB)#\n", + "LCr=0.2*(math.log(d/rdash)+1./2.*math.log(2.))\n", + "LCi=0.866*math.log(2.)##mH\n", + "print '%s' %(\"Inductance per km of phase3(mH)\")#\n", + "print '%.4f %s %.2f' %(LCr,'+j',LCi)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Inductance per km of phase1(mH)\n", + "1.1214 -j 0.60\n", + "Inductance per km of phase2(mH) 1.052\n", + "Inductance per km of phase3(mH)\n", + "1.1214 +j 0.60\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E10 - Pg 90" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Spacing between adjacent conductors\n", + "import math\n", + "#Given data :\n", + "r=1.2/2.*10.##mm\n", + "rdash=0.7788*r##mm\n", + "d=3.5*1000.##mm\n", + "L=2.*10.**-7.*math.log(d/rdash)##H/m\n", + "Lav=1./3.*(L+L+L)##H/m\n", + "d=rdash*math.exp(Lav/(2.*10.**-7.)-1./3.*math.log(2.))##mm\n", + "print '%s %.4e' %(\"Spacing between adjacent conductors(m)\",d/1000.)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Spacing between adjacent conductors(m) 2.7780e+00\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E11 - Pg 94" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Spacing between adjacent conductors\n", + "import math\n", + "#Given data :\n", + "r=20.##mm\n", + "rdash=0.7788*r##mm\n", + "d=7.*1000.##mm\n", + "L=10**-7*math.log(math.sqrt(3.)/2.*d/rdash)##H/m\n", + "print '%s %.4f' %(\"Spacing between adjacent conductors(mH)\",L*10.**3./10.**-3.)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Spacing between adjacent conductors(mH) 0.5964\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E12 - Pg 94" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Inductance per phase\n", + "import math \n", + "#Given data :\n", + "r=0.9##cm\n", + "rdash=0.7788*r*10.**-2.##m\n", + "daa_dash=math.sqrt(6.**2.+6.**2.)##m\n", + "dbb_dash=7.##m\n", + "dcc_dash=daa_dash##m\n", + "daa=rdash##m\n", + "d_adash_adash=rdash##m\n", + "d_adash_a=daa_dash##m\n", + "Dsa=(daa*daa_dash*d_adash_adash*d_adash_a)**(1./4.)##m\n", + "Dsb=(daa*7.)**(1./2.)##m\n", + "Dsc=(daa*daa_dash)**(1./2.)##m\n", + "Ds=(Dsa*Dsb*Dsc)**(1./3.)##m\n", + "dab=math.sqrt(3.**2.+0.5**2.)##m\n", + "dab_dash=math.sqrt(3.**2.+6.5**2.)##m\n", + "d_adash_b=math.sqrt(3.**2.+6.5**2.)##m\n", + "d_adash_bdash=math.sqrt(3.**2.+0.5**2.)##m\n", + "Dab=(dab*dab_dash*d_adash_b*d_adash_bdash)**(1./4.)##m\n", + "Dbc=((dab*dab_dash)**2.)**(1./4.)##m\n", + "Dca=((6.*6.)**2.)**(1./4.)##m\n", + "Dm=(Dab*Dbc*Dca)**(1./3.)##m\n", + "L=0.2*math.log(Dm/Ds)##mH/km\n", + "print '%s %.4f' %(\"Inductance per phase(mH/km)\",L)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Inductance per phase(mH/km) 0.6135\n" + ] + } + ], + "prompt_number": 12 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E13 - Pg 95" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate GMD,Deq or Dm,Inductance of 100 km line,Using Alternate method, Inductance of 100 km line\n", + "import math\n", + "#Given data :\n", + "r=5./2.##mm\n", + "rdash=2.176*r*10.**-3.##m\n", + "daa_dash=math.sqrt(6**2+16**2)##m\n", + "dbb_dash=6.##m\n", + "dcc_dash=daa_dash##m\n", + "dab=8.##m\n", + "dab_dash=math.sqrt(6.**2.+8.**2.)##m\n", + "dbc=8.##m\n", + "dbc_dash=math.sqrt(6.**2.+8.**2.)##m\n", + "dca=16.##m\n", + "dca_dash=6.##m\n", + "Dsa=math.sqrt(rdash*daa_dash)##m\n", + "Dsb=math.sqrt(rdash*dbb_dash)##m\n", + "Dsc=math.sqrt(rdash*dcc_dash)##m\n", + "Ds=(Dsa*Dsb*Dsc)**(1/3)##m\n", + "print '%s %.2f' %(\"GMD(m) : \",Ds)#\n", + "Dab=(dab*dab_dash)**(1./2.)##m\n", + "Dbc=(dbc*dbc_dash)**(1./2.)##m\n", + "Dca=(dca*dca_dash)**(1./2.)##m\n", + "Dm=(Dab*Dbc*Dca)**(1./3.)##m\n", + "print '%s %.2f' %(\"Deq or Dm(m) : \",Dm)#\n", + "L=0.2*math.log(Dm/Ds)##mH/km\n", + "L=L*10.**-3.*100.##H(for 100 km line)\n", + "print '%s %.4f' %(\"Inductance of 100 km line(H)\",L)#\n", + "#/Alternate method is given below\n", + "d1=dab##m\n", + "d2=dca_dash##m\n", + "L=0.2*math.log(2.**(1./6.))*math.sqrt(d1/rdash)*((d1**2.+d2**2.)/(4.*d1**2.+d2**2.))**(1./6.)##mH\n", + "L=L*10.**-3.*100.##H(for 100 km line)\n", + "print '%s %.4f' %(\"Using Alternate method, Inductance of 100 km line(H)\",L)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "GMD(m) : 1.00\n", + "Deq or Dm(m) : 9.22\n", + "Inductance of 100 km line(H) 0.0444\n", + "Using Alternate method, Inductance of 100 km line(H) 0.0741\n" + ] + } + ], + "prompt_number": 13 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E14 - Pg 97" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Inductance per phase\n", + "import math\n", + "#Given data :\n", + "r=5./2.##cm\n", + "rdash=0.7788*r*10.**-2.##m\n", + "d=6.5##m\n", + "s=0.4##m\n", + "Ds=math.sqrt(rdash*s)##m\n", + "dab=6.5##m\n", + "dab_dash=6.9##m\n", + "d_adash_b=6.1##m\n", + "d_adash_bdash=6.5##m\n", + "Dab=(dab*dab_dash*d_adash_b*d_adash_bdash)**(1./4.)##m\n", + "Dbc=Dab##m\n", + "dca=13.##m\n", + "dca_dash=12.6##m\n", + "d_cdash_a=13.4##m\n", + "d_cdash_adash=13.##m\n", + "Dca=(dca*dca_dash*d_cdash_a*d_cdash_adash)**(1./4.)##m\n", + "Dm=(Dab*Dbc*Dca)**(1./3.)##m\n", + "L=0.2*math.log(Dm/Ds)##mH/km\n", + "print '%s %.3f' %(\"Inductance per phase(mH/km)\",L)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Inductance per phase(mH/km) 0.906\n" + ] + } + ], + "prompt_number": 14 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E15 - Pg 98" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Inductive reactance of bundled conductor line,Inductive reactance with single conductor\n", + "import math\n", + "#Given data :\n", + "f=50.##Hz\n", + "r=3.5/2.##cm\n", + "rdash=0.7788*r*10.**-2.##m\n", + "d=7.##m\n", + "s=40./100.##m\n", + "Ds=math.sqrt(rdash*s)##m\n", + "dab=7.##m\n", + "dab_dash=7.4##m\n", + "d_adash_b=6.6##m\n", + "d_adash_bdash=7.##m\n", + "Dab=(dab*dab_dash*d_adash_b*d_adash_bdash)**(1./4.)##m\n", + "Dbc=Dab##m\n", + "dca=14.##m\n", + "dca_dash=13.6##m\n", + "d_cdash_a=14.4##m\n", + "d_cdash_adash=14.##m\n", + "Dca=(dca*dca_dash*d_cdash_a*d_cdash_adash)**(1./4.)##m\n", + "Dm=(Dab*Dbc*Dca)**(1./3.)##m\n", + "L=0.2*math.log(Dm/Ds)##mH/km\n", + "XL=2*math.pi*f*L*10.**-3.##ohm/km\n", + "print '%s %.2f' %(\"Inductive reactance of bundled conductor line(ohm/km)\",XL)#\n", + "#Equivalent single conductor\n", + "n=2#\n", + "r1=math.sqrt(n*math.pi*r**2./math.pi)##m\n", + "r1dash=0.7788*r1*10.**-2.##m\n", + "Dm1=(Dab*Dbc*Dca)**(1./3.)##m\n", + "L1=0.2*math.log(Dm1/r1dash)##mH/km\n", + "XL1=2*math.pi*f*L1*10.**-3.##ohm/km\n", + "print '%s %.3f' %(\"Inductive reactance with single conductor(ohm/km)\",XL1)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Inductive reactance of bundled conductor line(ohm/km) 0.30\n", + "Inductive reactance with single conductor(ohm/km) 0.385\n" + ] + } + ], + "prompt_number": 15 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E16 - Pg 102" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Capacitance of line\n", + "import math\n", + "#Given data :\n", + "r=15./2.##mm\n", + "d=1.5*1000.##mm\n", + "l=30.##km\n", + "epsilon_o=8.854*10.**-12.##permitivity\n", + "C=math.pi*epsilon_o/math.log(d/r)*l*1000.##F\n", + "print '%s %.4f' %(\"Capacitance of line(micro F)\",C*10**6)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Capacitance of line(micro F) 0.1575\n" + ] + } + ], + "prompt_number": 16 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E17 - Pg 105" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Capacitance of line\n", + "#Given data :\n", + "import math\n", + "r=2./2.##cm\n", + "d=2.5*100.##cm\n", + "l=100.##km\n", + "epsilon_o=8.854*10.**-12.##permitivity\n", + "C=2*math.pi*epsilon_o/math.log(d/r)*l*1000.##F\n", + "print '%s %.4f' %(\"Capacitance of line(micro F)\",C*10.**6.)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Capacitance of line(micro F) 1.0075\n" + ] + } + ], + "prompt_number": 17 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E18 - Pg 105" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Capacitance of line\n", + "import math\n", + "#Given data :\n", + "r=2./2./100.##m\n", + "d1=3.5##m\n", + "d2=5.##m\n", + "d3=8.##m\n", + "epsilon_o=8.854*10.**-12.##permitivity\n", + "CN=2.*math.pi*epsilon_o*1000/math.log((d1*d2*d3)**(1./3.)/r)##F\n", + "print '%s %.4f' %(\"Capacitance of line(micro F)\",CN*10.**6.)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Capacitance of line(micro F) 0.0089\n" + ] + } + ], + "prompt_number": 18 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E19 - Pg 105" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Capacitance per phase per meter line,Charging current per phase\n", + "import math\n", + "#Given data :\n", + "f=50.##Hz\n", + "VL=220.##KV\n", + "r=20./2./1000.##m\n", + "d1=3.##m\n", + "d2=3.##m\n", + "d3=6.##m\n", + "epsilon_o=8.854*10.**-12.##permitivity\n", + "CN=2.*math.pi*epsilon_o/math.log((d1*d2*d3)**(1./3.)/r)##F\n", + "print '%s %.4e' %(\"Capacitance per phase per meter line(F)\",CN)#\n", + "Vph=VL*1000./math.sqrt(3.)##V\n", + "Ic=2.*math.pi*f*CN*Vph##A\n", + "print '%s %.3f' %(\"Charging current per phase(mA) : \",Ic*1000.)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Capacitance per phase per meter line(F) 9.3737e-12\n", + "Charging current per phase(mA) : 0.374\n" + ] + } + ], + "prompt_number": 19 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E20 - Pg 106" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Capacitance per phase per meter line,Charging current per phase\n", + "import math\n", + "#Given data :\n", + "f=50.##Hz\n", + "VL=110.##kV\n", + "r=1.05/2.##cm\n", + "d1=3.5##m\n", + "d2=3.5##m\n", + "d3=7.##m\n", + "epsilon_o=8.854*10.**-12.##permitivity\n", + "CN=2.*math.pi*epsilon_o/math.log((d1*d2*d3)**(1./3.)*100./r)##F\n", + "print '%s %.2e' %(\"Capacitance per phase per meter line(F)\",CN)#\n", + "Vph=VL*1000./math.sqrt(3.)##V\n", + "Ic=2.*math.pi*f*CN*Vph##A/m\n", + "print '%s %.3f' %(\"Charging current per phase(A/km) : \",Ic/10**-3)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Capacitance per phase per meter line(F) 8.26e-12\n", + "Charging current per phase(A/km) : 0.165\n" + ] + } + ], + "prompt_number": 20 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E21 - Pg 108" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Capacitive reactance too neutral,Charging current\n", + "import math\n", + "#Given data :\n", + "r=2.5/2.*10.**-2.##m\n", + "VL=132.##KV\n", + "epsilon_o=8.85*10.**-12.##permitivity\n", + "f=50.##Hz\n", + "dRRdash=math.sqrt(7.**2.+(4.+4.)**2.)##m\n", + "dBBdash=dRRdash##m\n", + "dYYdash=9.##m\n", + "DSR=math.sqrt(r*dRRdash)##m\n", + "DSY=math.sqrt(r*dYYdash)##m\n", + "DSB=math.sqrt(r*dBBdash)##m\n", + "Ds=(DSR*DSB*DSY)**(1./3.)##m\n", + "dRY=math.sqrt(4.**2.+(4.5-3.5)**2.)##m\n", + "dRYdash=math.sqrt((9.-1.)**2.+4.**2.)##m\n", + "dRdashY=math.sqrt((9.-1.)**2.+4.**2.)##m\n", + "dRdashYdash=math.sqrt(4.**2.+(4.5-3.5)**2.)##m\n", + "DRY=(dRY*dRYdash*dRdashY*dRdashYdash)**(1./4.)##m\n", + "DYB=((dRY*dRYdash)**2.)**(1./4.)##m\n", + "DBR=((8.*7.)**2.)**(1./4.)##m\n", + "Dm=(DRY*DYB*DBR)**(1./3.)##m\n", + "C=2*math.pi*epsilon_o/math.log(Dm/Ds)##F/m\n", + "C=C/10.**-3.##F/km\n", + "X=1./(2.*math.pi*f*C)##ohm\n", + "print '%s %.3f' %(\"Capacitive reactance too neutral(kohm) : \",X/1000.)#\n", + "Vph=VL*1000./math.sqrt(3.)##Volt\n", + "Ic=2.*math.pi*f*C*Vph##A\n", + "print '%s %.4f' %(\"Charging current(A/km)\",Ic)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Capacitive reactance too neutral(kohm) : 166.599\n", + "Charging current(A/km) 0.4574\n" + ] + } + ], + "prompt_number": 21 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E22 - Pg 109" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Capacitance of 100 km line\n", + "import math\n", + "#Given data :\n", + "d1=8.##m\n", + "d2=6.##m\n", + "epsilon_o=8.854*10.**-12.##permitivity\n", + "r=3.*5./2.*10.**-3.##m\n", + "C=4*math.pi*epsilon_o/math.log(2.**(1./3.)*d1/r*((d1**2.+d2**2.)/(4.*d1**2.+d2**2.)**(1./3.)))##F/m\n", + "C100=C*100.*1000.*10.**6.##microF\n", + "print '%s %.3f' %(\"Capacitance of 100 km line(micro Farad) : \",C100)#\n", + "#answer in the textbook is wrong.\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Capacitance of 100 km line(micro Farad) : 1.122\n" + ] + } + ], + "prompt_number": 22 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E23 - Pg 110" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Capacitance,Charging currentimport math\n", + "#Given data :\n", + "import math\n", + "VL=132.##kV\n", + "f=50.##Hz\n", + "r=5./2.##cm\n", + "rdash=0.7788*r*10.**-2.##m\n", + "d=6.5##m\n", + "s=0.4##m\n", + "epsilon_o=8.854*10.**-12.##permitivity\n", + "Ds=math.sqrt(rdash*s)##m\n", + "dab=6.5##m\n", + "dab_dash=6.9##m\n", + "d_adash_b=6.1##m\n", + "d_adash_bdash=6.5##m\n", + "Dab=(dab*dab_dash*d_adash_b*d_adash_bdash)**(1./4.)##m\n", + "Dbc=Dab##m\n", + "dca=13.##m\n", + "dca_dash=12.6##m\n", + "d_cdash_a=13.4##m\n", + "d_cdash_adash=13.##m\n", + "Dca=(dca*dca_dash*d_cdash_a*d_cdash_adash)**(1./4.)##m\n", + "Dm=(Dab*Dbc*Dca)**(1./3.)##m\n", + "L=0.2*math.log(Dm/Ds)##mH/km\n", + "C=2*math.pi*epsilon_o/math.log(Dm/Ds)##F/m\n", + "C=C/10.**-3.##F/km\n", + "print '%s %.2e' %(\"Capacitance per km(F/km) : \",C)#\n", + "Vph=VL*1000./math.sqrt(3)##Volt\n", + "Ic=2*math.pi*f*C*Vph##A/km\n", + "print '%s %.1f' %(\"Charging current per km(A/km) : \",Ic)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Capacitance per km(F/km) : 1.23e-08\n", + "Charging current per km(A/km) : 0.3\n" + ] + } + ], + "prompt_number": 23 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E24 - Pg 112" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate One conductor ACSR moose conductor line,Inductive reactance per Km per phase(ohm) :,Capacitivetive reactance per Km per phase(Mohm),Three conductor bundled line\n", + "#calculate Inductive reactance per km per phase(ohm)\n", + "#calculate Capacitivetive reactance per km per phase(Mohm)\n", + "import math\n", + "#Given data :\n", + "VL=132.##kV\n", + "f=50.##Hz\n", + "r=31.8/2##mm\n", + "rdash=0.7788*r##mm\n", + "d=10.*1000.##mm\n", + "epsilon_o=8.854*10**-12##permitivity\n", + "print '%s' %(\"One conductor ACSR moose conductor line : \")#\n", + "LAr=0.2*(math.log(d/rdash)+1./2.*math.log(2.))\n", + "LAi=0.866*math.log(2.)##mH/km\n", + "LB=0.2*math.log(d/rdash)##mH/km\n", + "LCr=0.2*(math.log(d/rdash)+1./2.*math.log(2.))\n", + "LCi=0.866*math.log(2.)##mH/km\n", + "Lav=(LAr+LAi+LB+LCr+LCi)/3.##mH/km\n", + "XL=2*math.pi*f*Lav*10.**-3.##ohm\n", + "print '%s %.3f' %(\"Inductive reactance per Km per phase(ohm) : \",XL)#\n", + "d1=10.##m\n", + "d2=10.##m\n", + "d3=20.##m\n", + "CN=2.*math.pi*epsilon_o/math.log((d1*d2*d3)**(1./3.)/(rdash*10.**-3.))/10.**3.##F/km\n", + "XC=1./(2.*math.pi*f*CN*10.**6.)##ohm\n", + "print '%s %.3f' %(\"Capacitivetive reactance per Km per phase(Mohm) : \",XC/10**6)#\n", + "print '%s' %(\"Three conductor bundled line : \")#\n", + "S=40./100.##m\n", + "Ds=(rdash*10.**-3.*S**2.)**(1./3.)##m\n", + "Deq=(d1*d2*d3)**(1./3.)##m\n", + "Ldash=0.2*math.log(Deq/Ds)##mH/km\n", + "XLdash=2*math.pi*f*Ldash*10.**-3.##ohm\n", + "print '%s %.3f' %(\"Inductive reactance per km per phase(ohm) : \",XLdash)#\n", + "Ds=(r*10.**-3.*S**2.)**(1./3.)##m\n", + "Cdash=2.*math.pi*epsilon_o*10.**3./math.log(Deq/Ds)##microF/km\n", + "XC=1./(2.*math.pi*f*Cdash)/10.**6.##Mohm\n", + "print '%s %.3f' %(\"Capacitivetive reactance per km per phase(Mohm) : \",XC)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "One conductor ACSR moose conductor line : \n", + "Inductive reactance per Km per phase(ohm) : 0.561\n", + "Capacitivetive reactance per Km per phase(Mohm) : 0.396\n", + "Three conductor bundled line : \n", + "Inductive reactance per km per phase(ohm) : 0.290\n", + "Capacitivetive reactance per km per phase(Mohm) : 0.259\n" + ] + } + ], + "prompt_number": 24 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E25 - Pg 114" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Capacitance per km of line\n", + "import math\n", + "#Given data :\n", + "r=1.5/2.##cm\n", + "d=3.*100.##cm\n", + "h=6.*100.##cm\n", + "epsilon_o=8.854*10.**-12.##permitivity\n", + "C=math.pi*epsilon_o/math.log(d/(1.+d**2./4./h**2.)**r)*10.**3.##F\n", + "print '%s %.3e' %(\"Capacitance per km of line(F) : \",C)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Capacitance per km of line(F) : 4.916e-09\n" + ] + } + ], + "prompt_number": 25 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E26 - Pg 114" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Part(i) Capacitance per phase per meter length,Part(ii) Capacitance per phase per meter length\n", + "import math\n", + "#Given data :\n", + "r=2./100.##m\n", + "d1=4.##m\n", + "d2=4.##m\n", + "d3=8.##m\n", + "epsilon_o=8.854*10.**-12.##permitivity\n", + "CN=2.*math.pi*epsilon_o/math.log((d1*d2*d3)**(1./3.)/r)##F\n", + "print '%s %.3e' %(\"Part(i) Capacitance per phase per meter length(F) : \",CN)#\n", + "h1=20.##m\n", + "h2=20.##m\n", + "h3=20.##m\n", + "h12=math.sqrt(20.**2.+4.**2.)##m\n", + "h23=math.sqrt(20.**2.+4.**2.)##m\n", + "h31=math.sqrt(20.**2.+8.**2.)##m\n", + "Deq=(d1*d2*d3)**(1./3.)##m\n", + "CN=2.*math.pi*epsilon_o/(math.log(Deq/r)-math.log((h12*h23*h31/h1/h2/h3)**(1./3.)) )##F\n", + "print '%s %.3e' %(\"Part(ii) Capacitance per phase per meter length(F) : \",CN)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Part(i) Capacitance per phase per meter length(F) : 1.006e-11\n", + "Part(ii) Capacitance per phase per meter length(F) : 1.013e-11\n" + ] + } + ], + "prompt_number": 26 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Elements_of_Power_system/Chapter_5.ipynb b/Elements_of_Power_system/Chapter_5.ipynb new file mode 100755 index 00000000..49ce6211 --- /dev/null +++ b/Elements_of_Power_system/Chapter_5.ipynb @@ -0,0 +1,1386 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:ddc558b09e8a48f2e508ce080e711444f5dcc5027e225fbf933fb8580dbc869f" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 5 - REPRESENTATION AND PERFORMANCE OF SHORT AND MEDIUM TRANSMISSION LINES" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E1 - Pg 128" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Voltage at sending end,Regulation,Transmission Efficiency\n", + "import math\n", + "#Given data :\n", + "P=1100.##kW\n", + "VR=11.*1000.##V\n", + "pf=0.8##power factor\n", + "R=2.##ohm\n", + "X=3.##ohm\n", + "I=P*1000./VR/pf##A\n", + "cos_fi_r=pf#\n", + "sin_fi_r=math.sqrt(1.-cos_fi_r**2)#\n", + "VS=math.sqrt((VR*cos_fi_r+I*R)**2.+(VR*sin_fi_r+I*X)**2.)##V\n", + "print '%s %.f' %(\"Voltage at sending end(V)\",VS)#\n", + "Reg=(VS-VR)/VR*100.##%\n", + "print '%s %.3f' %(\"Regulation\",Reg)#\n", + "LineLoss=I**2.*R/1000.##kW\n", + "Eta_T=P*100./(P+LineLoss)##%\n", + "print '%s %.2f' %(\"Transmission Efficiency(%)\",Eta_T)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Voltage at sending end(V) 11426\n", + "Regulation 3.873\n", + "Transmission Efficiency(%) 97.24\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E2 - Pg 128" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Transmission Efficiency(%)\n", + "import math \n", + "#Given data :\n", + "R=0.4##ohm\n", + "X=0.4##ohm \n", + "P=2000.##kVA\n", + "pf=0.8##power factor\n", + "VL=3000.##V\n", + "VR=VL/math.sqrt(3.)##V\n", + "cos_fi_r=pf#\n", + "sin_fi_r=math.sqrt(1-cos_fi_r**2.)#\n", + "I=P*1000./3./VR##A\n", + "VS=VR+I*(R*cos_fi_r+X*sin_fi_r)##V\n", + "Reg=(VS-VR)/VR*100.##%\n", + "print '%s %.2f' %(\"% Regulation\",Reg)#\n", + "LineLoss=3.*I**2.*R/1000.##kW\n", + "Pout=P*cos_fi_r##kW\n", + "Eta_T=Pout*100./(Pout+LineLoss)##%\n", + "print '%s %.f' %(\"Transmission Efficiency(%)\",Eta_T)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "% Regulation 12.44\n", + "Transmission Efficiency(%) 90\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E3 - Pg 129" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate \n", + "import math\n", + "#Given data :\n", + "l=15.##km\n", + "P=5.##MW\n", + "V=11.##kV\n", + "f=50.##Hz\n", + "pf=0.8##power factor\n", + "cos_fi_r=pf#\n", + "sin_fi_r=math.sqrt(1-cos_fi_r**2)#\n", + "L=1.1##mH/Km\n", + "VR=V*1000./math.sqrt(3.)##V\n", + "I=P*1000./math.sqrt(3.)/V/cos_fi_r##A\n", + "LineLoss=12./100.*P*10**6##W\n", + "R=LineLoss/3./I**2##ohm\n", + "X=2.*math.pi*f*L*10**-3*l##ohm/phase\n", + "VS=VR+I*(R*cos_fi_r+X*sin_fi_r)##V\n", + "VSL=math.sqrt(3.)*VS/1000.##KV\n", + "print '%s %.3f' %(\"Line voltage at sending end(kV)\",VSL)#\n", + "Reg=(VSL-V)/V*100.##%\n", + "print '%s %.3f' %(\"% Regulation\",Reg)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Line voltage at sending end(kV) 13.612\n", + "% Regulation 23.745\n" + ] + } + ], + "prompt_number": 22 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E4 - Pg 130" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Line voltage at sending end(kV),Sending end pf(lagging),Transmission Efficiency(%),Regulation\n", + "import math \n", + "#Given data :\n", + "l=50.##km\n", + "S=10000.##kVA\n", + "pf=0.8##power factor\n", + "d=1.2*100.##cm\n", + "cos_fi_r=pf#\n", + "sin_fi_r=math.sqrt(1-cos_fi_r**2)#\n", + "V=33000.##Volts\n", + "VR=V/math.sqrt(3.)##V\n", + "f=50.##Hz\n", + "I=S*1000./math.sqrt(3.)/V##A\n", + "LineLoss=10./100.*S*10.**3*pf##W\n", + "R=LineLoss/3./I**2##ohm\n", + "rho=1.73*10**-6##kg/m**3\n", + "a=rho*l*1000.*100./R##cm**2\n", + "r=math.sqrt(a/math.pi)##cm\n", + "L=0.2*math.log(d/r/0.7788)*l##mH\n", + "X=2*math.pi*f*L*10**-3##ohm\n", + "VS=VR+I*(R*cos_fi_r+X*sin_fi_r)##V\n", + "VSL=math.sqrt(3.)*VS/1000.##kV\n", + "print '%s %.2f' %(\"Line voltage at sending end(kV)\",VSL)#\n", + "pf_s=(VR*cos_fi_r+I*R)/VS##lagging(sendinf end pf)\n", + "print '%s %.4f' %(\"Sending end pf(lagging) \",pf_s)#\n", + "Eta_T=S*pf/(S*pf+LineLoss/1000.)*100.#\n", + "print '%s %.2f' %(\"Transmission Efficiency(%)\",Eta_T)#\n", + "Reg=(VSL-V/1000.)/(V/1000.)*100.##%\n", + "print '%s %.2f' %(\"% Regulation\",Reg)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Line voltage at sending end(kV) 38.32\n", + "Sending end pf(lagging) 0.7579\n", + "Transmission Efficiency(%) 90.91\n", + "% Regulation 16.12\n" + ] + } + ], + "prompt_number": 23 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E5 - Pg 130" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Resistance per phase(ohm/phase),Inductance per phase(mH/phase)\n", + "import math \n", + "#Given data :\n", + "VRL=30000.##Volts\n", + "VSL=33000.##Volts\n", + "f=50.##Hz\n", + "P=10.*10.**6##W\n", + "pf=0.8##power factor\n", + "cos_fi_r=pf#\n", + "sin_fi_r=math.sqrt(1-cos_fi_r**2)#\n", + "VR=VRL/math.sqrt(3.)##V\n", + "I=P/math.sqrt(3.)/VRL/pf##A\n", + "Eta_T=0.96##Efficiency\n", + "LineLoss=P*(1/Eta_T-1)##W\n", + "R=LineLoss/3/I**2##ohm/phase\n", + "print '%s %.1f' %(\"Resistance per phase(ohm/phase)\",R)#\n", + "VS=VSL/math.sqrt(3.)##V\n", + "X=(VS-VR-I*R*cos_fi_r)/I/sin_fi_r##V\n", + "L=X/2./math.pi/f##H/phase\n", + "print '%s %.f' %(\"Inductance per phase(mH/phase)\",L*1000)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Resistance per phase(ohm/phase) 2.4\n", + "Inductance per phase(mH/phase) 28\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E6 - Pg 131" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Line voltage at load end(volt),Transmission Efficiency(%)\n", + "import math\n", + "import numpy\n", + "from numpy import roots\n", + "#Given data :\n", + "l=3.##km\n", + "P=3000.##KW\n", + "VSL=11.*10**3##volt\n", + "R=l*0.4##ohm\n", + "X=l*0.8##ohm\n", + "VS=VSL/math.sqrt(3.)##Volts\n", + "pf=0.8##power factor\n", + "cos_fi_r=pf#\n", + "sin_fi_r=math.sqrt(1-cos_fi_r**2)#\n", + "#VS=VR+I*(R*cos_fi_r+X*sin_fi_r)##V\n", + "I_into_VR=P*1000./3./cos_fi_r##VA\n", + "#VR**2-VS*VR+I_into_VR*(R*cos_fi_r+X*sin_fi_r)#\n", + "p=([1, -VS, I_into_VR*(R*cos_fi_r+X*sin_fi_r)])#\n", + "VR=numpy.roots(p)#\n", + "VR=VR[0]##taking greater value\n", + "I=I_into_VR/VR##A\n", + "VRL=math.sqrt(3.)*VR##volt\n", + "print '%s %.f' %(\"Line voltage at load end(volt) : \",VRL)#\n", + "Eta_T=P*1000/(P*1000+3*I**2*R)*100##%\n", + "print '%s %.1f' %(\"Transmission Efficiency(%) : \",Eta_T)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Line voltage at load end(volt) : 10110\n", + "Transmission Efficiency(%) : 94.8\n" + ] + } + ], + "prompt_number": 24 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E7 - Pg 131" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Power output(kW),Power factor at sending end(lagging)\n", + "import math\n", + "#Given data :\n", + "R=5.##ohm/phase\n", + "X=20.##ohm/phase\n", + "VSL=46.85##kV\n", + "VRL=33.##kV\n", + "VRL=VRL*1000.##v\n", + "pf=0.8##power factor\n", + "cos_fi_r=pf#\n", + "sin_fi_r=math.sqrt(1-cos_fi_r**2)#\n", + "VR=VRL/math.sqrt(3.)##V\n", + "I=(VSL*1000./math.sqrt(3.)-VR)/(R*cos_fi_r+X*sin_fi_r)##A\n", + "Pout=math.sqrt(3.)*VRL*I*pf/1000.##kW\n", + "print '%s %.f' %(\"Power output(kW)\",Pout)#\n", + "cosfi_s=(VR*pf+I*R)/(VSL*1000/math.sqrt(3.))##power factor\n", + "print '%s %.3f' %(\"Power factor at sending end(lagging)\",cosfi_s)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Power output(kW) 22853\n", + "Power factor at sending end(lagging) 0.656\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E8 - Pg 136" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Sending end power factor(lag),Regulation(%),Transmission Efficiency(%)\n", + "import math\n", + "import cmath\n", + "#Given data :\n", + "l=80.##km\n", + "P=15.##MW\n", + "VR=66.*10**3##Volt\n", + "R=l*0.3125##ohm\n", + "X=l*1.##ohm\n", + "Y=l*17.5*10**-6##S\n", + "pf=0.8##power factor\n", + "cos_fi_r=pf#\n", + "sin_fi_r=math.sqrt(1-cos_fi_r**2)#\n", + "IR=P*10**6/(VR*pf)##A\n", + "IR=IR*(cos_fi_r-1j*sin_fi_r)##A\n", + "IC=1j*Y*VR##A\n", + "IS=IR+IC##A\n", + "print '%s %.1f %s %.2f' %(\"Sending end current(A), magnitude is \",abs(IS),\" and angle in degree is \",cmath.phase(IS)*180/math.pi)#\n", + "VS=VR+IS*(R+1j*X)##volt\n", + "print '%s %.f %s %.2f' %(\"Sending end voltage(V), magnitude is \",abs(VS),\" and angle in degree is \",cmath.phase(VS)*180/math.pi)#\n", + "fi_s=cmath.phase(VS)-cmath.phase(IS)##\n", + "cos_fis=math.cos(fi_s)##sending end pf\n", + "print '%s %.2f' %(\"Sending end power factor(lag) : \",cos_fis)#\n", + "Reg=(abs(VS)-VR)/VR*100##%\n", + "print '%s %.1f' %(\"Regulation(%) : \",Reg)#\n", + "LineLoss=abs(IS)**2*R/1000.##kW\n", + "print '%s %.1f' %(\"Line Losses in kW : \",LineLoss)#\n", + "Eta_T=P*1000/(P*1000+LineLoss)*100##%\n", + "print '%s %.2f' %(\"Transmission Efficiency(%) : \",Eta_T)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Sending end current(A), magnitude is 240.3 and angle in degree is -18.95\n", + "Sending end voltage(V), magnitude is 79598 and angle in degree is 11.77\n", + "Sending end power factor(lag) : 0.86\n", + "Regulation(%) : 20.6\n", + "Line Losses in kW : 1443.6\n", + "Transmission Efficiency(%) : 91.22\n" + ] + } + ], + "prompt_number": 67 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E9 - Pg 137" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Sending end line voltage(Volt) ,Regulation(%),Transmission Efficiency(%)\n", + "import math\n", + "import cmath\n", + "#Given data :\n", + "l=100.##km\n", + "P=20.##MW\n", + "VRL=66.*10**3##volt\n", + "f=50.##Hz\n", + "R=10.##ohm\n", + "L=111.7*10**-3##H\n", + "C=0.9954*10**-6##F\n", + "pf=0.8##power factor\n", + "X=2.*math.pi*f*L##ohm\n", + "Y=2.*math.pi*f*C##S\n", + "cos_fi_r=pf#\n", + "sin_fi_r=math.sqrt(1-cos_fi_r**2)#\n", + "VR=VRL/math.sqrt(3.)##volt\n", + "IR=P*10**6/(math.sqrt(3.)*VRL*pf)##A\n", + "IR=IR*(cos_fi_r-1j*sin_fi_r)##A\n", + "Z=R+1j*X##ohm\n", + "Vdash=VR+1./2.*IR*Z##Volt\n", + "IC=Vdash*1j*Y##A\n", + "IS=IR+IC##A\n", + "VS=Vdash+1./2.*IS*Z##Volt\n", + "VSL=abs(VS)*math.sqrt(3.)##Volt\n", + "print '%s %.f' %(\"Sending end line voltage(Volt) :\",VSL)#\n", + "Reg=(VSL-VRL)/VRL*100.##%\n", + "print '%s %.2f' %(\"Regulation(%) : \",Reg)#\n", + "fi_s=cmath.phase(VS)-cmath.phase(IS)##\n", + "cos_fi_s=math.cos(fi_s)##sending end pf\n", + "Eta_T=math.sqrt(3.)*VRL*abs(IR)*cos_fi_r/(math.sqrt(3)*VSL*abs(IS)*cos_fi_s)*100##%\n", + "print '%s %.1f' %(\"Transmission Efficiency(%) : \",Eta_T)#\n", + "#Ans is not accurate in the book.\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Sending end line voltage(Volt) : 77071\n", + "Regulation(%) : 16.77\n", + "Transmission Efficiency(%) : 93.5\n" + ] + } + ], + "prompt_number": 27 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E10 - Pg 138" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Sending end line voltage(kV),Regulation(%),Transmission Efficiency(%) \n", + "import math\n", + "import cmath\n", + "#Given data :\n", + "l=200.##km\n", + "P=50.##MVA\n", + "VRL=132.*10**3.##Volt\n", + "f=50.##Hz\n", + "R=l*0.15##ohm\n", + "X=l*0.50##ohm\n", + "Y=l*2.*10**-6##mho\n", + "pf=0.85##power factor\n", + "cos_fi_r=pf#\n", + "sin_fi_r=math.sqrt(1-cos_fi_r**2)#\n", + "VR=VRL/math.sqrt(3.)##Volt\n", + "IR=P*10**6/(math.sqrt(3.)*VRL)##A\n", + "Z=R+1j*X##ohm\n", + "IR=IR*(cos_fi_r-1j*sin_fi_r)##A\n", + "Vdash=VR+1/2*IR*Z##Volt\n", + "IC=Vdash*1j*Y##A\n", + "IS=IR+IC##A\n", + "print '%s %.2f %s %.2f' %(\"Sending end current(A), magnitude is \",abs(IS),\" and angle in degree is \",cmath.phase(IS)*180/math.pi)#\n", + "VS=Vdash+1/2*IS*Z##Volt\n", + "VSL=abs(VS)*math.sqrt(3)##Volt\n", + "print '%s %.2f' %(\"Sending end line voltage(kV) :\",VSL/1000)#\n", + "Reg=(VSL-VRL)/VRL*100##%\n", + "print '%s %.2f' %(\"Regulation(%) : \",Reg)#\n", + "fi_s=cmath.phase(VS)-cmath.phase(IS)##\n", + "cos_fi_s=math.cos(fi_s)##sending end pf\n", + "Eta_T=math.sqrt(3.)*VRL*abs(IR)*cos_fi_r/(math.sqrt(3)*VSL*abs(IS)*cos_fi_s)*100##%\n", + "print '%s %.2f' %(\"Transmission Efficiency(%) : \",Eta_T)#\n", + "#Ans is wrong in the book.Angle of VS is calculated wrong leads to wrong answers.\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Sending end current(A), magnitude is 204.28 and angle in degree is -24.50\n", + "Sending end line voltage(kV) : 132.00\n", + "Regulation(%) : 0.00\n", + "Transmission Efficiency(%) : 100.00\n" + ] + } + ], + "prompt_number": 65 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E11 - Pg 139" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Sending end power factor(lag)\n", + "import math\n", + "import cmath\n", + "#Given data :\n", + "S=1.*10**3##kVA\n", + "pf=0.71##power factor\n", + "VRL=22.*10**3##Volt\n", + "f=50.##Hz\n", + "R=15.##ohm\n", + "L=0.2##H\n", + "C=0.5*10**-6##F\n", + "cos_fi_r=pf#\n", + "sin_fi_r=math.sqrt(1-cos_fi_r**2)#\n", + "IR=S*10.**3/VRL##A\n", + "IR=IR*(cos_fi_r-1j*sin_fi_r)##A\n", + "X=2.*math.pi*f*L##ohm\n", + "#Z=sqrt(R**2+X**2)##ohm\n", + "Z=R+1j*X##ohm\n", + "Y=2.*math.pi*f*C##S\n", + "ICR=1./2.*1j*Y*VRL##A\n", + "IL=IR+ICR##A\n", + "VS=VRL+IL*Z##Volt\n", + "print '%s %.f %s %.2f' %(\"Sending end voltage(Volt), magnitude is \",abs(VS),\" and angle in degree is \",cmath.phase(VS))#\n", + "ICS=1./2.*1j*Y*VS##A\n", + "IS=IL+ICS##A\n", + "print '%s %.3f %s %.2f' %(\"Sending end current(A), magnitude is \",abs(IS),\" and angle in degree is \",cmath.phase(IS))#\n", + "fi_s=cmath.phase(VS)-cmath.phase(IS)##\n", + "cos_fi_s=math.cos(fi_s)##sending end pf\n", + "print '%s %.3f' %(\"Sending end power factor(lag) : \",cos_fi_s)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Sending end voltage(Volt), magnitude is 24437 and angle in degree is 0.06\n", + "Sending end current(A), magnitude is 42.874 and angle in degree is -0.72\n", + "Sending end power factor(lag) : 0.706\n" + ] + } + ], + "prompt_number": 31 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E12 - Pg 139" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Sending end line to line voltage(kV)\n", + "import math\n", + "#Given data :\n", + "P=50.*10**6##W\n", + "f=50.##Hz\n", + "l=150.##km\n", + "pf=0.8##power factor\n", + "VRL=110.*10**3##Volt\n", + "VR=VRL/math.sqrt(3.)##Volt\n", + "cos_fi_r=pf#\n", + "sin_fi_r=math.sqrt(1-cos_fi_r**2)#\n", + "R=0.1*l##ohm\n", + "XL=0.5*l##ohm\n", + "Z=R+1j*XL##ohm\n", + "IR=P/(math.sqrt(3)*VRL*pf)##A\n", + "IR=IR*(cos_fi_r-1j*sin_fi_r)##A\n", + "Y=3.*10**-6*l##S\n", + "ICR=1./2.*1j*Y*VR##A\n", + "IL=IR+ICR##A\n", + "VS=VR+IL*Z##Volt\n", + "VSL=math.sqrt(3.)*abs(VS)##Volt\n", + "print '%s %.3f' %(\"Sending end line to line voltage(kV) :\",VSL/1000.)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Sending end line to line voltage(kV) : 143.562\n" + ] + } + ], + "prompt_number": 32 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E13 - Pg 140" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Sending end line to line voltage(kV),Sending end power factor(lag)\n", + "import math\n", + "import cmath\n", + "#Given data :\n", + "f=50.##Hz\n", + "l=30.##km\n", + "Z=40.+1j*125##ohm\n", + "Y=10**-3##mho\n", + "P=50.*10**6##W\n", + "VRL=220.*10**3##Volt\n", + "VR=VRL/math.sqrt(3)##Volt\n", + "pf=0.8##power factor\n", + "cos_fi_r=pf#\n", + "sin_fi_r=math.sqrt(1-cos_fi_r**2)#\n", + "IR=P/(math.sqrt(3.)*VRL*pf)##A\n", + "IR=IR*(cos_fi_r-1j*sin_fi_r)##A\n", + "ICR=1./2.*1j*Y*VR##A\n", + "IL=IR+ICR##A\n", + "VS=VR+IL*Z##Volt\n", + "VSL=math.sqrt(3)*abs(VS)##Volt\n", + "print '%s %.2f ' %(\"Sending end line to line voltage(kV) :\",VSL/1000)#\n", + "IS=IL+1./2.*1j*Y*VS##A\n", + "print '%s %.2f %s %.1f' %(\"Sending end current(A), magnitude is \",abs(IS),\" and angle in degree is \",cmath.phase(IS)*180/math.pi)#\n", + "fi_s=cmath.phase(VS)-cmath.phase(IS)##\n", + "cos_fis=math.cos(fi_s)##sending end pf\n", + "print '%s %.3f' %(\"Sending end power factor(lag) : \",cos_fis)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Sending end line to line voltage(kV) : 238.07 \n", + "Sending end current(A), magnitude is 128.15 and angle in degree is 15.1\n", + "Sending end power factor(lag) : 0.988\n" + ] + } + ], + "prompt_number": 63 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E14 - Pg 141" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Sending end line to line voltage(kV)\n", + "import math \n", + "#Given data :\n", + "f=50.##Hz\n", + "l=30.##km\n", + "Z=40.+1j*125.##ohm\n", + "Y=10**-3##mho\n", + "P=50.*10**6##W\n", + "VRL=220.*10**3##Volt\n", + "VR=VRL/math.sqrt(3.)##Volt\n", + "pf=0.8##power factor\n", + "cos_fi_r=pf#\n", + "sin_fi_r=math.sqrt(1-cos_fi_r**2)#\n", + "IR=P/(math.sqrt(3.)*VRL*pf)##A\n", + "IR=IR*(cos_fi_r-1j*sin_fi_r)##A\n", + "ICR=1./2.*1j*Y*VR##A\n", + "IL=IR+ICR##A\n", + "VS=VR+IL*Z##Volt\n", + "VSL=math.sqrt(3.)*abs(VS)##Volt\n", + "print '%s %.2f' %(\"Sending end line to line voltage(kV) :\",VSL/1000.)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Sending end line to line voltage(kV) : 238.07\n" + ] + } + ], + "prompt_number": 16 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E15 - Pg 141" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Sending end line voltage(kV),Sending end power factor(lag),Transmission Efficiency(%)\n", + "import math\n", + "import cmath\n", + "#Given data :\n", + "f=50.##Hz\n", + "l=100.##km\n", + "P=50.*10**6##W\n", + "pf=0.8##power factor\n", + "cos_fi_r=pf#\n", + "sin_fi_r=math.sqrt(1-cos_fi_r**2)#\n", + "VRL=132.*10**3##Volt\n", + "VR=VRL/math.sqrt(3.)##Volt\n", + "R=0.1*l##ohm\n", + "XL=0.3*l##ohm\n", + "Z=R+1j*XL##ohm\n", + "Y=3.*10**-6*l##S\n", + "IR=P/(math.sqrt(3)*VRL*pf)##A\n", + "IR=IR*(cos_fi_r-1j*sin_fi_r)##A\n", + "ICR=1/2*1j*Y*VR##A\n", + "IL=IR+ICR##A\n", + "VS=VR+IL*Z##Volt\n", + "VSL=math.sqrt(3.)*abs(VS)##Volt\n", + "print '%s %.2f' %(\"Sending end line voltage(kV) :\",VSL/1000)#\n", + "ICS=1./2.*1j*Y*VS##A\n", + "IS=IL+ICS##A\n", + "fi_s=cmath.phase(VS)-cmath.phase(IS)##\n", + "cos_fi_s=math.cos(fi_s)##sending end pf\n", + "print '%s %.2f' %(\"Sending end power factor(lag) : \",cos_fi_s*180/math.pi)#\n", + "Eta_T=math.sqrt(3)*VRL*abs(IR)*cos_fi_r/(math.sqrt(3)*VSL*abs(IS)*cos_fi_s)*100##%\n", + "print '%s %.3f' %(\"Transmission Efficiency(%) : \",Eta_T)#\n", + "#answer in book is wrong\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Sending end line voltage(kV) : 144.56\n", + "Sending end power factor(lag) : 45.03\n", + "Transmission Efficiency(%) : 95.709\n" + ] + } + ], + "prompt_number": 61 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E16 - Pg 142" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Line voltage at mid point(kV),Sending end line voltage(kV)\n", + "import math \n", + "import cmath\n", + "#Given data :\n", + "f=50.##Hz\n", + "l=10.##km\n", + "S1=5000.*10**3##VA\n", + "S2=10000.*10**3##VA\n", + "pf=0.8##power factor\n", + "cos_fi_r=pf#\n", + "sin_fi_r=math.sqrt(1-cos_fi_r**2)#\n", + "pf2=0.7071##power factor\n", + "cos_fi_r2=pf2#\n", + "sin_fi_r2=math.sqrt(1-cos_fi_r2**2)#\n", + "R=0.6*l##ohm\n", + "XL=1.5*l##ohm\n", + "VRL=33*10**3##Volt\n", + "VR=VRL/math.sqrt(3.)##Volt\n", + "I1=S1/(math.sqrt(3.)*VRL)##A\n", + "I1=I1*(cos_fi_r-1j*sin_fi_r)##A\n", + "Z1=R+1j*XL##ohm\n", + "VB=VR+I1*Z1##Volt\n", + "VBL=math.sqrt(3)*abs(VB)##Volt\n", + "print '%s %.3f' %(\"Line voltage at mid point(kV) : \",VBL/1000)#\n", + "I2=S2/(math.sqrt(3.)*VBL)##A\n", + "I2=I2*(cos_fi_r2-1j*sin_fi_r2)##A\n", + "I=I1+I2##A\n", + "print '%s %.2f %s %.2f' %(\"Total current(A), magnitude is \",abs(I),\" and angle in degree is \",cmath.phase(I))#\n", + "Z2=R+1j*XL##ohm\n", + "VS=VB+I*Z2##Volt\n", + "VSL=math.sqrt(3.)*abs(VS)##Volt\n", + "print '%s %.2f' %(\"Sending end line voltage(kV) :\",VSL/1000)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Line voltage at mid point(kV) : 35.114\n", + "Total current(A), magnitude is 251.32 and angle in degree is -0.74\n", + "Sending end line voltage(kV) : 41.64\n" + ] + } + ], + "prompt_number": 34 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E17 - Pg 143" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Power supplied by line A(kW),B(kW)\n", + "import cmath\n", + "import math \n", + "#Given data :\n", + "P=10.##MWatt\n", + "pf=0.8##power factor\n", + "VRL=30.*10**3##Volt\n", + "R1=5.5##ohm\n", + "XL1=13.5##ohm\n", + "R2=6.##ohm\n", + "XL2=11.##ohm\n", + "ZA=R1+1j*XL1##ohm\n", + "ZB=R2+1j*XL2##ohm\n", + "S=P*10.**3./pf*(math.cos(-36.52*math.pi/180.) + 1j*math.sin(-36.52*math.pi/180.))##kVA\n", + "SA=S*ZB/(ZA+ZB)##kVA\n", + "print '%s %.f %s %.3f' %(\"Load supply by line A(kVA), magnitude is \",abs(SA),\" at pf \",cmath.phase(SA))#\n", + "SB=S*ZA/(ZA+ZB)##kVA\n", + "print '%s %.f %s %.2f' %(\"Load supply by line B(kVA), magnitude is \",abs(SB),\" and angle in degree is \",cmath.phase(SA))#\n", + "PA=abs(SA)*(math.cos(cmath.phase(SA)*180/math.pi))##kW\n", + "print '%s %.2f' %(\"Power supplied by line A(kW) : \",PA)#\n", + "PB=abs(SB)*(math.cos(cmath.phase(SB)*180/math.pi))##kW\n", + "print '%s %.2f' %(\"Power supplied by line B(kW) : \",PB)#\n", + "#Answer is not accurate in the book.\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Load supply by line A(kVA), magnitude is 5787 at pf -0.698\n", + "Load supply by line B(kVA), magnitude is 6733 and angle in degree is -0.70\n", + "Power supplied by line A(kW) : -3797.43\n", + "Power supplied by line B(kW) : -3546.79\n" + ] + } + ], + "prompt_number": 36 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E18 - Pg 145" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Percentage rise in voltage\n", + "import math \n", + "#Given data :\n", + "L=200.##km\n", + "f=50.##Hz\n", + "omega=2.*math.pi*f##rad/s\n", + "Rise=omega**2.*L**2.*10.**-8./18.##%\n", + "print '%s %.2f' %(\"Percentage rise in voltage : \",Rise)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Percentage rise in voltage : 2.19\n" + ] + } + ], + "prompt_number": 20 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E19 - Pg 151" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Parameter A,B,C,D\n", + "import math \n", + "import cmath\n", + "#Given data :\n", + "L=80.##km\n", + "f=50.##Hz\n", + "Z=(0.15+1j*0.78)*L##ohm\n", + "Y=(1j*5.*10.**-6)*L##mho\n", + "A=1.+1./2.*Y*Z##parameter of 3-phase line\n", + "D=A##parameter of 3-phase line\n", + "B=Z*(1.+1./4.*Y*Z)##parameter of 3-phase line\n", + "C=Y##parameter of 3-phase line\n", + "print (\"Parameter A : \",A)#\n", + "print (\"Parameter B : \",B)#\n", + "print (\"Parameter C : \",C)#\n", + "print (\"Parameter D : \",D)#\n", + "#Answer of B is wrong in the book.\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "('Parameter A : ', (0.98752+0.0024j))\n", + "('Parameter B : ', (11.85024+62.02502400000001j))\n", + "('Parameter C : ', 0.00039999999999999996j)\n", + "('Parameter D : ', (0.98752+0.0024j))\n" + ] + } + ], + "prompt_number": 47 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E20 - Pg 151" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Power Input(MW),Transmission Efficiency(%),Sending end power factor(lag)\n", + "import math \n", + "import cmath\n", + "#Given data :\n", + "Z=200*math.cos(80.*math.pi/180.) + 1j*math.sin(80.*math.pi/180.)##ohm\n", + "Y=0.0013*math.cos(90.*math.pi/180.) + 1j*math.sin(90.*math.pi/180.)##mho/phase\n", + "P=80*10**6##W\n", + "pf=0.8##power factor\n", + "cos_fi_r=pf#\n", + "sin_fi_r=math.sqrt(1-cos_fi_r**2)#\n", + "VRL=220.*10**3##Volt\n", + "VR=VRL/math.sqrt(3)##Volt\n", + "f=50##Hz\n", + "IR=P/(math.sqrt(3.)*VRL*pf)##A\n", + "IR=IR*(cos_fi_r-1j*sin_fi_r)##A\n", + "A=1.+1./2.*Y*Z##parameter of 3-phase line\n", + "D=A##parameter of 3-phase line\n", + "B=Z*(1.+1./4.*Y*Z)##parameter of 3-phase line\n", + "C=Y##parameter of 3-phase line\n", + "print '%s %.2f %s %.2f' %(\"Parameter A, magnitude is \",abs(A),\" and angle in degree is \",cmath.phase(A)*180/math.pi)#\n", + "print '%s %.2f %s %.2f' %(\"Parameter B, magnitude is \",abs(B),\" and angle in degree is \",cmath.phase(B)*180/math.pi)#\n", + "print '%s %.2f %s %.2f' %(\"Parameter C, magnitude is \",abs(C),\" and angle in degree is \",cmath.phase(C)*180/math.pi)#\n", + "print '%s %.2f %s %.2f' %(\"Parameter D, magnitude is \",abs(D),\" and angle in degree is \",cmath.phase(D)*180/math.pi)#\n", + "VS=A*VR+B*IR##Volt\n", + "VSL=math.sqrt(3)*abs(VS)##Volt\n", + "print '%s %.2f' %(\"Sending end Line voltage(kV) : \",VSL/1000.)#\n", + "IS=C*VR+D*IR##A\n", + "print '%s %.2f %s %.2f' %(\"Sending end current(A), magnitude is \",abs(IS),\" and angle in degree is \",cmath.phase(IS)*180/math.pi)#\n", + "fi_s=cmath.phase(VS)-cmath.phase(IS)##\n", + "cos_fis=math.cos(fi_s)##sending end pf\n", + "print '%s %.2f' %(\"Sending end power factor(lag) : \",cos_fis)#\n", + "Pin=math.sqrt(3.)*VSL*abs(IS)*cos_fis*10**-6##MW\n", + "print '%s %.2f' %(\"Power Input(MW) : \",Pin)#\n", + "Eta=P/(Pin*10**6)*100.##%\n", + "print '%s %.2f' %(\"Transmission Efficiency(%) : \",Eta)#\n", + "#Answer in book is wrong" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Parameter A, magnitude is 17.37 and angle in degree is 88.33\n", + "Parameter B, magnitude is 302.79 and angle in degree is 86.66\n", + "Parameter C, magnitude is 1.00 and angle in degree is 90.00\n", + "Parameter D, magnitude is 17.37 and angle in degree is 88.33\n", + "Sending end Line voltage(kV) : 3930.49\n", + "Sending end current(A), magnitude is 130613.70 and angle in degree is 88.75\n", + "Sending end power factor(lag) : 1.00\n", + "Power Input(MW) : 888811.72\n", + "Transmission Efficiency(%) : 0.01\n" + ] + } + ], + "prompt_number": 69 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E21 - Pg 152" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Sending end power factor(lag),Power Input(MW),Transmission Efficiency(%)\n", + "import math \n", + "import cmath\n", + "#Given data :\n", + "P=50.*10**6##VA\n", + "pf=0.8##power factor\n", + "cos_fi_r=pf#\n", + "sin_fi_r=math.sqrt(1-cos_fi_r**2)#\n", + "A=0.98*math.cos(3.*math.pi/180.) + 1j*math.sin(3.*math.pi/180.)##parameter of 3-phase line\n", + "D=0.98*math.cos(3.*math.pi/180.) + 1j*math.sin(3.*math.pi/180.)##parameter of 3-phase line\n", + "B=110*math.cos(75.*math.pi/180.) + 1j*math.sin(75.*math.pi/180.)##parameter of 3-phase line\n", + "C=0.0005*math.cos(80.*math.pi/180.) + 1j*math.sin(80.*math.pi/180.)##parameter of 3-phase line\n", + "VRL=110.*10**3##Volt\n", + "VR=VRL/math.sqrt(3.)##Volt\n", + "IR=P/(math.sqrt(3.)*VRL)##A\n", + "IR=IR*(cos_fi_r-1j*sin_fi_r)##A\n", + "VS=A*VR+B*IR##Volt\n", + "VSL=math.sqrt(3.)*abs(VS)##Volt\n", + "print '%s %.2f' %(\"Sending end Line voltage(kV) : \",VSL/1000.)#\n", + "IS=C*VR+D*IR##A\n", + "print '%s %.2f %s %.2f' %(\"Sending end current(A), magnitude is \",abs(IS),\" and angle in degree is \",cmath.phase(IS)*180/math.pi)#\n", + "fi_s=cmath.phase(VS)-cmath.phase(IS)##\n", + "cos_fis=math.cos(fi_s)##sending end pf\n", + "print '%s %.2f' %(\"Sending end power factor(lag) : \",cos_fis)#\n", + "Pin=math.sqrt(3.)*VSL*abs(IS)*cos_fis*10**-6##MW\n", + "print '%s %.2f' %(\"Power Input(MW) : \",Pin)#\n", + "Eta=P*pf/(Pin*10**6)*100.##%\n", + "print '%s %.2f' %(\"Transmission Efficiency(%) : \",Eta)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Sending end Line voltage(kV) : 118.28\n", + "Sending end current(A), magnitude is 62400.97 and angle in degree is 89.80\n", + "Sending end power factor(lag) : -0.01\n", + "Power Input(MW) : -134.12\n", + "Transmission Efficiency(%) : -29.82\n" + ] + } + ], + "prompt_number": 68 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E22 - Pg 153" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate \n", + "import math\n", + "import cmath\n", + "import numpy\n", + "from numpy import roots\n", + "#Given data :\n", + "f=50##Hz\n", + "L=300##km\n", + "r=0.15##ohm/km\n", + "x=0.5##ohm/km\n", + "y=3*10**-6##mho/km\n", + "VRL=220*10**3##Volt\n", + "VR=VRL/math.sqrt(3.)##Volt\n", + "P=200*10**6##W\n", + "pf=0.85##power factor\n", + "cos_fi_r=pf#\n", + "sin_fi_r=math.sqrt(1-cos_fi_r**2)#\n", + "R=r*L##ohm\n", + "X=x*L##ohm\n", + "Y=y*L##mho\n", + "Z=R+1j*X##ohm\n", + "#part (i)\n", + "A=1+1/2.*1j*Y*Z##parameter of 3-phase line\n", + "D=A##parameter of 3-phase line\n", + "B=Z##parameter of 3-phase line\n", + "C=1j*Y*(1.+1./4.*1j*Y*Z)##parameter of 3-phase line\n", + "print '%s %.4f %s %.2f' %(\"Parameter A, magnitude is \",abs(A),\" and angle in degree is \",cmath.phase(A)*180/math.pi)#\n", + "print '%s %.1f %s %.1f' %(\"Parameter B, magnitude is \",abs(B),\" and angle in degree is \",cmath.phase(B)*180/math.pi)#\n", + "print '%s %.2e %s %.2f' %(\"Parameter C, magnitude is \",abs(C),\" and angle in degree is \",cmath.phase(C)*180/math.pi)#\n", + "print '%s %.2f %s %.2f' %(\"Parameter D, magnitude is \",abs(D),\" and angle in degree is \",cmath.phase(D)*180/math.pi)#\n", + "#part (ii)\n", + "p=([0.024525, 11.427, -2102])##from VS=A*VR+B*IR##Volt\n", + "IR=roots(p)#\n", + "IR=IR[1]##taking +ve value\n", + "P=math.sqrt(3.)*VRL*IR*10**-6##MW\n", + "print '%s %.1f' %(\"Power received in MW : \",P)#\n", + "#/part (iii)\n", + "P=200.*10.**6##W\n", + "IR=P/math.sqrt(3.)/VRL/pf##A\n", + "fi=math.acos(pf) *180./math.pi##degree\n", + "IR=IR*math.cos(-fi*math.pi/180.) + 1j*math.sin(-fi*math.pi/180.)#\n", + "VS=A*VR+B*IR##Volt\n", + "VSL=math.sqrt(3.)*abs(VS)##Volt\n", + "print '%s %.2f' %(\"Sending end Line voltage(kV) : \",VSL/1000.)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Parameter A, magnitude is 0.9327 and angle in degree is 1.24\n", + "Parameter B, magnitude is 156.6 and angle in degree is 73.3\n", + "Parameter C, magnitude is 8.70e-04 and angle in degree is 90.60\n", + "Parameter D, magnitude is 0.93 and angle in degree is 1.24\n", + "Power received in MW : 53.8\n", + "Sending end Line voltage(kV) : 283.60\n" + ] + } + ], + "prompt_number": 59 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E23 - Pg 154" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Exa 5.23\n", + "import math \n", + "import cmath\n", + "#Given data :\n", + "A=0.936+1j*0.016##parameter of 3-phase line\n", + "D=A##parameter of 3-phase line\n", + "B=33.5+1j*138##parameter of 3-phase line\n", + "C=(-0.9280+1j*901.223)*10**-6##parameter of 3-phase line\n", + "VRL=200.*10**3##Volt\n", + "VR=VRL/math.sqrt(3.)##Volt\n", + "P=40*10**6##W\n", + "pf=0.86##power factor\n", + "cos_fi_r=pf#\n", + "sin_fi_r=math.sqrt(1-cos_fi_r**2)#\n", + "IR=P/math.sqrt(3.)/VRL/pf##A\n", + "fi=math.acos(pf) *180/math.pi##degree\n", + "IR=IR*(math.cos(-fi*math.pi/180.) + 1j*math.sin(-fi*math.pi/180.))#\n", + "VS=A*VR+B*IR##Volt\n", + "VSL=math.sqrt(3.)*abs(VS)##Volt\n", + "print '%s %.2f' %(\"Sending end Line voltage(kV) : \",VSL/1000.)#\n", + "IS=C*VR+D*IR##A\n", + "print '%s %.1f %s %.2f' %(\"Sending end current(A), magnitude is \",abs(IS),\" and angle in degree is \",cmath.phase(IS)*180/math.pi)#\n", + "fi_s=cmath.phase(VS)-cmath.phase(IS)##degree\n", + "print '%s %.4f' %(\"Sending end phase angle(degree): \",math.cos(fi_s))#\n", + "Ps=math.sqrt(3.)*abs(VSL)*abs(IS)*math.cos(fi_s)*10**-6##MW\n", + "print '%s %.3f' %(\"Sending end power(MW) : \",Ps)#\n", + "Vreg=(VSL-VRL)*100./VRL##%\n", + "print '%s %.2f' %(\"Voltage regulation in % : \",Vreg)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Sending end Line voltage(kV) : 211.98\n", + "Sending end current(A), magnitude is 116.8 and angle in degree is 20.96\n", + "Sending end phase angle(degree): 0.9716\n", + "Sending end power(MW) : 41.665\n", + "Voltage regulation in % : 5.99\n" + ] + } + ], + "prompt_number": 54 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E24 - Pg 155" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Sending end Line voltage(kV)\n", + "import cmath\n", + "import math\n", + "#Given data :\n", + "A1=0.98*(math.cos(2.*math.pi/180.) + 1j*math.sin(2.*math.pi/180.))##parameter of 3-phase line\n", + "D1=A1##parameter of 3-phase line\n", + "B1=28.*(math.cos(69.*math.pi/180.) + 1j*math.sin(69.*math.pi/180.))##parameter of 3-phase line\n", + "C1=0.0002*(math.cos(88.*math.pi/180.) + 1j*math.sin(88.*math.pi/180.))##parameter of 3-phase line\n", + "A2=0.95*(math.cos(3.*math.pi/180.) + 1j*math.sin(3.*math.pi/180.))##parameter of 3-phase line\n", + "D2=A2##parameter of 3-phase line\n", + "B2=40.*(math.cos(85.*math.pi/180.) + 1j*math.sin(85.*math.pi/180.))##parameter of 3-phase line\n", + "C2=0.0004*(math.cos(90.*math.pi/180.) + 1j*math.sin(90.*math.pi/180.))##parameter of 3-phase line\n", + "VRL=110.*10**3##Volt\n", + "VR=VRL/math.sqrt(3.)##Volt\n", + "IR=200.##A\n", + "pf=0.95##power factor\n", + "cos_fi_r=pf#\n", + "sin_fi_r=math.sqrt(1-cos_fi_r**2)#\n", + "fi=math.cos(pf)##degree\n", + "A=A1*A2+B1*C2##generalized parameter of 2 line\n", + "B=A1*B2+B1*D2##generalized parameter of 2 line\n", + "C=C1*A2+D1*C2##generalized parameter of 2 line\n", + "D=C1*B2+D1*D2##generalized parameter of 2 line\n", + "IR=IR*(math.cos(-fi*math.pi/180.) + 1j*math.sin(-fi*math.pi/180.))#\n", + "VS=A*VR+B*IR##Volt\n", + "VSL=math.sqrt(3.)*abs(VS)##Volt\n", + "print '%s %.2f' %(\"Sending end Line voltage(kV) : \",VSL/1000)#\n", + "IS=C*VR+D*IR##A\n", + "print '%s %.2f %s %.2f' %(\"Sending end current(A), magnitude is \",abs(IS),\" and angle in degree is \",cmath.phase(IS)*180/math.pi)#\n", + "#Answer for VSL is wrong in the book.\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Sending end Line voltage(kV) : 109.34\n", + "Sending end current(A), magnitude is 190.09 and angle in degree is 15.72\n" + ] + } + ], + "prompt_number": 51 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E25 - Pg 156" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Sending end power factor(lagging)\n", + "import cmath\n", + "import math\n", + "#Given data :\n", + "A1=0.98*(math.cos(1.*math.pi/180.) + 1j*math.sin(1.*math.pi/180.))##parameter of 3-phase line\n", + "D1=A1##parameter of 3-phase line\n", + "B1=100*(math.cos(75.*math.pi/180.) + 1j*math.sin(75.*math.pi/180.))##parameter of 3-phase line\n", + "C1=0.0005*(math.cos(90.*math.pi/180.) + 1j*math.sin(90.*math.pi/180.))##parameter of 3-phase line\n", + "A2=0.98*(math.cos(1.*math.pi/180.) + 1j*math.sin(1.*math.pi/180.))##parameter of 3-phase line\n", + "D2=A2##parameter of 3-phase line\n", + "B2=100*(math.cos(75.*math.pi/180.) + 1j*math.sin(75.*math.pi/180.))##parameter of 3-phase line\n", + "C2=0.0005*(math.cos(90.*math.pi/180.) + 1j*math.sin(90.*math.pi/180.))##parameter of 3-phase line\n", + "P=100*10**6##W\n", + "VRL=132*10**3##Volt\n", + "VR=VRL/math.sqrt(3)##Volt\n", + "pf=0.8##power factor\n", + "cos_fi_r=pf#\n", + "sin_fi_r=math.sqrt(1-cos_fi_r**2)#\n", + "fi=math.acos(pf)##degree\n", + "A=(A1*B2+A2*B1)/(B1+B2)##generalized parameter of 2 line\n", + "B=B1*B2/(B1+B2)##generalized parameter of 2 line\n", + "C=C1+C2-(A1-A2)*(D1-D2)/(B1+B2)##generalized parameter of 2 line\n", + "D=(B1*D2+B2*D1)/(B1+B2)##generalized parameter of 2 line\n", + "print '%s' %(\"Generalised constants ot two lines combined are : \")#\n", + "print '%s %.2f %s %.f' %(\"Parameter A, magnitude is \",abs(A),\" and angle in degree is \",cmath.phase(A)*180/math.pi)#\n", + "print '%s %.f %s %.2f' %(\"Parameter B, magnitude is \",abs(B),\" and angle in degree is \",cmath.phase(B)*180/math.pi)#\n", + "print '%s %.3f %s %.2f' %(\"Parameter C, magnitude is \",abs(C),\" and angle in degree is \",cmath.phase(C)*180/math.pi)#\n", + "print '%s %.2f %s %.2f' %(\"Parameter D, magnitude is \",abs(D),\" and angle in degree is \",cmath.phase(D)*180/math.pi)#\n", + "IR=P/math.sqrt(3.)/VRL/pf##A\n", + "IR=IR*(math.cos(-fi*math.pi/180.) + 1j*math.sin(-fi*math.pi/180.))#\n", + "VS=A*VR+B*IR##Volt\n", + "VSL=math.sqrt(3.)*abs(VS)##Volt\n", + "IS=C*VR+D*IR##A\n", + "fi_s=cmath.phase(VS)-cmath.phase(IS)#\n", + "print '%s %.4f' %(\"Sending end power factor(lagging) : \",math.cos(fi_s))#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Generalised constants ot two lines combined are : \n", + "Parameter A, magnitude is 0.98 and angle in degree is 1\n", + "Parameter B, magnitude is 50 and angle in degree is 75.00\n", + "Parameter C, magnitude is 0.001 and angle in degree is 90.00\n", + "Parameter D, magnitude is 0.98 and angle in degree is 1.00\n", + "Sending end power factor(lagging) : 0.9843\n" + ] + } + ], + "prompt_number": 50 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Elements_of_Power_system/Chapter_6.ipynb b/Elements_of_Power_system/Chapter_6.ipynb new file mode 100755 index 00000000..5edce177 --- /dev/null +++ b/Elements_of_Power_system/Chapter_6.ipynb @@ -0,0 +1,343 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:f3e57a0086738fdcfc0c2ba196533f123679df702a6579b464c4a555347a158e" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 6 - REPRESENTATION AND PERFORMANCE OF LONG TRANSMISSION LINES " + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E1 - Pg 168" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate A,B,C,D\n", + "import math \n", + "import cmath\n", + "import numpy\n", + "#Given data :\n", + "r=0.22##ohm\n", + "x=0.45##ohm\n", + "g=4.*10.**-9##S\n", + "b=2.53*10.**-6##S\n", + "f=50.##Hz\n", + "l=1000.##Km\n", + "#Using Convergent series of complex angles\n", + "z=r+1j*x##ohm\n", + "y=g+1j*b##ohm\n", + "Z=z*l##ohm\n", + "Y=y*l##ohm\n", + "YZ=Y*Z##ohm\n", + "Y2Z2=YZ**2.##ohm\n", + "Y3Z3=YZ**3.##ohm\n", + "A=1.+YZ/2.+Y2Z2/24.+Y3Z3/720.##ohm\n", + "D=A##oh,m\n", + "B=Z*(1.+YZ/6.+Y2Z2/120.+Y3Z3/5040.)##ohm\n", + "C=Y*(1.+YZ/6.+Y2Z2/120.+Y3Z3/5040.)##ohm\n", + "print '%s' %(\"Auxiliary Constants by using Convergent series of complex angles : \")#\n", + "print \"A = \",A#\n", + "print \"B = \",B#\n", + "print \"C = \",C#\n", + "#Using Convergent series of real angles\n", + "A=cmath.cosh(cmath.sqrt(YZ))##ohm\n", + "D=A##ohm\n", + "B=cmath.sqrt(Z/Y)*cmath.sinh(cmath.sqrt(YZ))##ohm\n", + "C=cmath.sqrt(Y/Z)*cmath.sinh(cmath.sqrt(YZ))##ohm\n", + "A=cmath.cosh(cmath.sqrt(YZ))##ohm\n", + "print '%s' %(\"Auxiliary Constants by using Convergent series of real angles : \")#\n", + "print '%s %.2f %s %.2f' %(\"A, magnitude is \",abs(A),\" and angle in degree is \",cmath.phase(A)*180/math.pi)#\n", + "print '%s %.2f %s %.2f' %(\"B, magnitude is \",abs(B),\" and angle in degree is \",cmath.phase(B)*180/math.pi)#\n", + "print '%s %.4f %s %.2f' %(\"C, magnitude is \",abs(C),\" and angle in degree is \",cmath.phase(C)*180/math.pi)#\n", + "print '%s' %(\"We obtain same result by both of the methods.\")\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Auxiliary Constants by using Convergent series of complex angles : \n", + "A = (0.471555198201+0.229032046676j)\n", + "B = (142.776787567+386.558406193j)\n", + "C = (-0.000206399312625+0.00207114180387j)\n", + "Auxiliary Constants by using Convergent series of real angles : \n", + "A, magnitude is 0.52 and angle in degree is 25.90\n", + "B, magnitude is 412.08 and angle in degree is 69.73\n", + "C, magnitude is 0.0021 and angle in degree is 95.69\n", + "We obtain same result by both of the methods.\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E2 - Pg 169" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Sending end line voltage in kV,Sending end current in A, magnitude is\n", + "import math\n", + "import cmath\n", + "\n", + "#Given data :\n", + "Z=200.*(math.cos(80.*math.pi/180.) + 1j*math.sin(80.*math.pi/180.))##ohm\n", + "Y=0.0013*(math.cos(90.*math.pi/180.) + 1j*math.sin(90.*math.pi/180.))#S/phase\n", + "P=80.*10.**6##W\n", + "pf=0.8##power factor\n", + "VRL=220.*1000.##V\n", + "VR=VRL/math.sqrt(3.)##V\n", + "IR=P/math.sqrt(3.)/VRL/pf##A\n", + "fi=math.acos(pf)*180/math.pi##degree\n", + "IR=IR*(math.cos(-fi*math.pi/180.) + 1j*math.sin(-fi*math.pi/180.))##A\n", + "YZ=Y*Z##ohm\n", + "Y2Z2=YZ**2##ohm\n", + "Y3Z3=YZ**3##ohm\n", + "A=1.+YZ/2.+Y2Z2/24+Y3Z3/720##ohm\n", + "D=A##oh,m\n", + "B=Z*(1.+YZ/6.+Y2Z2/120.+Y3Z3/5040.)##ohm\n", + "C=Y*(1.+YZ/6.+Y2Z2/120.+Y3Z3/5040.)##mho\n", + "VS=A*VR+B*IR##V\n", + "VSL=math.sqrt(3.)*abs(VS)##V\n", + "print '%s %.2f' %(\"Sending end line voltage in kV : \",VSL/1000.)#\n", + "IS=C*VR+D*IR##\n", + "print '%s %.2f %s %.2f' %(\"Sending end current in A, magnitude is \",abs(IS),\" and angle in degree is \",cmath.phase(IS)*180/math.pi)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Sending end line voltage in kV : 263.59\n", + "Sending end current in A, magnitude is 187.48 and angle in degree is 7.66\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E3 - Pg 176" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Constant A0,Constant B0,Constant C0,Constant D0\n", + "import math\n", + "import cmath\n", + "#Given data :\n", + "VRL=220.##kV\n", + "VR=VRL/math.sqrt(3.)##V\n", + "P=10.*10**6##VA\n", + "Z=1.+1j*8.##ohm(in %)\n", + "Zse=Z/100.*VRL**2./100.##ohm/phase\n", + "A=0.9*(math.cos(0.6*math.pi/180.) + 1j*math.sin(0.6*math.pi/180.))##Auxiliary constant\n", + "D=A ##Auxiliary constant\n", + "\n", + "B=153.2*(math.cos(84.6*math.pi/180.) + 1j*math.sin(84.6*math.pi/180.))##Auxiliary constant\n", + "C=0.0012*(math.cos(90*math.pi/180.) + 1j*math.sin(90*math.pi/180.))##Auxiliary constant\n", + "A0=A+C*Zse##constant\n", + "B0=B+D*Zse##ohm#constant\n", + "C0=C##mho or S#constant\n", + "D0=A##constant\n", + "print '%s %.4f %s %.2f' %(\"Constant A0, magnitude is \",abs(A0),\" and angle in degree is \",cmath.phase(A0)*180/math.pi)#\n", + "print '%s %.f %s %.2f' %(\"Constant B0(ohm), magnitude is \",abs(B0),\" and angle in degree is \",cmath.phase(B0)*180/math.pi)#\n", + "print '%s %.4f %s %.2f' %(\"Constant C0(S), magnitude is \",abs(C0),\" and angle in degree is \",cmath.phase(C0)*180/math.pi)#\n", + "print '%s %.1f %s %.2f' %(\"Constant D0, magnitude is \",abs(D0),\" and angle in degree is \",cmath.phase(D0)*180/math.pi)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Constant A0, magnitude is 0.8536 and angle in degree is 1.02\n", + "Constant B0(ohm), magnitude is 188 and angle in degree is 84.39\n", + "Constant C0(S), magnitude is 0.0012 and angle in degree is 90.00\n", + "Constant D0, magnitude is 0.9 and angle in degree is 0.60\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E4 - Pg 177" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Constant A0,Constant B0,Constant C0,Constant D0\n", + "import math\n", + "import cmath\n", + "#Given data :\n", + "A=0.98*(math.cos(2.*math.pi/180.) + 1j*math.sin(2.*math.pi/180.))##Auxiliary constant\n", + "D=A##Auxiliary constant\n", + "B=28.*(math.cos(69.*math.pi/180.) + 1j*math.sin(69.*math.pi/180.))##Auxiliary constant\n", + "Zse=12.*(math.cos(80.*math.pi/180.) + 1j*math.sin(80.*math.pi/180.))##ohm\n", + "C=(A*D-1)/B##Auxiliary constant\n", + "A0=A+C*Zse##constant\n", + "B0=B+2.*A*Zse+C*Zse**2.##ohm#constant\n", + "C0=C##mho or S#constant\n", + "D0=A0##constant\n", + "print '%s %.2f %s %.2f' %(\"Constant A0, magnitude is \",abs(A0),\" and angle in degree is \",cmath.phase(A0)*180/math.pi)#\n", + "print '%s %.2f %s %.2f' %(\"Constant B0(ohm), magnitude is \",abs(B0),\" and angle in degree is \",cmath.phase(B0)*180/math.pi)#\n", + "print '%s %.2f %s %.f' %(\"Constant C0(S), magnitude is \",abs(C0),\" and angle in degree is \",cmath.phase(C0)*180/math.pi)#\n", + "print '%s %.3f %s %.2f' %(\"Constant D0, magnitude is \",abs(D0),\" and angle in degree is \",cmath.phase(D0)*180/math.pi)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Constant A0, magnitude is 0.96 and angle in degree is 3.53\n", + "Constant B0(ohm), magnitude is 50.89 and angle in degree is 75.24\n", + "Constant C0(S), magnitude is 0.00 and angle in degree is 53\n", + "Constant D0, magnitude is 0.958 and angle in degree is 3.53\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E5 - Pg 177" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate \n", + "import math \n", + "import cmath\n", + "#Given data :\n", + "A=0.92*(math.cos(5.3*math.pi/180.) + 1j*math.sin(5.3*math.pi/180.))#Auxiliary constant\n", + "D=A##Auxiliary constant\n", + "B=65.3*(math.cos(81*math.pi/180.) + 1j*math.sin(81*math.pi/180.))##Auxiliary constant\n", + "ZT=100*(math.cos(70*math.pi/180.) + 1j*math.sin(70*math.pi/180.))##ohm\n", + "YT=0.0002*(math.cos(-75.*math.pi/180.) + 1j*math.sin(-75.*math.pi/180.))##S\n", + "C=(A*D-1)/B##Auxiliary constant\n", + "A0=A*(1+2*YT*ZT)+B*(YT)+C*ZT*(1+YT*ZT)##constant\n", + "B0=2.*A*ZT+B+C*ZT**2##ohm#constant\n", + "C0=2.*A*YT*(1.+YT*ZT)+B*YT**2.+C*(1.+YT*ZT)**2.##mho or S#constant\n", + "D0=A0##constant\n", + "print '%s %.5f %s %.2f' %(\"Constant A0, magnitude is \",abs(A0),\" and angle in degree is \",cmath.phase(A0)*180/math.pi)#\n", + "print '%s %.2f %s %.2f' %(\"Constant B0(ohm), magnitude is \",abs(B0),\" and angle in degree is \",cmath.phase(B0)*180/math.pi)#\n", + "print '%s %.6f %s %.1f' %(\"Constant C0(S), magnitude is \",abs(C0),\" and angle in degree is \",cmath.phase(C0)*180/math.pi)#\n", + "print '%s %.2f %s %.2f' %(\"Constant D0, magnitude is \",abs(D0),\" and angle in degree is \",cmath.phase(D0)*180/math.pi)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Constant A0, magnitude is 0.84340 and angle in degree is 26.45\n", + "Constant B0(ohm), magnitude is 233.85 and angle in degree is 84.30\n", + "Constant C0(S), magnitude is 0.003442 and angle in degree is 50.9\n", + "Constant D0, magnitude is 0.84 and angle in degree is 26.45\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E6 - Pg 178" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate \n", + "import math \n", + "import cmath\n", + "#Given data :\n", + "A=0.945*math.cos(1.02*math.pi/180.) + 1j*math.sin(1.02*math.pi/180.)##Auxiliary constant\n", + "D=A##Auxiliary constant\n", + "B=82.3*math.cos(73.03*math.pi/180.) + 1j*math.sin(73.03*math.pi/180.)##ohm#Auxiliary constant\n", + "C=0.001376*math.cos(90.4*math.pi/180.) + 1j*math.sin(90.4*math.pi/180.)##S#Auxiliary constant\n", + "#part (i)\n", + "Y=C##S\n", + "Z=2.*(A-1)/C##ohm\n", + "print '%s' %(\"For equivalent T-network : \")#\n", + "print '%s %.6f %s %.1f' %(\"Shunt admittance in S, magnitude is \",abs(Y),\" and angle in degree is \",cmath.phase(Y)*180/math.pi)#\n", + "print '%s %.2f %s %.1f' %(\"Impedance in ohm, magnitude is \",abs(Z),\" and angle in degree is \",cmath.phase(Z)*180/math.pi)#\n", + "print '%s' %(\"For equivalent pi-network : \")#\n", + "Z=B##ohm\n", + "print '%s %.2f %s %.2f' %(\"Series Impedance in ohm, magnitude is \",abs(Z),\" and angle in degree is \",cmath.phase(Z)*180/math.pi)#\n", + "Y=2.*(A-1)/B##S\n", + "print '%s %.6f %s %.2f' %(\"Shunt admittance in S, magnitude is \",abs(Y),\" and angle in degree is \",cmath.phase(Y)*180/math.pi)#\n", + "#For T-Network Value of Z is wrog in the book.\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "For equivalent T-network : \n", + "Shunt admittance in S, magnitude is 0.999976 and angle in degree is 90.0\n", + "Impedance in ohm, magnitude is 0.12 and angle in degree is 72.1\n", + "For equivalent pi-network : \n", + "Series Impedance in ohm, magnitude is 24.04 and angle in degree is 2.28\n", + "Shunt admittance in S, magnitude is 0.004821 and angle in degree is 159.83\n" + ] + } + ], + "prompt_number": 15 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Elements_of_Power_system/Chapter_7.ipynb b/Elements_of_Power_system/Chapter_7.ipynb new file mode 100755 index 00000000..fba9cc63 --- /dev/null +++ b/Elements_of_Power_system/Chapter_7.ipynb @@ -0,0 +1,454 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:7a4739840eca82c1ce9eed121a54d5060bb7d710089eb77f452cc47ec3867eee" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 7 - CORONA" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E1 - Pg 189" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Line Voltage for comencing of corena(in kV)\n", + "import math\n", + "#Given data :\n", + "r=1.##cm\n", + "d=4.##meter\n", + "g0=30./math.sqrt(2.)##kV/cm\n", + "LineVoltage=math.sqrt(3.)*g0*r*math.log(d*100./r)##kV\n", + "print '%s %.2f' %(\"Line Voltage for comencing of corena(in kV) :\",round(LineVoltage))#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Line Voltage for comencing of corena(in kV) : 220.00\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E2 - Pg 190" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Disruptive critical voltage from line to line(kV rms)\n", + "import math\n", + "#Given data :\n", + "Ph=3.##phase\n", + "V=220.##kV\n", + "f=50.##Hz\n", + "r=1.2##cm\n", + "d=2.##meter\n", + "mo=0.96##Irregularity factor\n", + "t=20.##degree C\n", + "T=t+273.##K\n", + "b=72.2##cm\n", + "go=21.1##kV rms/cm\n", + "dela=3.92*b/T##Air density factor\n", + "Vdo=go*dela*mo*r*math.log(d*100./r)##in kV\n", + "Vdo_line=math.sqrt(3.)*Vdo##in kV\n", + "print '%s %.2f' %(\"Disruptive critical voltage from line to line(kV rms) : \",round(Vdo_line))#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Disruptive critical voltage from line to line(kV rms) : 208.00\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E3 - Pg 190" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Spacing between conductors in meter\n", + "import math\n", + "#Given data :\n", + "V=132.##kV\n", + "r=2./2.##cm\n", + "Vexceed=210.##kV(rms)\n", + "go=30000./math.sqrt(2.)##Volts/cm\n", + "go=go/1000.##kV/cm\n", + "Vdo=Vexceed/math.sqrt(3.)##Volt\n", + "mo=1.##assumed \n", + "dela=1.##assumed air density factor\n", + "#Formula : Vdo=go*del*mo*r*log(d*100/r)##in kV\n", + "d=math.exp(Vdo/go/dela/mo/r)*r##cm\n", + "print '%s %.2f' %(\"Spacing between conductors in meter : \",d*10**-2)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Spacing between conductors in meter : 3.04\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E4 - Pg 190" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Minimum Diameter of conductor by Hit & Trial method(cm)\n", + "import math\n", + "import numpy\n", + "#Given data :\n", + "Ph=3.##phase\n", + "V=132.##kV\n", + "f=50.##Hz\n", + "d=3.##meter\n", + "d=d*100.##in cm\n", + "go=21.21##kV/cm : assumed\n", + "mo=0.85##assumed \n", + "dela=0.95##assumed air density factor\n", + "Vdo=V/math.sqrt(3.)##kV\n", + "#Formula : Vdo=go*del*mo*r*log(d*100/r)##in kV\n", + "#r*log(d/r)=Vdo/go/del/mo: solving\n", + "#Implementing Hit & Trial method\n", + "w=numpy.zeros(200)\n", + "\n", + "w[0]=.1\n", + "for i in range (1,200):\n", + "\tw[i]=.1+w[i-1];\n", + "\n", + "for r in w:\n", + " if round(r*math.log(d/r))==round(Vdo/go/dela/mo):\n", + " print '%s %.2f' %(\"Minimum Diameter of conductor by Hit & Trial method(cm) : \",2*r)#\n", + " break" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Minimum Diameter of conductor by Hit & Trial method(cm) : 1.20\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E5 - Pg 191" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate g1max(kV/cm)\n", + "import math\n", + "#Given data :\n", + "r=2.5/2.##cm\n", + "epsilon_r=4.##constant\n", + "r1=3./2.##cm\n", + "r2=9./2.##cm\n", + "V=20.##kV(rms)\n", + "#Formula : gmax=q/(2*epsilon*r)\n", + "g2maxBYg1max=r/epsilon_r/r1##unitless\n", + "#Formula : V=g1max*r*log(r1/r)+g2max*r1*log(r2/r1)\n", + "g1max=V/(r*math.log(r1/r)+g2maxBYg1max*r1*math.log(r2/r1))##in kV/cm\n", + "print '%s %.2f' %(\"g1max(kV/cm) = \",g1max)#\n", + "print '%s' %(\"Corona will be present.g1max > go\")#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "g1max(kV/cm) = 35.01\n", + "Corona will be present.g1max > go\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E6 - Pg 192" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Line to line visual critical voltage for local corona(kV-rms),Line to line visual critical voltage for general corona(kV-rms)\n", + "import math\n", + "#Given data :\n", + "Ph=3.##phase\n", + "r=10.4/2##mm\n", + "r=r/10.##in cm\n", + "d=2.5##meter\n", + "d=d*100.##in cm\n", + "t=21.##degree C\n", + "T=t+273.##K\n", + "b=73.6##cm-Hg\n", + "mo=0.85# \n", + "mv_l=0.7#\n", + "mv_g=0.8#\n", + "go=21.21##kV/cm : assumed\n", + "dela=3.92*b/T##Air density factor\n", + "#Formula : Vdo=go*del*mo*r*log(d*100/r)##kV\n", + "Vdo=go*dela*mo*r*math.log(d/r)##kV\n", + "Vdo_line=math.sqrt(3.)*Vdo##kV\n", + "Vvo=go*dela*mv_l*r*(1+.3/math.sqrt(dela*r))*math.log(d/r)##kV\n", + "Vvo_line_local=Vvo*math.sqrt(3.)##kV(rms)\n", + "print '%s %.1f' %(\"Line to line visual critical voltage for local corona(kV-rms) : \",Vvo_line_local)\n", + "Vvo_line_general=Vvo_line_local*mv_g/mv_l##kV(rms)\n", + "print '%s %.f' %(\"Line to line visual critical voltage for general corona(kV-rms) : \",Vvo_line_general)\n", + "#Note : Answer in the book is not accurate.\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Line to line visual critical voltage for local corona(kV-rms) : 115.1\n", + "Line to line visual critical voltage for general corona(kV-rms) : 132\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E7 - Pg 193" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Corona Loss at 113 kV in kW ,Disruptive critical voltage between lines(kV)\n", + "#Given data :\n", + "import math\n", + "Pc1=53.##in kW\n", + "V1=106.##in kV\n", + "Pc2=98.##in kW\n", + "V2=110.9##in kV\n", + "Vph1=V1/math.sqrt(3.)##in kV\n", + "Vph2=V2/math.sqrt(3.)##in kV\n", + "#Formula : Pc=3*244/del*(f+25)*sqrt(r/d)*(Vph-Vdo)**2*10**-5##kW/Km\n", + "print '%s' %(\"Using proportionality : Pc is proportional to (Vph-Vdo)**2\")#\n", + "print '%s' %(\"We have, Pc1/Pc2 = (Vph1-Vdo)**2/(Vph2-Vdo)**2\")#\n", + "Vdo=(Vph1-math.sqrt(Pc1/Pc2)*(Vph2))/(1-math.sqrt(Pc1/Pc2))#\n", + "V3=113.##in kV\n", + "Vph3=V3/math.sqrt(3.)##in kV\n", + "Pc3=Pc2*(Vph3-Vdo)**2./(Vph2-Vdo)**2##in kW\n", + "print '%s %.1f' %(\"Corona Loss at 113 kV in kW : \",Pc3)#\n", + "VLine=math.sqrt(3.)*Vdo##in kV\n", + "print '%s %.1f' %(\"Disruptive critical voltage between lines(kV): \",VLine)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Using proportionality : Pc is proportional to (Vph-Vdo)**2\n", + "We have, Pc1/Pc2 = (Vph1-Vdo)**2/(Vph2-Vdo)**2\n", + "Corona Loss at 113 kV in kW : 121.5\n", + "Disruptive critical voltage between lines(kV): 92.4\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E8 - Pg 194" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Total corona loss under foul weather condition using Peek formula in kW,Total corona loss under foul weather condition using Peterson formula in kW \n", + "import math\n", + "#Given data :\n", + "f=50.##Hz\n", + "l=160.##km\n", + "r=1.036/2.##cm\n", + "d=2.44*100.##cm\n", + "g0=21.1##kV/cm(rms)\n", + "m0=0.85##irregularity factor\n", + "mv=0.72##roughness factor\n", + "b=73.15##cm\n", + "t=26.6##degree C\n", + "dela=3.92*b/(273.+t)##air density factor\n", + "Vd0=g0*dela*m0*r*math.log(d/r)##kV(rms)\n", + "print '%s %.2f' %(\"Critical disruptive voltage(rms) in kV : \",Vd0)#\n", + "Vv0=g0*dela*mv*r*(1+0.3/math.sqrt(dela*r))*math.log(d/r)##kV\n", + "print '%s %.1f' %(\"Visual Critical voltage(rms) in kV : \",Vv0)#\n", + "Vph=110./math.sqrt(3.)##in kV\n", + "Pc_dash=d/dela*(f+25)*math.sqrt(r/d)*(Vph-0.8*Vd0)**2*10**-5##kW/km/phase\n", + "T_Corona_loss=l*3*Pc_dash##kW\n", + "print '%s %.f' %(\"Total corona loss under foul weather condition using Peek formula in kW : \",T_Corona_loss)#\n", + "VphBYVd0=Vph/Vd0/0.8#\n", + "K=0.46##constant\n", + "Corona_loss=21*10**-5*f*Vph**2*K/(math.log10(d/r))**2##kW/km/phase\n", + "T_corona_loss=Corona_loss*3*l##kW\n", + "print '%s %.1f' %(\"Total corona loss under foul weather condition using Peterson formula in kW : \",T_corona_loss)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Critical disruptive voltage(rms) in kV : 54.73\n", + "Visual Critical voltage(rms) in kV : 66.1\n", + "Total corona loss under foul weather condition using Peek formula in kW : 1645\n", + "Total corona loss under foul weather condition using Peterson formula in kW : 1308.7\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E9 - Pg 195" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Power loss due to corona for fair weather condition,Total corona loss using Peek formula in kW,Total corona loss under foul weather condition using Peterson formula in kW \n", + "import math\n", + "#given data :\n", + "f=50.##Hz\n", + "l=175.##km\n", + "r=1./2.##cm\n", + "d=3.*100.##cm\n", + "g0=21.1##kV/cm(rms)\n", + "m0=0.85##irregularity factor\n", + "mv=0.72##roughness factor\n", + "mv_dash=0.82##roughness factor\n", + "b=74.##cm\n", + "t=26.##degree C\n", + "Vph=110./math.sqrt(3.)##kV\n", + "dela=3.92*b/(273.+t)##air density factor\n", + "Vd0=g0*dela*m0*r*math.log(d/r)##kV(rms)\n", + "Vvo=g0*dela*mv*r*(1.+0.3/math.sqrt(dela*r))*math.log(d/r)##kV rms\n", + "Vvo_dash=Vvo*mv_dash/mv##kV rms\n", + "Pc=244./dela*(f+25.)*math.sqrt(r/d)*(Vph-Vd0)**2.*10.**-5##kW/Km/phase\n", + "T_CoronaLoss=Pc*l*3.##kW\n", + "print '%s' %(\"Power loss due to corona for fair weather condition : \")#\n", + "print '%s %.f' %(\"Total corona loss using Peek formula in kW : \",T_CoronaLoss)#\n", + "K=0.0713##constant for Vph/Vdo=1.142\n", + "Pc=21.*10.**-5*f*Vph**2./(math.log10(d/r))**2.*K##kW/Km/phase\n", + "T_CoronaLoss=Pc*l*3##kW\n", + "print '%s %.1f' %(\"According Peterson formula, Total corona loss for 175 km 3-phase line(kW): \",T_CoronaLoss)#\n", + "print '%s' %(\"Power loss due to corona for stormy weather condition : \")#\n", + "Vd0=0.8*Vd0##kV\n", + "Pc_dash=l*3.*244./dela*(f+25.)*math.sqrt(r/d)*(Vph-Vd0)**2.*10.**-5##kW/Km/phase\n", + "print '%s %.f' %(\"Total corona loss using Peek formula in kW : \",Pc_dash)#\n", + "K=0.395##constant for Vph/Vdo=1.42\n", + "Pc=21.*10.**-5*f*Vph**2./(math.log10(d/r))**2.*K##kW/Km/phase\n", + "T_CoronaLoss=Pc*l*3.##kW\n", + "print '%s %.f' %(\"According Peterson formula, Total corona loss for 175 km 3-phase line(kW): \",T_CoronaLoss)#\n", + "#Answer is wrong in the book for corona loss fair weather condition using Peek formula.\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Power loss due to corona for fair weather condition : \n", + "Total corona loss using Peek formula in kW : 249\n", + "According Peterson formula, Total corona loss for 175 km 3-phase line(kW): 205.4\n", + "Power loss due to corona for stormy weather condition : \n", + "Total corona loss using Peek formula in kW : 1457\n", + "According Peterson formula, Total corona loss for 175 km 3-phase line(kW): 1138\n" + ] + } + ], + "prompt_number": 8 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Elements_of_Power_system/Chapter_8.ipynb b/Elements_of_Power_system/Chapter_8.ipynb new file mode 100755 index 00000000..423bc6e5 --- /dev/null +++ b/Elements_of_Power_system/Chapter_8.ipynb @@ -0,0 +1,123 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:6d073c49f372dda47c7aa22d6e606de390e394a91f8374089b05d9ccb3405267" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 8 - ELECTROSTATIC AND ELECTROMAGNETIC INTERFERENCE WITH COMMUNICATION LINES" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E1 - Pg 203" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Voltage induced per Km in the line in Volt\n", + "import math\n", + "#Given data :\n", + "f=50.##Hz\n", + "hor_con=1.2##horizontal configuration spacing in m\n", + "x=0.85##telephone line location below power line in meter\n", + "I=120.##current in power line in A\n", + "d=0.4##spacing between conductors in meter\n", + "dAD=math.sqrt(x**2.+((hor_con+d)/2.)**2.)##m\n", + "dAC=math.sqrt(x**2.+((hor_con-d)/2.)**2.)##m\n", + "dBD=dAC##m\n", + "dBC=dAD##m\n", + "M=d*math.log(math.sqrt(dAD*dBC/dAC/dBD))##mh/km\n", + "Vm=2*math.pi*f*M*10.**-3*I##V\n", + "print '%s %.3f' %(\"Voltage induced per Km in the line in Volt :\",Vm)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Voltage induced per Km in the line in Volt : 3.275\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E2 - Pg 205" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate \n", + "import math\n", + "#Given data :\n", + "f=50.##HzdAP=AO+5##m\n", + "l=200.##km\n", + "V=132.*1000.##V\n", + "Load=28000.##kW\n", + "pf=0.85##lagging power factor\n", + "r=5./1000.##radius of conductor in m\n", + "#From the figure given in question\n", + "AO=math.sqrt(4.**2.-2.**2.)##m\n", + "dAP=AO+5.##m\n", + "dAQ=dAP+1.##m\n", + "dBP=math.sqrt(5.**2.+2.**2.)##m\n", + "dBQ=math.sqrt(6.**2.+2.**2.)##m\n", + "MA=0.2*math.log(dAQ/dAP)##mH/km\n", + "MB=0.2*math.log(dBQ/dBP)##mH/km\n", + "MC=MB##mH/km\n", + "M=MB-MA##mH/km(MA,MB and Mc are print '%s %.2f' %laced by 120 degree)\n", + "I=Load*1000./math.sqrt(3.)/V/pf##A\n", + "Vm=2.*math.pi*f*M*10.**-3.*I##V/km\n", + "Vm1=Vm*l##V(For whole route)\n", + "print '%s %.1f' %(\"Induced Voltage(For whole route) in Volts : \",Vm1)#\n", + "VA=V/math.sqrt(3.)##V\n", + "VB=V/math.sqrt(3.)##V\n", + "hA=20.+AO##m\n", + "VPA=VA*math.log((2.*hA-dAP)/dAP)/math.log((2.*hA-r)/r)##V\n", + "VPB=VB*math.log((2.*hA-dBP)/dBP)/math.log((2.*hA-r)/r)##V\n", + "VPC=VPB##V\n", + "VP=VPB-VPA##V\n", + "print '%s %.f' %(\"Potential of telephone conductor in Volts :\",VP)#\n", + "#Answer in the book is wrong due to little accuracy as compared to scilab.\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Induced Voltage(For whole route) in Volts : 88.9\n", + "Potential of telephone conductor in Volts : 4409\n" + ] + } + ], + "prompt_number": 2 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Elements_of_Power_system/Chapter_9.ipynb b/Elements_of_Power_system/Chapter_9.ipynb new file mode 100755 index 00000000..4d406e3b --- /dev/null +++ b/Elements_of_Power_system/Chapter_9.ipynb @@ -0,0 +1,569 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:3ce27a1ffc85e51aa7fc37d88fef9ce130fae45889a6045109b8b780c88a7574" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 9 - OVERHEAD LINE INSULATORS" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E1 - Pg 220" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Voltage across the first,second,third,fourth,fifth,sixth unit\n", + "import math\n", + "#Given data :\n", + "C1=1.##\n", + "C=6.#\n", + "K=C1/C#\n", + "V2byV1=(1.+K)#\n", + "V3byV1=(1.+3.*K+K**2.)#\n", + "V4byV1=(1.+6.*K+5.*K**2.+K**3.)#\n", + "#I5=I4+i4#\n", + "#omega*C*V5=omega*C*V4+omega*C1*(V1+V2+V3+V4)\n", + "V5byV1=1.+10.*K+15.*K**2.+7.*K**3.+K**4.\n", + "VbyV1=1+V2byV1+V3byV1+V4byV1+V5byV1#\n", + "V1byV=1/VbyV1#\n", + "print '%s %.3f %s' %(\"Voltage across the first unit is \",V1byV*100,\" % of V\")#\n", + "print '%s %.3f %s' %(\"Voltage across the seconf unit is \",V2byV1*V1byV*100,\" % of V\")#\n", + "print '%s %.3f %s' %(\"Voltage across the third unit is \",V3byV1*V1byV*100,\" % of V\")#\n", + "print '%s %.3f %s' %(\"Voltage across the fourth unit is \",V4byV1*V1byV*100,\" % of V\")#\n", + "print '%s %.3f %s' %(\"Voltage across the bottom most unit is \",V5byV1*V1byV*100,\" % of V\")#\n", + "n=5##no. of unit\n", + "Strinf_eff=1/n/(V5byV1*V1byV)##%\n", + "print '%s %.2f' %(\"String Efficiency(%)\",Strinf_eff*100.)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Voltage across the first unit is 11.168 % of V\n", + "Voltage across the seconf unit is 13.029 % of V\n", + "Voltage across the third unit is 17.062 % of V\n", + "Voltage across the fourth unit is 23.938 % of V\n", + "Voltage across the bottom most unit is 34.804 % of V\n", + "String Efficiency(%) 0.00\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E2 - Pg 221" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Voltage across the first,second,third,fourth,fifth,sixth unit\n", + "import math\n", + "#Given data :\n", + "C1=1.##\n", + "C=10.#\n", + "K=C1/C#\n", + "V2byV1=(1.+K)#\n", + "V3byV1=(1.+3.*K+K**2.)#\n", + "V4byV1=(1.+6.*K+5.*K**2.+K**3.)#\n", + "V5byV1=1.+10.*K+15.*K**2.+7.*K**3.+K**4.\n", + "#I6=I5+i5#\n", + "#omega*C*V6=omega*C*V5+omega*C1*(V1+V2+V3+V4+V5)\n", + "V6byV1=V5byV1+K*(1.+V2byV1+V3byV1+V4byV1+V5byV1)#\n", + "VbyV1=1.+V2byV1+V3byV1+V4byV1+V5byV1+V6byV1#\n", + "V1byV=1./VbyV1#\n", + "print '%s %.3f %s' %(\"Voltage across the first unit is \",V1byV*100,\" % of V\")#\n", + "print '%s %.3f %s' %(\"Voltage across the seconf unit is \",V2byV1*V1byV*100,\" % of V\")#\n", + "print '%s %.3f %s' %(\"Voltage across the third unit is \",V3byV1*V1byV*100,\" % of V\")#\n", + "print '%s %.3f %s' %(\"Voltage across the fourth unit is \",V4byV1*V1byV*100,\" % of V\")#\n", + "print '%s %.3f %s' %(\"Voltage across the fifth unit is \",V5byV1*V1byV*100,\" % of V\")#\n", + "print '%s %.3f %s' %(\"Voltage across the sixth unit is \",V6byV1*V1byV*100,\" % of V\")#\n", + "n=6##no. of unit\n", + "Strinf_eff=1/n/(V6byV1*V1byV)##%\n", + "print '%s %.2f' %(\"String Efficiency(%)\",Strinf_eff*100)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Voltage across the first unit is 9.904 % of V\n", + "Voltage across the seconf unit is 10.894 % of V\n", + "Voltage across the third unit is 12.974 % of V\n", + "Voltage across the fourth unit is 16.351 % of V\n", + "Voltage across the fifth unit is 21.364 % of V\n", + "Voltage across the sixth unit is 28.513 % of V\n", + "String Efficiency(%) 0.00\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E3 - Pg 222" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Part(i) Percentage String Efficiency,Part(ii) Percentage String Efficiency\n", + "import math\n", + "#Given data :\n", + "V=66.##kV\n", + "#Part(i)\n", + "n=5.##no. of uniits\n", + "K=1./5.##shunt to mutual capacitance ratio\n", + "V1=V/(5.+20.*K+21.*K**2.+8.*K**3.+K**4.)##kV\n", + "V5=V1*(1.+10.*K+15.*K**2.+7.*K**3.+K**4.)##kV\n", + "Strinf_eff=V/n/V5#\n", + "print '%s %.2f' %(\"Part(i) Percentage String Efficiency(%)\",Strinf_eff*100.)#\n", + "#Part(ii)\n", + "n=5.##no. of uniits\n", + "K=1./6.##shunt to mutual capacitance ratio\n", + "V1=V/(5.+20.*K+21.*K**2.+8.*K**3.+K**4.)##kV\n", + "V5=V1*(1.+10.*K+15.*K**2.+7.*K**3.+K**4.)##kV\n", + "Strinf_eff=V/n/V5#\n", + "print '%s %.2f' %(\"Part(ii) Percentage String Efficiency(%)\",Strinf_eff*100)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Part(i) Percentage String Efficiency(%) 54.16\n", + "Part(ii) Percentage String Efficiency(%) 57.46\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E4 - Pg 223" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Voltage across top most unit(kV),Voltage across middle unit(kV),Percentage String Efficiency(%)\n", + "import math\n", + "#Given data :\n", + "Vs=20.##kV\n", + "n=3.##no. of uniits\n", + "K=0.1##shunt to mutual capacitance ratio\n", + "V3=Vs##kV\n", + "V1=V3/(1.+3.*K+K**2.)##kV\n", + "print '%s %.3f' %(\"Voltage across top most unit(kV)\",V1)#\n", + "V2=V1*(1.+K)##kV\n", + "print '%s %.3f' %(\"Voltage across middle unit(kV)\",V2)#\n", + "V=V1+V2+V3##kV\n", + "Strinf_eff=V/n/V3#\n", + "print '%s %.3f' %(\"Percentage String Efficiency(%)\",Strinf_eff*100.)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Voltage across top most unit(kV) 15.267\n", + "Voltage across middle unit(kV) 16.794\n", + "Percentage String Efficiency(%) 86.768\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E5 - Pg 223" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Maximum safe working voltage(kV)\n", + "import math\n", + "#Given data :\n", + "Vs=17.5##kV\n", + "n=3.##no. of uniits\n", + "K=1./8.##shunt to mutual capacitance ratio\n", + "V3=Vs##kV\n", + "V1=V3/(1.+3.*K+K**2.)##kV\n", + "V2=V1*(1.+K)##kV\n", + "V=V1+V2+V3##kV\n", + "#Strinf_eff=V/n/V3#\n", + "print '%s %.2f' %(\"Maximum safe working voltage(kV)\",V)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Maximum safe working voltage(kV) 44.24\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E6 - Pg 224" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Maximum safe working voltage,Percentage String Efficiency\n", + "import math\n", + "#Given data :\n", + "Vs=12.##kV\n", + "n=4.##no. of uniits\n", + "K=0.1##shunt to mutual capacitance ratio\n", + "V4=Vs##kV\n", + "V1=V4/(1.+6.*K+5.*K**2.+K**3.)##kV\n", + "V2=V1*(1.+K)##kV\n", + "V3=V1*(1.+3.*K+K**2.)##kV\n", + "V=V1+V2+V3+V4##kV\n", + "print '%s %.2f' %(\"Maximum safe working voltage(kV)\",V)#\n", + "Strinf_eff=V/n/V4#\n", + "print '%s %.3f' %(\"Percentage String Efficiency(%)\",Strinf_eff*100)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Maximum safe working voltage(kV) 36.78\n", + "Percentage String Efficiency(%) 76.635\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E7 - Pg 224" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Maximum safe working voltage\n", + "import math\n", + "#Given data :\n", + "Vs=11.##kV\n", + "n=5.##no. of uniits\n", + "K=0.1##shunt to mutual capacitance ratio\n", + "V5=Vs##kV\n", + "V1=V5/(1.+10.*K+15.*K**2.+7.*K**3.+K**4.)##kV\n", + "V2=V1*(1.+K)##kV\n", + "V3=V1*(1.+3.*K+K**2.)##kV\n", + "V4=V1*(1.+6.*K+5.*K**2.+K**3.)##kV\n", + "V=V1+V2+V3+V4+V5##kV\n", + "print '%s %.1f' %(\"Maximum safe working voltage(kV)\",V)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Maximum safe working voltage(kV) 36.8\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E8 - Pg 225" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Voltage between conductors(kV),Percentage String Efficiency(%)\n", + "import math\n", + "import numpy\n", + "from numpy import roots\n", + "#Given data :\n", + "V2=15.##kV\n", + "V3=21.##kV\n", + "n=4.##no. of uniits\n", + "#V3/V2=(1+3*K+K**2)/(1+K)\n", + "#K**2*V2+K*(V3+3*V2)-V2+V3=0#\n", + "p=([V2, -V3+3.*V2, V2-V3])#\n", + "K=numpy.roots(p)#\n", + "K=K[1]##Taking +ve value\n", + "V1=V2/(1.+K)##kV\n", + "V4=(1.+6.*K+5.*K**2.+K**3.)*V1##kV\n", + "V=V1+V2+V3+V4##kV\n", + "VL=math.sqrt(3.)*V##kV\n", + "print '%s %.1f' %(\"Voltage between conductors(kV)\",VL)#\n", + "Strinf_eff=V/n/V4#\n", + "print '%s %.2f' %(\"Percentage String Efficiency(%)\",Strinf_eff*100.)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Voltage between conductors(kV) 138.4\n", + "Percentage String Efficiency(%) 63.19\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E9 - Pg 228" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate C2,C3,C4,C5,C6\n", + "import math\n", + "#Given data :\n", + "K=0.1##shunt to mutual capacitance ratio\n", + "CbyC1=10.#\n", + "C2byC1=(1.+K)*CbyC1#\n", + "C3byC1=(1.+3.*K)*CbyC1#\n", + "C4byC1=(1.+6.*K)*CbyC1#\n", + "print '%s %.2f %s' %(\"C2 is \",C2byC1,\" times of C1\")#\n", + "print '%s %.2f %s' %(\"C3 is \",C3byC1,\" times of C1\")#\n", + "print '%s %.2f %s' %(\"C4 is \",C4byC1,\" times of C1\")#\n", + "#I5=I4+i4\n", + "#omega*C5*v=omega*C4*v+omega*C1*4*v\n", + "C5byC1=(1.+10.*K)*CbyC1#\n", + "print '%s %.2f %s' %(\"C5 is \",C5byC1,\" times of C1\")#\n", + "#I6=I5+i5\n", + "#omega*C6*v=omega*C5*v+omega*C1*5*v\n", + "C6byC1=(1.+15.*K)*CbyC1#\n", + "print '%s %.2f %s' %(\"C6 is \",C6byC1,\" times of C1\")#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "C2 is 11.00 times of C1\n", + "C3 is 13.00 times of C1\n", + "C4 is 16.00 times of C1\n", + "C5 is 20.00 times of C1\n", + "C6 is 25.00 times of C1\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E10 - Pg 229" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate C1,C2,C3,C4,C5,C6,C7\n", + "import math\n", + "#Given data :\n", + "n=8.##no. of units\n", + "p=[1 ,2, 3, 4, 5, 6, 7, 8]#\n", + "#Cp=p*C/(n-p)\n", + "C1byC=1/(n-p[0])#\n", + "C2byC=2/(n-p[1])#\n", + "C3byC=3/(n-p[2])#\n", + "C4byC=4/(n-p[3])#\n", + "C5byC=5/(n-p[4])#\n", + "C6byC=6/(n-p[5])#\n", + "C7byC=7/(n-p[6])#\n", + "print '%s %.2f %s' %(\"C1 is \",C1byC,\" times of C\")#\n", + "print '%s %.2f %s' %(\"C2 is \",C2byC,\" times of C\")#\n", + "print '%s %.2f %s' %(\"C3 is \",C3byC,\" times of C\")#\n", + "print '%s %.2f %s' %(\"C4 is \",C4byC,\" times of C\")#\n", + "print '%s %.2f %s' %(\"C5 is \",C5byC,\" times of C\")#\n", + "print '%s %.2f %s' %(\"C6 is \",C6byC,\" times of C\")#\n", + "print '%s %.2f %s' %(\"C7 is \",C7byC,\" times of C\")#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "C1 is 0.14 times of C\n", + "C2 is 0.33 times of C\n", + "C3 is 0.60 times of C\n", + "C4 is 1.00 times of C\n", + "C5 is 1.67 times of C\n", + "C6 is 3.00 times of C\n", + "C7 is 7.00 times of C\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E11 - Pg" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate String efficiency in % is\n", + "import math\n", + "#Given data :\n", + "v2byv1=25./23.25##ratio(By Kirchoff law)\n", + "v3byv1=1.65/1.1625##ratio(By Kirchoff law)\n", + "Vbyv1=1.+v2byv1+v3byv1##ratio(Final voltage between line conductor & earth)\n", + "v1byV=1./Vbyv1##ratio\n", + "v2byV=v2byv1*v1byV##ratio\n", + "v3byV=v3byv1*v1byV##ratio\n", + "eff=1./3./v3byV*100.##string efficiency in %(V/3/v3)\n", + "print '%s %.1f' %(\"String efficiency in % is \",eff)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "String efficiency in % is 82.1\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E12 - Pg" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Voltage onn the line end unit in kV,Capacitance required\n", + "import math\n", + "#Given data :\n", + "V=20.##kV\n", + "\n", + "#Cmutual=C##F\n", + "CmutualBYC=1.#\n", + "#Cshunt=C/5##F\n", + "CshuntBYC=1./5.#\n", + "#I2=I1+i1#omega*C*V2=omega*C*V1+omega*Cshunt*V1\n", + "V2BYV1=1.+CshuntBYC#\n", + "V3BYV2=1.##a V2=V3\n", + "#V=V1+V2+V3\n", + "V1=V/(V3BYV2+V2BYV1+V2BYV1)##kV\n", + "V2=V2BYV1*V1##kV\n", + "V3=V2##kV\n", + "print '%s %.2f' %(\"Voltage onn the line end unit in kV : \",V3)#\n", + "#I3+ix=I2+i2\n", + "CxBYC=(V2+CshuntBYC*(V1+V2)-V3)/V3#\n", + "print '%s %.2f %s' %(\"Capacitance required is \",CxBYC,\"C(in F).\")#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Voltage onn the line end unit in kV : 7.06\n", + "Capacitance required is 0.37 C(in F).\n" + ] + } + ], + "prompt_number": 12 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Elements_of_Power_system/chapter_1.ipynb b/Elements_of_Power_system/chapter_1.ipynb new file mode 100755 index 00000000..a56e6794 --- /dev/null +++ b/Elements_of_Power_system/chapter_1.ipynb @@ -0,0 +1,200 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:477bd6a59c5c41b919502c0727994ee33a0452f8b8b2d97d47ae8f442ad83a0e" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 1 - POWER SYSTEM COMPONENTS" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E1 - Pg 12" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Calculate base impedence \n", + "#Given data :\n", + "BaseVoltage=1100.##in Volts\n", + "BasekVA=10**6##kVA\n", + "BasekV=BaseVoltage/1000.##kV\n", + "IB=BasekVA/BasekV##in Ampere\n", + "ZB=BasekV*1000./IB##in ohm\n", + "print '%s %.5f' %(\"Base Impedence (in ohm) :\",ZB)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Base Impedence (in ohm) : 0.00121\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E2 - Pg 13" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Per unit resistance \n", + "#Given data :\n", + "R=5.##in ohm\n", + "kVA_B=10.##kVA\n", + "kV_B=11.##kV\n", + "RB=kV_B**2*1000/kVA_B##in ohm\n", + "Rpu=R/RB##in ohm\n", + "print '%s %.6f' %(\"Per unit resistance (pu) :\",Rpu)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Per unit resistance (pu) : 0.000413\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E3 - Pg 13" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Leakage reactance Per unit\n", + "#Given data :\n", + "kVA_B=2.5##kVA\n", + "kV_B=0.4##kV\n", + "reactance=0.96##in ohm\n", + "Z_BLV=kV_B**2*1000./kVA_B##in ohm\n", + "Zpu=reactance/Z_BLV##in ohm\n", + "print '%s %.3f' %(\"Leakage reactance Per unit (pu) :\",Zpu)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Leakage reactance Per unit (pu) : 0.015\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E4 - Pg 13" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate Leakage reactance Per unit\n", + "import cmath\n", + "import math\n", + "#Given data :\n", + "Zr=30.\n", + "Zi=110.##in ohm\n", + "kVA_B=100.*1000.##kVA\n", + "kV_B=132.##kV\n", + "Z_BLV=kV_B**2*1000./kVA_B##in ohm\n", + "Zpur=Zr*kVA_B/kV_B**2/1000.##pu\n", + "Zpui=Zi*kVA_B/kV_B**2/1000.##pu\n", + "print '%s' %(\"Leakage reactance Per unit (pu) :\")#\n", + "print '%.3f %s %.3f' %(Zpur,'+j',Zpui)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Leakage reactance Per unit (pu) :\n", + "0.172 +j 0.631\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example E5 - Pg 13" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate New Per unit impedence\n", + "#Given data :\n", + "oldkVA_B=30000##kVA\n", + "oldkV_B=11##kV\n", + "oldZpu=0.2##pu\n", + "newkVA_B=50000.##kVA\n", + "newkV_B=33.##kV\n", + "newZpu=oldZpu*newkVA_B/oldkVA_B*(oldkV_B/newkV_B)**2##pu\n", + "print '%s %.3f' %(\"New Per unit impedence(pu) :\",newZpu)#\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "New Per unit impedence(pu) : 0.037\n" + ] + } + ], + "prompt_number": 6 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Elements_of_Power_system/screenshots/chap5.png b/Elements_of_Power_system/screenshots/chap5.png new file mode 100755 index 00000000..00919e4f Binary files /dev/null and b/Elements_of_Power_system/screenshots/chap5.png differ diff --git a/Elements_of_Power_system/screenshots/chap6.png b/Elements_of_Power_system/screenshots/chap6.png new file mode 100755 index 00000000..a7a59e51 Binary files /dev/null and b/Elements_of_Power_system/screenshots/chap6.png differ diff --git a/Elements_of_Power_system/screenshots/chap7.png b/Elements_of_Power_system/screenshots/chap7.png new file mode 100755 index 00000000..9e8f6e21 Binary files /dev/null and b/Elements_of_Power_system/screenshots/chap7.png differ -- cgit