diff options
Diffstat (limited to 'ELECTRIC_MACHINERY/.ipynb_checkpoints/chapter5-checkpoint.ipynb')
| -rwxr-xr-x | ELECTRIC_MACHINERY/.ipynb_checkpoints/chapter5-checkpoint.ipynb | 609 |
1 files changed, 609 insertions, 0 deletions
diff --git a/ELECTRIC_MACHINERY/.ipynb_checkpoints/chapter5-checkpoint.ipynb b/ELECTRIC_MACHINERY/.ipynb_checkpoints/chapter5-checkpoint.ipynb new file mode 100755 index 00000000..d0c5898a --- /dev/null +++ b/ELECTRIC_MACHINERY/.ipynb_checkpoints/chapter5-checkpoint.ipynb @@ -0,0 +1,609 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 5: Synchronous Machines" + ] + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 5.1, Page number: 254" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from __future__ import division\n", + "import math\n", + "import cmath\n", + "\n", + "#Varaible Declaration:\n", + "pf=0.95 #Lagging power factor\n", + "Vl=460 #Terminal voltage(V)\n", + "I=120 #Terminal current(A)\n", + "If=47 #Field current(A)\n", + "X=1.68j #Line syncchronous reactance(ohm)\n", + "\n", + "\n", + "#Calculation:\n", + "#Choosing motor reference direction:\n", + "Va=Vl/math.sqrt(3)\n", + "theta=math.acos(0.95)\n", + "Ia=I*cmath.exp(-theta*1j)\n", + "Eaf=Va-X*Ia\n", + "wc=120*math.pi\n", + "Laf=math.sqrt(2)*abs(Eaf)/(wc*If)\n", + "P=3*Va*Ia*pf\n", + "\n", + "#Results:\n", + "print \"Generated emf:\",round(abs(Eaf),1),\"V line to line\"\n", + "print \"Fied to armature mutual inductance:\",round(Laf*1000,1),\"mH\"\n", + "print \"Three phase power:\",round(abs(P/1000),1),\"kW or\",round(abs(P)/746),\"hp\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Generated emf: 278.8 V line to line\n", + "Fied to armature mutual inductance: 22.3 mH\n", + "Three phase power: 90.8 kW or 122.0 hp\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 5.2, Page number: 255" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from __future__ import division\n", + "import cmath \n", + "from math import *\n", + "\n", + "#Variable Declaration:\n", + "Pin=90.6*10**3 #Input power(kW)\n", + "Va=265.6 #Terninal voltage(V)\n", + "X=1.68j #Synchronous reactance(ohm)\n", + "Laf=22.3*10**-3 #Mutual inductance(H)\n", + "wc=120*pi #Angular frequency(rad/sec)\n", + "\n", + "\n", + "#Calculations:\n", + "Ia=Pin/(3*Va)\n", + "Eaf=Va-X*Ia\n", + "delta=degrees(cmath.phase(Eaf))\n", + "I=sqrt(2)*Eaf/(wc*Laf)\n", + "\n", + "\n", + "#Results:\n", + "print\"The phase angle,delta:\",round(delta,1),\"degrees\"\n", + "print\"Required field current:\",round(abs(I),2),\"A\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "The phase angle,delta: -35.7 degrees\n", + "Required field current: 55.04 A\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 5.3, Page number: 257" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from __future__ import division\n", + "from math import *\n", + "\n", + "#Variable declaration:\n", + "Eafl=13.8*10**3 #Open circuit voltage(V)\n", + "If1=318 #Field current(A)\n", + "If2=263 #Field current after extrapolation(A)\n", + "wc=120*pi #Angular frequency(Hz)\n", + "\n", + "#Calculations:\n", + "Eaf=Eafl/sqrt(3)\n", + "La1=sqrt(2)*Eaf/(wc*If1)\n", + "La2=sqrt(2)*Eaf/(wc*If2)\n", + "\n", + "#Results:\n", + "print \"Saturated Laf1:\",round(La1*1000,0),\"mH\" \n", + "print \"Unsaturated Laf1:\",round(La2*1000,0),\"mH\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Saturated Laf1: 94.0 mH\n", + "Unsaturated Laf1: 114.0 mH\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 5.4, Page number: 262" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from __future__ import division\n", + "from math import *\n", + "\n", + "#Variable declaration:\n", + "Ia=[118, 152] #Armature current from SC Characteristics(A)\n", + "If=[2.20, 2.84] #Field current from SC Characteristics(A)\n", + "Vll=220 #Line-to-line Voltage(V)\n", + "V=202 #Line-to-line air voltage(V) \n", + "P=45*10**3 #Power roted to motor(W) \n", + "Is_sc=1 #per unit rated current(A)\n", + "\n", + "#Calculations:\n", + "Va_ag=V/sqrt(3) #At field current of 2.20A,at air gap,(V)\n", + "Ia_ag=Ia[0]\n", + "Xs_u=Va_ag/Ia_ag\n", + "Ia_rated=P/(sqrt(3)*Vll)\n", + "Xa_g=Va_ag/1\n", + "Xs_u_pu=Va_ag/Is_sc\n", + "Xs=Vll/(Ia[1]*sqrt(3))\n", + "Ia_pu=Ia[1]/Ia[0]\n", + "SCR=If[1]/If[0]\n", + "Xs=1/SCR\n", + "\n", + "\n", + "\n", + "#Results:\n", + "print \"'All quantities are in per unit values'\"\n", + "print\"Unsaturated value of synchronous reactance:\",round(Xs_u,3),\"ohm\"\n", + "print \"Satureted value of synchronous reactance: \",round(Xs,3),\"ohm\"\n", + "print\"Short circuit ratio:\",round(SCR,3)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "'All quantities are in per unit values'\n", + "Unsaturated value of synchronous reactance: 0.988 ohm\n", + "Satureted value of synchronous reactance: 0.775 ohm\n", + "Short circuit ratio: 1.291\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 5.5, Page number: 265" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from __future__ import division\n", + "\n", + "#Variable declaration:\n", + "P_rated=45*10**3 #Rated power(KV)\n", + "Pl=1.80*10**3 #Short circuit load loss(W)\n", + "Ia_pu=1 #Per unit armature current\n", + "Ia=118 #rated armature current(A)\n", + "Ra_dc=0.0335 #Dc resistance(ohm/phase)\n", + "\n", + "\n", + "#Calculations:\n", + "Pl_pu=Pl/P_rated \n", + "Ra_eff1=Pl_pu/Ia_pu**2 #in per unit basis\n", + "Ra_eff2=Pl/(3*(Ia)**2)\n", + "\n", + "#Results:\n", + "print \"Armature resistance in per unit:\",round(Ra_eff1,3),\"per unit\" \n", + "print \"Armature resistance in ohms/phase:\", round(Ra_eff2,3),\"ohms/phase\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Armature resistance in per unit: 0.04 per unit\n", + "Armature resistance in ohms/phase: 0.043 ohms/phase\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 5.6, Page number: 269" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from __future__ import division\n", + "%pylab inline\n", + "import cmath\n", + "import math\n", + "\n", + "\n", + "#Variable declaration:\n", + "Veq=1.0 #Externalsupply(p.u) \n", + "Eaf=1.0 #Internal voltage(p.u)\n", + "Xeq=0.23 #Eqv.resistance of external system(p.u)\n", + "Xs=1.35 #Saturated synchronous reactance(p.u)\n", + "\n", + "\n", + "#Calculations:\n", + "#for part (a):\n", + "P_max=Eaf*Veq/(Xs+Xeq)\n", + "\n", + "\n", + "#for part (b):\n", + "delta=[0]*500\n", + "Ia=[0]*500\n", + "Va=[0]*500\n", + "degree=[0]*500\n", + "for n in range(1,101,1):\n", + " delta[n-1]=(pi/2)*(n-1)/100\n", + " Ia[n-1] = (Eaf *exp(1j*delta[n-1]) - Veq)/(1j*(Xs + Xeq))\n", + " Va[n-1] = abs(Veq + 1j*Xeq*Ia[n-1])\n", + " degree[n-1]=180*delta[n-1]/pi\n", + "plot(degree,Va,'r.')\n", + "xlabel('Power angle,delta(degrees)')\n", + "ylabel('Terminal voltage(per unit)')\n", + "title('Terminal voltage vs. power angle for part (b)')\n", + "show()\n", + "#for part (c):\n", + "Vterm=1.0\n", + "P=[0]*500\n", + "deltat=[0]*500\n", + "Ia=[0]*500\n", + "Eaf=[0]*500\n", + "\n", + "for n in range(1,101,1):\n", + " P[n-1]=(n-1)/100\n", + " deltat[n-1]=math.asin(P[n-1]*Xeq/(Vterm*Veq))\n", + " Ia[n-1]=(Vterm*exp(1j*deltat[n-1])-Veq)/(1j*Xeq)\n", + " Eaf[n-1]=abs(Vterm+1j*(Xs+Xeq)*Ia[n-1])\n", + "plot(P,Eaf,'r.')\n", + "xlabel('Power [per unit]')\n", + "ylabel('Eaf [per unit]')\n", + "title('Eaf vs. power for part (c)')\n", + "show()\n", + "\n", + "\n", + "\n", + "#Results:\n", + "print \"(a) Maximum power supplied to external system:\",round(P_max,2),\"p.u\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + }, + { + "output_type": "stream", + "stream": "stderr", + "text": [ + "WARNING: pylab import has clobbered these variables: ['prod', 'Circle', 'power', 'diag', 'sinh', 'trunc', 'binomial', 'plot', 'eye', 'det', 'tan', 'product', 'roots', 'vectorize', 'sin', 'plotting', 'zeros', 'cosh', 'conjugate', 'linalg', 'take', 'solve', 'trace', 'beta', 'draw_if_interactive', 'random', 'ones', 'transpose', 'cos', 'interactive', 'diff', 'invert', 'tanh', 'Polygon', 'reshape', 'sqrt', 'floor', 'source', 'add', 'multinomial', 'test', 'poly', 'mod', 'sign', 'fft', 'gamma', 'log', 'var', 'info', 'seterr', 'flatten', 'nan', 'pi', 'exp']\n", + "`%pylab --no-import-all` prevents importing * from pylab and numpy\n" + ] + }, + { + "metadata": {}, + "output_type": "display_data", + "png": "iVBORw0KGgoAAAANSUhEUgAAAYQAAAEZCAYAAACXRVJOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\na/B03gAAAABJRU5ErkJggg==\n", + "text": [ + "<matplotlib.figure.Figure at 0x3794dd0>" + ] + }, + { + "metadata": {}, + "output_type": "display_data", + "png": "iVBORw0KGgoAAAANSUhEUgAAAYYAAAEZCAYAAACTsIJzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text": [ + "<matplotlib.figure.Figure at 0x3965f10>" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Maximum power supplied to external system: 0.63 p.u\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 5.7, Page number: 272" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from __future__ import division\n", + "from math import *\n", + "\n", + "#Variable declaration:\n", + "P_rated=2000*746/3 #per phase rated power of motor(W)\n", + "Xsm=1.95 #Synchronous reactance(ohm)\n", + "Vl=2300 #Line to line voltage(V)\n", + "f=60 #Angular frequency(Hz)\n", + "p=30 #No. of poles\n", + "Xsg=2.65 #Synchronous reactance of generator(ohm)\n", + "\n", + "\n", + "#Calculations:\n", + "#for part (a):\n", + "Vp=2300/sqrt(3)\n", + "Ip=P_rated/Vp\n", + "Eafm=sqrt(Vp**2+(Ip*Xsm)**2)\n", + "Pm=3*Vp*Eafm/Xsm #Max power delivered to motor(W)\n", + "ws=2*2*pi*f/p\n", + "Tmax=Pm/ws #MAx torque of motor(Nm)\n", + "\n", + "\n", + "#for part (b):\n", + "Eafg=sqrt(Vp**2+(Ip*Xsg)**2)\n", + "Pm2=3*Eafm*Eafg/(Xsg+Xsm) #Max power delivered to motor(W)\n", + "Tmax2=Pm2/ws #Max torque(Nm)\n", + "\n", + "\n", + "\n", + "#Results:\n", + "print\"(a) Max power :\",round(Pm/1000,0),\"kW,3-ph\"\n", + "print\" Max torque :\",round(Tmax/1000,1),\"kNm\"\n", + "print \"(b) Max power :\", round(Pm2/1000,0),\"kW,3-ph\"\n", + "print \" Max torque:\", round(Tmax2/1000,1),\"Nm\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Max power : 3096.0 kW,3-ph\n", + " Max torque : 123.2 kNm\n", + "(b) Max power : 1639.0 kW,3-ph\n", + " Max torque: 65.2 Nm\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 5.8, Page number: 279" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from __future__ import division\n", + "from math import *\n", + "\n", + "\n", + "#Variable declaration:\n", + "P=45 #Power rated(KVA)\n", + "Va=220 #Terminal voltage(V)\n", + "Pin=45 #Power input to the armature(KVA)\n", + "If=5.50 #field current(A)\n", + "Rf=35.5 #Field winding resistance(ohm)\n", + "Ra=0.0399 #Armature dc resistance(ohm/phase)\n", + "Xal=0.215 #Leakage reactance of motor(ohm)\n", + "pf=0.80 #Lagging power factor \n", + "Pc=1.8 #Core loss(kW)\n", + "Pw=0.91 #Friction & windage losses(kW)\n", + "Ps=0.37 #Stray load loss(kW)\n", + "\n", + "\n", + "#Calculations:\n", + "Ia=P*10**3/(sqrt(3)*Va)\n", + "P1=If**2*Rf/10**3 #Loss in field winding(kW)\n", + "P2=3*Ia**2*Ra/10**3 #Loss in armature(kW)\n", + "Pl=(Pc+Pw+Ps+P1+P2)\n", + "Pi=Pin*pf+P1\n", + "Po=Pi-Pl\n", + "eff=(Po/Pi)*100\n", + "\n", + "#Results:\n", + "print \"Efficiency of the synchronous machine:\",round(eff,1),\"%\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Efficiency of the synchronous machine: 84.3 %\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 5.9, Page number: 287" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from __future__ import division\n", + "import math\n", + "import cmath\n", + "\n", + "#Variable declaration:\n", + "Xd=1 #Direct axis synchronus reactance(p.u)\n", + "Xq=0.60 #Quadrature axis synchronous reactance(p.u)\n", + "Va=1 #Terminal voltage(p.u)\n", + "pf=0.8 #Lagging power factor\n", + "Ia=0.8-1j*math.sin(math.acos(0.8)) #Line current(p.u)\n", + "\n", + "\n", + "#Calculations:\n", + "phy=-math.acos(pf)\n", + "E=Va+1j*Xq*Ia\n", + "delta=cmath.phase(E)\n", + "Id=abs(Ia)*math.sin(delta-phy)*cmath.exp(1j*(-pi/2+delta))\n", + "Iq=abs(Ia)*math.cos(delta-phy)*cmath.exp(1j*delta)\n", + "Eaf=Va+Xd*Id*1j+Xq*Iq*1j\n", + "\n", + "\n", + "#Results:\n", + "print \"Generated voltage:\",round(abs(Eaf),2),\"p.u Volt\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Generated voltage: 1.78 p.u Volt\n" + ] + } + ], + "prompt_number": 12 + }, + { + "cell_type": "heading", + "level": 3, + "metadata": {}, + "source": [ + "Example 5.11, Page number: 291" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from pylab import *\n", + "import cmath\n", + "from sympy import *\n", + "\n", + "#Variable declaration:\n", + "P_rated=2000*746 #Rated power of motor(W)\n", + "Xs=1.95 #Synchronous reactance(ohm/phase)\n", + "Xd=1.95 #Direct axis synchronous reactance(ohm/ph)\n", + "Xq=1.40 #Quadrature axis synchronous reactance(ohm/ph)\n", + "pf=1 #Power factor of the machine\n", + "Vl=2300 #Line to line voltage(V)\n", + "\n", + "#Calculatons:\n", + "Va=float(Vl/sqrt(3)) #volt\n", + "Ia=float(P_rated/(Va*3)) #ampere\n", + "E1=Va-1j*Ia*Xq #From phasor diagram\n", + "delta=cmath.phase(E1) #power angle\n", + "Id=Ia*sin(abs(delta)) #direct axis current(A)\n", + "Eaf=abs(E1)+Id*(Xd-Xq)\n", + "r=symbols('r')\n", + "def P(r): #Process for finding maximum power\n", + " return Eaf*Va*sin(r)/Xd + Va**2*(Xd-Xq)*sin(2*r)/(2*Xd*Xq)\n", + "P1=diff(P(r),r)\n", + "#On differentiation,\n", + "#P1 = 1023732.58489791*cos(r) + 355250.305250306*(2*(cos(r))**2-1)\n", + "l = solve(1023732.58489791*cos(r) + 355250.305250306*(2*(cos(r))**2-1),r)\n", + "P_max = (P(round(l[0],5)))\n", + "\n", + "\n", + "#Results:\n", + "print \"Maximum mechanical power:\",math.ceil(3*P_max/10**3),\"kW,3-phase\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Maximum mechanical power: 3236.0 kW,3-phase\n" + ] + } + ], + "prompt_number": 1 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file |