From f270f72badd9c61d48f290c3396004802841b9df Mon Sep 17 00:00:00 2001 From: kinitrupti Date: Fri, 12 May 2017 18:53:46 +0530 Subject: Removed duplicates --- .../Chapter1.ipynb | 2766 ++++++++++++++++++++ .../Chapter3.ipynb | 1133 ++++++++ .../screenshots/chap1.png | Bin 0 -> 60414 bytes .../screenshots/chap12.png | Bin 0 -> 56300 bytes .../screenshots/chap3.png | Bin 0 -> 81262 bytes 5 files changed, 3899 insertions(+) create mode 100755 Elements_of_Electric_drives_by_J.B._Gupta/Chapter1.ipynb create mode 100755 Elements_of_Electric_drives_by_J.B._Gupta/Chapter3.ipynb create mode 100755 Elements_of_Electric_drives_by_J.B._Gupta/screenshots/chap1.png create mode 100755 Elements_of_Electric_drives_by_J.B._Gupta/screenshots/chap12.png create mode 100755 Elements_of_Electric_drives_by_J.B._Gupta/screenshots/chap3.png (limited to 'Elements_of_Electric_drives_by_J.B._Gupta') diff --git a/Elements_of_Electric_drives_by_J.B._Gupta/Chapter1.ipynb b/Elements_of_Electric_drives_by_J.B._Gupta/Chapter1.ipynb new file mode 100755 index 00000000..5b5c8817 --- /dev/null +++ b/Elements_of_Electric_drives_by_J.B._Gupta/Chapter1.ipynb @@ -0,0 +1,2766 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:8bd4989c6c6e6f6efd1cf72e88cf69a0617a89e6bfdc01e162aefc837909aa37" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 1 - Electric drives" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1 - pg 6" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Total annual cost in both cases\n", + "#Initialization of variables\n", + "C_g=60000.;#in Rs\n", + "C_id=18750*10;#in Rs\n", + "E_c=75000;#in kWh\n", + "E_a=60000;#in kWh\n", + "#Calculations\n", + "D=0.12*C_g;#in Rs\n", + "C_e=4*E_c;#in Rs\n", + "C_t=D+C_e;#in Rs\n", + "AD=0.15*C_id;#in Rs\n", + "C_ea=4*E_a;#in Rs\n", + "C_total=AD+C_ea;#in Rs\n", + "#Results\n", + "print 'Total annual cost in case of group drive (in Rs)=',C_t\n", + "print 'Total annual cost in case of individual drive (in Rs)=',C_total" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Total annual cost in case of group drive (in Rs)= 307200.0\n", + "Total annual cost in case of individual drive (in Rs)= 268125.0\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2 - pg 17" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the stable operating point\n", + "import math\n", + "#Initialization of variables\n", + "a=1;\n", + "b=1;\n", + "c=-30;\n", + "#Calculations\n", + "w_m=(-b+math.sqrt((b**2)-4*a*c))/(2*a);#speed of the drive\n", + "t_l=0.5*(w_m**2);#motoring torqe \n", + "#Results\n", + "print 'stable operating point=',w_m,t_l" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "stable operating point= 5.0 12.5\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3 - pg 18" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the power developed by the motor\n", + "#Initialization of variables\n", + "import math\n", + "J_m=0.4;#motor inertia(in Kg-m2)\n", + "J_l=10.;#load inertia(in Kg-m2)\n", + "a=0.1;#Teeth ratio of gear\n", + "i=1./a;\n", + "N=1400.;\n", + "pi=22./7.;\n", + "n=0.90;#efficency of motor\n", + "T_l=50.;#Torque(N-m)\n", + "#Calculations\n", + "J=J_m+J_l/(i**2);#Total moment of inertia referred to the motor shaft\n", + "T_L=T_l/(i*n);#total equivalent torque referref to motor shaft\n", + "P=T_L*2*pi*N/60.;#power developed by motor\n", + "#Results\n", + "print 'power developed by motor(in Watt)=',math.ceil(P)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "power developed by motor(in Watt)= 815.0\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4 - pg 19" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the total torque and power developed\n", + "#Initialization of variables\n", + "import math\n", + "J_m=0.4;#motor inertia(in Kg-m2)\n", + "J_l=10;#load inertia(in Kg-m2)\n", + "a=0.1;#Teeth ratio of gear\n", + "N=1500.;\n", + "n_t=0.88;\n", + "m=600.;#weight\n", + "g=9.81;\n", + "#Calculations\n", + "f_r=m*g;#force\n", + "w_m=2*math.pi*N/60.;#motor speed\n", + "w=2.;#uniform speed of weight lifting\n", + "n=0.9;#efficency of motor\n", + "T_l=50;#Torque(N-m)\n", + "J=J_m+(a**2)*J_l+m*((w/w_m)**2);#Total moment of inertia referred to the motor shaft\n", + "T_L=(a*T_l/n)+f_r*w/(n_t*w_m) ;#total equivalent torque referred to motor shaft\n", + "p=T_L*w_m;#power developed by motor(in Watt)\n", + "P=p/1000.;#power developed by motor(in kWatt)\n", + "#Results\n", + "print 'Total torque referred to motor shaft(in kg-m2)=',round(J,2)\n", + "print 'Total equivalent Torque referred to motor shaft(in N-m)=',round(T_L,2)\n", + "print 'power developed by motor(in kWatt)=',round(P,2)\n", + "print 'The answers are a bit different from textbook due to rounding off error'" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Total torque referred to motor shaft(in kg-m2)= 0.6\n", + "Total equivalent Torque referred to motor shaft(in N-m)= 90.72\n", + "power developed by motor(in kWatt)= 14.25\n", + "The answers are a bit different from textbook due to rounding off error\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5 - pg 50" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Motor Speed\n", + "#Initialization of variables\n", + "import math\n", + "from math import ceil\n", + "V=220.;#in volts\n", + "V_1=200.;#in volts\n", + "N=1000.;#in rpm\n", + "I=100.;#in amperes\n", + "R_a=0.1;#in ohms\n", + "#Calculations\n", + "E_b=V-I*R_a;#in volts\n", + "I_1=I;#in amperes\n", + "E_b1=V_1-I_1*R_a;#in volts\n", + "N_1=N*E_b1/E_b;\n", + "#Results\n", + "print 'Motor Speed (in rpm)=',ceil(N_1)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Motor Speed (in rpm)= 905.0\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6 - pg 50" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the full load Speed and Torque\n", + "#Initialization of variables\n", + "import math\n", + "from math import ceil\n", + "V=230;#in volts\n", + "R_sh=230;#in ohms\n", + "R_a=0.5;#in ohms\n", + "I_sh=V/R_sh;#in amperes\n", + "#Calculations\n", + "I_lo=3;#in amperes\n", + "I_ao=I_lo-I_sh;#in amperes\n", + "E_bo=V-I_ao*R_a;#in volts\n", + "N_o=1000;#in rpm\n", + "I_lf=23;#in amperes\n", + "I_af=I_lf-I_sh;#in amperes\n", + "E_bf=V-I_af*R_a;#in volts\n", + "Phy_ratio=0.98;\n", + "N_f=N_o*(E_bf/E_bo)/Phy_ratio;\n", + "T_f=9.55*E_bf*I_af/N_f;\n", + "#Results\n", + "print 'Full Load Speed (in rpm)=',ceil(N_f)\n", + "print 'Full load Torque (in Newton-meter)=',round(T_f,2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Full Load Speed (in rpm)= 976.0\n", + "Full load Torque (in Newton-meter)= 47.15\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7 - pg 51" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Armature voltage drop at full load\n", + "#Initialization of variables\n", + "V=440.;#in volts\n", + "N_o=2000.;#in rpm\n", + "E_bo=440.;#in volts\n", + "N_f=1000.;#in rpm\n", + "N_h=1050.;#in rpm\n", + "#Calculations\n", + "E_bf=E_bo*N_f/N_o#in volts\n", + "E_b=E_bo*N_h/N_o;#in volts\n", + "v=(E_b-E_bf)*2;\n", + "#Results\n", + "print 'Armature voltage drop at full load (in volts)=',v" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Armature voltage drop at full load (in volts)= 22.0\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 8 - pg 51" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Speed\n", + "#Initialization of variables\n", + "V=230.;#in volts\n", + "N1=750.;#in rpm\n", + "R=10.;#in ohms\n", + "I_a=30.;#in amperes\n", + "#Calculations\n", + "N2=N1*((V+I_a*R)/V)**-1;\n", + "#Results\n", + "print'Speed (in rpm)=',int(N2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Speed (in rpm)= 325\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9 - pg 52" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Speed in both cases\n", + "import math\n", + "from math import ceil\n", + "#Initialization of variables\n", + "V=200.;#in volts\n", + "I_1=20.#in amperes\n", + "R_a=0.5;#in ohms\n", + "#Calculations\n", + "E_b1=V-I_1*R_a;#in volts\n", + "N1=700;#in rpm\n", + "I_2=math.sqrt(1.44)*I_1;#in amperes\n", + "E_b2=V-I_2*R_a;#in volts\n", + "N2=N1*(E_b2/E_b1)*(I_1/I_2);\n", + "I_3=10;#in amperes\n", + "E_b3=V-I_3*R_a;#in volts\n", + "N3=N1*(E_b3/E_b1)*(I_1/I_3);\n", + "#Results\n", + "print '(a) Speed (in rpm)=',round(N2,1)\n", + "print '(b) Speed (in rpm)=',ceil(N3)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Speed (in rpm)= 577.2\n", + "(b) Speed (in rpm)= 1437.0\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 10 - pg 52" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Torque and Speed\n", + "#Initialization of variables\n", + "import math\n", + "from math import ceil\n", + "V=230.;#in volts\n", + "I_1=90.;#in amperes\n", + "R_a=0.08;#in ohms\n", + "R_se=0.05;#in ohms\n", + "E_2=180.;#in volts\n", + "N2=700.;#in rpm\n", + "R=1.5;#in ohms\n", + "#Calculations\n", + "R_m=R_a+R_se;#in ohms\n", + "E_b1=V-I_1*(R_m+R);#in volts\n", + "N1=N2*(E_b1/E_2);\n", + "T=9.55*E_b1*I_1/N1;\n", + "#Results\n", + "print 'Speed (in rpm)=',ceil(N1)\n", + "print 'Torque (in Newton-meter)=',round(T,0)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Speed (in rpm)= 324.0\n", + "Torque (in Newton-meter)= 221.0\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 12 - pg 54" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the torque developed and Terminal Voltage\n", + "#Initialization of variables\n", + "import math\n", + "P=4.;#no. of poles\n", + "f=50.;#in hertz\n", + "N_s=120.*f/P;#in rpm\n", + "V=400/math.sqrt(3.);#in volts\n", + "R2=4;#in ohms\n", + "R1=1.5;#in ohms\n", + "X1=4.;#in ohms\n", + "X2=4.;#in ohms\n", + "N=1350.;#in rpm\n", + "#Calculations\n", + "s=(N_s-N)/N_s;#slip\n", + "T=(3*V**2*4./s)/((((R1+(R2/s))**2)+((X1+X2)**2))*(2*math.pi*N_s/60.));#in newton-meter\n", + "N1=900.;#in rpm\n", + "s1=(N_s-N1)/N_s;#slip\n", + "T1=T*(N1/N)**2;\n", + "V1=V*math.sqrt((N1/N)**2*(s1/s)*((((R1+(R2/s1))**2)+((X1+X2)**2)))/(((R1+(R2/s))**2)+((X1+X2)**2)));\n", + "#Results\n", + "print 'Torque developed (in Newton-meter)=',round(T1,2)\n", + "print 'Terminal Voltage (in volts)=',round(V1,2)\n", + "print 'Answer given in the textbook is worng as the torque equation is not multiplied by R2'" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Torque developed (in Newton-meter)= 10.14\n", + "Terminal Voltage (in volts)= 102.06\n", + "Answer given in the textbook is worng as the torque equation is not multiplied by R2\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 13 - pg 55" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the RMS Voltage\n", + "#Initialization of variables\n", + "import math\n", + "P=4.;#no. of poles\n", + "f=50.;#in hertz\n", + "N_s=120.*f/P;#in rpm\n", + "s_f=0.05;#slip\n", + "V=415;#in volts\n", + "s_m=0.1;#slip corresponding to maximum slip\n", + "N1=1350.;#in rpm\n", + "#Calculations\n", + "N=N_s*(1-s_f);#in rpm\n", + "s_fn=(N_s-N1)/N_s;#full load slip\n", + "V1=V*math.sqrt((N1/N)*(s_f/s_m)*(8./5.));\n", + "#Results\n", + "print ' RMS Voltage (in volts)=',round(V1,1)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + " RMS Voltage (in volts)= 361.3\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 14 - pg 56" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the slip Frequency\n", + "#Initialization of variables\n", + "import math\n", + "f1=2;#in hertz\n", + "f=50;#in hertz\n", + "s_m=0.1;\n", + "V=400;#in volts\n", + "s1=0.04;#slip\n", + "#Calculations\n", + "s2=(0.2095-math.sqrt((0.2095)**2-s1))/2.;\n", + "f_n=s2*40;\n", + "#Results\n", + "print 'Slip Frequency (in Hertz)=',round(f_n,2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Slip Frequency (in Hertz)= 2.94\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 15 - pg 57" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the maximum torque\n", + "#Initialization of variables\n", + "import math\n", + "R1=0.02;#in ohms\n", + "X1=0.1;#in ohms\n", + "X2=X1;#in ohms\n", + "#T_ratio is defined as the ratio of maximum torque at one-half load and 25Hz frequency to maximum torque at rated voltage and frequency\n", + "#Calculations\n", + "T_ratio=(R1+math.sqrt(R1**2+(X1+X2)**2))/(2*(R1+math.sqrt(R1**2+((X1+X2)**2)/4)));\n", + "#Results\n", + "print ' maximum torque at one-half load and 25Hz frequency =',round(T_ratio,4)\n", + "print' times the maximum torque at rated voltage and frequency (T_max)'" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + " maximum torque at one-half load and 25Hz frequency = 0.9059\n", + " times the maximum torque at rated voltage and frequency (T_max)\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 16 - pg 77" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the starting torque, slip and ratio\n", + "#Initialization of variables\n", + "import math\n", + "s_f=0.04;#full load slip\n", + "I_ratio=6.;#Ratio of Starting current to full load current\n", + "#Calculations\n", + "T_ratio=I_ratio**2*s_f;#Ratio of Starting torque to full load torque\n", + "s_max=math.sqrt((I_ratio**2-1)/(625.-I_ratio**2.));\n", + "T_rm=(1./2.)*((s_f/s_max)+(s_max/s_f));\n", + "#Results\n", + "print '(a) Starting Torque =',T_ratio\n", + "print ' times the full load torque (T_f)'\n", + "print'(b) Slip at which Maximum torque occurs=',round(s_max,3)\n", + "print'(c) Ratio of maximum torque to full load torque=',round(T_rm,3)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Starting Torque = 1.44\n", + " times the full load torque (T_f)\n", + "(b) Slip at which Maximum torque occurs= 0.244\n", + "(c) Ratio of maximum torque to full load torque= 3.129\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 17 - pg 78" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the starting torque in all cases\n", + "#Initialization of variables\n", + "import math\n", + "I_ratio=8.;#Ratio of short circuit current to full load current\n", + "s_f=0.04;#full load slip\n", + "#Calculations\n", + "T_r1=I_ratio**2*s_f;\n", + "T_r2=I_ratio**2*s_f/3.;\n", + "K=math.sqrt(3./8.);# transformation ratio of transformer\n", + "T_st=K**2*I_ratio**2*s_f;\n", + "#Results\n", + "print '(a) Starting Torque when started by means of direct switching=',T_r1\n", + "print(' times the full load torque');\n", + "print '(b) Starting Torque when started by star-delta starter=',round(T_r2,3)\n", + "print(' times the full load torque');\n", + "print '(C) Starting Torque =',T_st\n", + "print(' times the full load torque');" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Starting Torque when started by means of direct switching= 2.56\n", + " times the full load torque\n", + "(b) Starting Torque when started by star-delta starter= 0.853\n", + " times the full load torque\n", + "(C) Starting Torque = 0.96\n", + " times the full load torque\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 18 - pg 78" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Ratio of starting current to full load current\n", + "#Initialization of variables\n", + "import math\n", + "P=10.*7355;#in watts\n", + "V=400.;#in volts\n", + "pf=0.8#power factor\n", + "Eff=0.9;#efficiency in per unit\n", + "#Calculations\n", + "I_f=P/(math.sqrt(3.)*V*pf*Eff);#in amperes\n", + "I_sc=7.2;#in amperes\n", + "I_sc1=I_sc*400./160;#in amperes\n", + "I_st=I_sc1/3.;#Starting current (in amperes)\n", + "I_r=I_st/I_f;\n", + "#Results\n", + "print'Ratio of starting current to full load current=',round(I_r,4)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Ratio of starting current to full load current= 0.0407\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 19 - pg 78" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the tap Position of auto transformer and Ratio of Starting torque to full load torque\n", + "#Initialization of variables\n", + "import math\n", + "P_o=50.*1000;#in VA\n", + "s_f=0.05;#slip\n", + "V=400.;#in volts\n", + "#Calculations\n", + "I_f=P_o/(math.sqrt(3.)*V);#in amperes\n", + "Z=0.866;#in ohms/phase\n", + "I_sc=V/(math.sqrt(3)*Z);#Short Circuit current (in amperes)\n", + "I_st=100;#Supply current at start (in amperes)\n", + "K=math.sqrt(I_st/I_sc);\n", + "I_ratio=I_sc/I_f;\n", + "T_r=K**2*I_ratio**2*s_f;\n", + "#Results\n", + "print 'Tap Position of auto transformer(in %)=',round(K*100,2)\n", + "print 'Ratio of Starting torque to full load torque =',round(T_r,3)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Tap Position of auto transformer(in %)= 61.24\n", + "Ratio of Starting torque to full load torque = 0.256\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 20 - pg 79" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Starting current and Torque of the motor\n", + "#Initialization of variables\n", + "import math\n", + "from math import sqrt\n", + "V=440./sqrt(3);#in volts\n", + "R_s=2.;#in ohms\n", + "R_r=2.;#in ohms\n", + "f=50.;#in hertz\n", + "X_s=3.;#in ohms\n", + "P=4.;#no. of poles\n", + "X_r=3.;#in ohms\n", + "#Calculations\n", + "R_o1=R_s+R_r;#Equivalent resistance of motor as referred to stator (in ohms)\n", + "X_o1=X_s+X_r;##Equivalent reactance of motor as referred to stator (in ohms)\n", + "I_st=V/(sqrt(R_o1**2+X_o1**2));#Starting current (in amperes)\n", + "P_cu=3*I_st**2*R_r;#Copper loss (in watts)\n", + "P2=7446;#in watts\n", + "N_s=120*f/P;#Synchronous Speed (in rpm)\n", + "T_st=9.55*P2/N_s;#Starting Torque (in Newton-meter)\n", + "V1=V*10/50;#in volts\n", + "X_o2=X_o1*10/50;#in ohms\n", + "I_st1=V1/(sqrt(R_o1**2+X_o2**2));#Starting current (in amperes)\n", + "P_2=3*I_st1**2*R_r;#Copper loss (in watts)\n", + "N_s1=120*10./P;#Synchronous Speed (in rpm)\n", + "T_st2=9.55*P_2/N_s1;#Starting Torque (in Newton-meter)\n", + "#Results\n", + "print'Starting Current of motor at 50 Hertz (in amperes)=',round(I_st,2)\n", + "print 'Starting Torque of motor at 50 hertz (in Newton-meters)=',round(T_st,2)\n", + "print 'Starting Current of motor at 10 Hertz (in amperes)=',round(I_st1,3)\n", + "print 'Starting Torque of motor at 10 hertz (in Newton-meters)=',round(T_st2,3)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Starting Current of motor at 50 Hertz (in amperes)= 35.23\n", + "Starting Torque of motor at 50 hertz (in Newton-meters)= 47.41\n", + "Starting Current of motor at 10 Hertz (in amperes)= 12.166\n", + "Starting Torque of motor at 10 hertz (in Newton-meters)= 28.27\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 21 - pg 80" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Moment of inertia of drive\n", + "import math\n", + "#Initialization of variables\n", + "T_m=100;#Motor Torque (in Newton-meter)\n", + "T_l=30;#Load Torque (in Newton-meter)\n", + "#Calculations\n", + "alpha=2*math.pi*10;#in angular acceleration (in rad/sec**2)\n", + "J=(T_m-T_l)/alpha;\n", + "#Results\n", + "print'Moment of inertia of drive (in Kg-m^2)',round(J,3)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Moment of inertia of drive (in Kg-m^2) 1.114\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 22 - pg 80" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the time required\n", + "#Initialization of variables\n", + "import math\n", + "P_o=37.5*1000;#in watts\n", + "N=500.;#in rpm\n", + "#Calculations\n", + "T_l=P_o*60/(2*math.pi*N);#Full load torque (in Newton-meter)\n", + "T_st=(1.1+1.4)*T_l/2;# Average Starting Torque (in Newton-meters)\n", + "T_a=T_st-T_l;#total available torque for acceleration\n", + "J=20;#Moment of Inertia (in Kg-m**2)\n", + "t1=J*2*math.pi*N/(60*T_a);\n", + "#Results\n", + "print 'Time in attaining full load speed (in seconds)=',round(t1,2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Time in attaining full load speed (in seconds)= 5.85\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 23 - pg 80" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the starting Period\n", + "#Initialization of variables\n", + "import math\n", + "P_o=37.5*1000.;#in watts\n", + "N=500.;#in rpm\n", + "#Calculations\n", + "T_l=P_o*60/(2*math.pi*N);#Full load torque (in Newton-meter)\n", + "T_m=2*T_l;# Torque developed by motor during starting\n", + "T_a=T_m-T_l;#total available torque for acceleration\n", + "E=37.5*660*9.81;#Stored energy of machine\n", + "J=E*2/(2*math.pi*N/60)**2;#Moment of inertia (in Kg-m**2)\n", + "alpha=T_a/J;#angular acceleration (in rad/sec**2)\n", + "t=(2*math.pi*N/60)/alpha;\n", + "#Results\n", + "print 'Starting Period (in seconds)=',round(t,2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Starting Period (in seconds)= 12.95\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 24 - pg 81" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Energy Dissipated\n", + "#Initialization of variables\n", + "V=220.;#in volts\n", + "I=20.;#in ampers\n", + "R=1;#in ohms\n", + "#Calculations\n", + "P_o=V*I-I**2*R;#Motor Output (in watts)\n", + "w=200;#in radians/second\n", + "T_l=P_o/w;#Load Torque (in N-m)\n", + "J=5;#kg-m**2\n", + "t_st=2.5;#in seconds\n", + "alpha=w/t_st;#angular acceleration (in rad/second**2)\n", + "K=(J*alpha+T_l)/I**2;\n", + "W_st=(J*R*w/K)+(T_l*R*t_st/K);\n", + "#Results\n", + "print 'Energy Dissipated (in watts)=',W_st" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Energy Dissipated (in watts)= 1000.0\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 25 - pg 97" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Value of additional resistance\n", + "#Initialization of variables\n", + "I_l1=22.;#in amperes\n", + "V=220.;#in volts\n", + "R_sh=100.;#in ohms\n", + "R_a=0.1;#in ohms\n", + "#Calculations\n", + "I_sh=V/R_sh;#in amperes\n", + "I_a1=I_l1-I_sh;#armatur current (in amperes)\n", + "E_b1=V-I_a1*R_a;#Back Emf (in volts)\n", + "N1=1000;#in rpm\n", + "I_a2=0.8*19.8;#in amperes\n", + "R=(218.416-(800*218.02/1000))/I_a2;\n", + "I_a3=0.64*I_a1;#in amperes\n", + "R3=(218.7328-(800*218.02/1000))/I_a3;\n", + "#Results\n", + "print 'Value of additional resistance (in ohms)=',round(R,3)\n", + "print 'Value of additional resistance (in ohms)=',round(R3,3)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Value of additional resistance (in ohms)= 2.778\n", + "Value of additional resistance (in ohms)= 3.497\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 26 - pg 97" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Value of additional resistance\n", + "#Initialization of variables\n", + "import math\n", + "I_1=50;#in amperes\n", + "V=500;#in volts\n", + "N_ratio=0.5;#Speed Ratio\n", + "#Calculations\n", + "E_b1=V;#Back Emf (in volts)\n", + "T_ratio=N_ratio**3;#Torque ratio\n", + "I_2=I_1*math.sqrt(T_ratio);#in amperes\n", + "R=(E_b1-(I_2*N_ratio*E_b1/I_1))/I_2;\n", + "#Results\n", + "print 'Value of additional resistance (in ohms)=',round(R,3)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Value of additional resistance (in ohms)= 23.284\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 27 - pg 98" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the value of Diverter resistance and Series field resistance\n", + "#Initialization of variables\n", + "#Calculations\n", + "#Results\n", + "N_ratio=1.2;#Speed Ratio\n", + "#From Saturation Curve\n", + "I_ratio=0.65;#feild current ratio corresponding to 83.3% of full load value of flux to 65% of full load value of flux\n", + "I_a_ratio=N_ratio;#Armature current ratio corresponding to 83.3% of full load value of flux to 65% of full load value of flux\n", + "R_ratio=I_ratio/(I_a_ratio-I_ratio);\n", + "print 'Value of Diverter resistance (in ohms)=',round(R_ratio,3)\n", + "print ' times the Series Field Resistance (R_se)'" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Value of Diverter resistance (in ohms)= 1.182\n", + " times the Series Field Resistance (R_se)\n" + ] + } + ], + "prompt_number": 12 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 28 - pg 99" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Armature current\n", + "#Initialization of variables\n", + "I_ab=800;#Armature current (in amperes)\n", + "N1=1000;#in rpm\n", + "N2=500.;#in rpm\n", + "#Calculations\n", + "I=I_ab*N1/N2;\n", + "#Results\n", + "print ' Armature Current at 1000 rpm (in amperes)=',I" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + " Armature Current at 1000 rpm (in amperes)= 1600.0\n" + ] + } + ], + "prompt_number": 13 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 29 - pg 99" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Value of additional resistance\n", + "#Initialization of variables\n", + "f=50;#in hertz\n", + "P=4.;#No.of poles\n", + "N_s=120*f/P;#Synchronous Speed (in rpm)\n", + "N=1440;#Full load speed (in rpm)\n", + "#Calculations\n", + "s1=(N_s-N)/N_s;#Full load Slip\n", + "N2=1200;#in rpm\n", + "s2=(N_s-N2)/N_s;#slip\n", + "R2=0.25;#ohms per phase\n", + "R=(s2*R2/s1)-R2;\n", + "#Results\n", + "print 'Value of additional resistance (in ohms)=',R" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Value of additional resistance (in ohms)= 1.0\n" + ] + } + ], + "prompt_number": 14 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 30 - pg 100" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Frequency of rotor current of 6-pole and 4 pole motor and slip referred\n", + "#Initialization of variables\n", + "f=50.;#in hertz\n", + "P1=6.;#No. of poles\n", + "P2=4.;#No.of poles\n", + "#Calculations\n", + "N_sc=120*f/(P1+P2);#Synchronous Speed (in rpm)\n", + "s=0.02;#slip\n", + "N=N_sc*(1-s);#Actual Speed (in rpm)\n", + "N_s=120*f/P1;#Synchronous Speed of 6-pole motor\n", + "s1=(N_s-N)/N_s;\n", + "f1=s1*f;\n", + "N_s2=120*f1/P2;#Synchronous Speed of 4-pole motor\n", + "s2=(N_s2-N)/N_s2;\n", + "f2=s2*f1;\n", + "#Results\n", + "print 'Frequency of rotor current of 6-pole motor (in Hertz)=',f1\n", + "print 'Slip referred to 6-pole stator field=',s1\n", + "print 'Frequency of rotor current of 4-pole motor (in Hertz)=',f2\n", + "print 'Slip referred to 4-pole stator field=',round(s2,4)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Frequency of rotor current of 6-pole motor (in Hertz)= 20.6\n", + "Slip referred to 6-pole stator field= 0.412\n", + "Frequency of rotor current of 4-pole motor (in Hertz)= 1.0\n", + "Slip referred to 4-pole stator field= 0.0485\n" + ] + } + ], + "prompt_number": 15 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 31 - pg 100" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Available speeds and Maximum load which can be delievered\n", + "#Initialization of variables\n", + "f=50.;#in hertz\n", + "P1=6.;#No. of poles\n", + "P2=4.;#No.of poles\n", + "P_o=15.;#in HP\n", + "#Calculations\n", + "N_s1=120*f/P1;#Synchronous Speed of 6-pole motor\n", + "N_s2=120*f/P2;#Synchronous Speed of 4-pole motor\n", + "N_sc1=120*f/(P1+P2);#Concantenated Speed of set when cumulatively compounded (in rpm)\n", + "N_sc2=120*f/(P1-P2);#Concantenated Speed of set when differentially compounded (in rpm)\n", + "r=P1/P2;\n", + "#Results\n", + "print(' Available Speeds (in rpm) are :');\n", + "print N_s1,N_s2,N_sc1,N_sc2\n", + "print 'Maximum Load which can be delievered (in HP)=',P_o\n", + "print 'Ratio of Mechanical Power Output',r" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + " Available Speeds (in rpm) are :\n", + "1000.0 1500.0 600.0 3000.0\n", + "Maximum Load which can be delievered (in HP)= 15.0\n", + "Ratio of Mechanical Power Output 1.5\n" + ] + } + ], + "prompt_number": 16 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 32 - pg 101" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the resistance to be added\n", + "#Initialization of variables\n", + "import math\n", + "from math import sqrt\n", + "f=50.;#in hertz\n", + "V=440.;#in volts\n", + "P_o=110.*1000;#in watts\n", + "P=24.;#No.Of Poles\n", + "#Calculations\n", + "N_s=120*f/P;#Synchronous Speed (in rpm)\n", + "N=245;#in rpm\n", + "s_f=(N_s-N)/N_s;#Full load Speed\n", + "T_f=P_o/(2*math.pi*N/60);#Full load Torque (in N-m)\n", + "R=0.04;#in ohms\n", + "R2=R/2;#Rotor resistance per phase (in ohms)\n", + "K=1.25;# ratio of stator turns to rotor turns\n", + "R_2=R2*K**2;#Rotor resistance reffered to stator (in ohms)\n", + "X_2=sqrt(((V**2*R_2*1.2/(T_f*500*math.pi))-R_2**2)*(1/R2)**2);#in ohms\n", + "s=(N_s-175)/N_s;#slip at 175 rpm\n", + "T=T_f*175**2/N**2;#Torque at 175 rpm (in N-m)\n", + "b=-(V**2*s*60/(T*2*math.pi*N_s));\n", + "a=1;\n", + "c=(s*X_2)**2;\n", + "R_n=(-b+sqrt(b**2-4*a*c))/(2*a)\n", + "R_ext=(R_n-R_2)/K**2;\n", + "#Results\n", + "print'Resistance to be added to each slip ring (in ohms)=',round(R_ext,4)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Resistance to be added to each slip ring (in ohms)= 0.6143\n" + ] + } + ], + "prompt_number": 20 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 33 - pg 111" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the value of external resistance and Initial braking torque \n", + "#Initialization of variables\n", + "import math\n", + "I_f=100.;#in amperes\n", + "V=220.;#in volts\n", + "N=1000.;#in rpm\n", + "#Calculations\n", + "T_f=V*I_f/(2*math.pi*N/60);#Full load torque (N-m)\n", + "E_bf=V;#Back emf (in volts)\n", + "V_a=V+E_bf;# Voltage across armature (in volts)\n", + "I_b=2*I_f;#braking current\n", + "R=(V_a/I_b);#in ohms\n", + "T_b=T_f*I_b/I_f;\n", + "E_b1=E_bf*500/N;#in volts\n", + "I_b1=(V+E_b1)/R;#in amperes\n", + "T_b1=T_f*I_b1/I_f;\n", + "#Results\n", + "print 'Value of external resistance (in ohms)=',R\n", + "print 'Initial Braking Torque (in N-m)=',round(T_b,0)\n", + "print 'Braking Torque when speed reduced to 500 rpm (in N-m)=',round(T_b1,0)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Value of external resistance (in ohms)= 2.2\n", + "Initial Braking Torque (in N-m)= 420.0\n", + "Braking Torque when speed reduced to 500 rpm (in N-m)= 315.0\n" + ] + } + ], + "prompt_number": 21 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 34 - pg 111" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Value of external resistance and braking torque\n", + "#Initialization of variables\n", + "import math\n", + "P_o=17.6*1000;#in watts\n", + "Eff=0.8;#Efficiency\n", + "V=220.;#in volts\n", + "#Calculations\n", + "I_f=P_o/(V*Eff);#in amperes\n", + "I_af=I_f;#in amperes\n", + "R_a=0.1;#in ohms\n", + "N=1200;#in rpm\n", + "T_f=P_o/(2*math.pi*N/60);#Full load torque (N-m)\n", + "E_bf=V-I_af*R_a;#Back emf (in volts)\n", + "V_a=V+E_bf;# Voltage across armature (in volts)\n", + "I_b=2*I_f;#braking current\n", + "R=(V_a/I_b)-R_a;#in ohms\n", + "E_b1=E_bf*400/N;#in volts\n", + "I_b1=(V+E_b1)/(R+R_a);#in amperes\n", + "T_b1=T_f*I_b1/I_f;\n", + "#Results\n", + "print'Value of external resistance (in ohms)=',round(R,2)\n", + "print'Braking Torque when speed reduced to 400 rpm (in N-m)=',round(T_b1,2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Value of external resistance (in ohms)= 2.05\n", + "Braking Torque when speed reduced to 400 rpm (in N-m)= 188.91\n" + ] + } + ], + "prompt_number": 22 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 35 - pg 112" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Current Drawn and Value of additional resistance\n", + "#Initialization of variables\n", + "V=220;#in volts\n", + "P_o=400*9.81*2.5;#(in watts)\n", + "Eff=0.85;#efficiency of motor\n", + "Eff_h=0.8\n", + "#Calculations\n", + "P_in=P_o/(Eff*Eff_h);#in watts\n", + "I=P_in/V;#in amperes\n", + "P_out=P_o*Eff*Eff_h;#in watts\n", + "R=V**2/P_out;\n", + "#Results\n", + "print 'Current Drawn (in amperes)=',round(I,1)\n", + "print 'Value of additional resistance (in ohms)=',round(R,3)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Current Drawn (in amperes)= 65.6\n", + "Value of additional resistance (in ohms)= 7.256\n" + ] + } + ], + "prompt_number": 23 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 36 - pg 113" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Externalm resistance to be inserted\n", + "#Initialization of variables\n", + "import math\n", + "T=245.;#in N-m\n", + "N=250.;#in rpm\n", + "#Calculations\n", + "P_in=T*2*math.pi*N/60;#in watts\n", + "#Corresponding to the value of P_in we found I=27.5A and E=233 V from the given curve shown in fig.1.102\n", + "E=233;#in volts\n", + "I=27.5;#in amperes\n", + "r=E/I;#resistance of the circuit\n", + "R=r-1;#External Resistance to be inserted (in ohms)\n", + "#Results\n", + "print'External Resistance to be inserted (in ohms)=',round(R,2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "External Resistance to be inserted (in ohms)= 7.47\n" + ] + } + ], + "prompt_number": 24 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 37 - pg 113" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Speed under regenerative braking and plugging\n", + "#Initialization of variables\n", + "P_o=45*1000;#in watts\n", + "R_a=0.2;#in ohms\n", + "V=500;#in volts\n", + "Eff=0.9;#Efficiency\n", + "R_sh=200;#in ohms\n", + "#Calculations\n", + "I_lf=P_o/(V*Eff);#Rated Line current (in amperes)\n", + "I_sh=V/R_sh;#Shunt feild Current (in amperes)\n", + "I_af=I_lf-I_sh;#Armature current on full load (in Amperes)\n", + "E_f=V-I_af*R_a;#emf induced (in volts)\n", + "N_f=600;#in rpm\n", + "E1=V+I_af*R_a;#in volts\n", + "N1=E1*N_f/E_f;\n", + "E2=I_af*(5.5+R_a)-V;#in volts\n", + "N2=E2*N_f/E_f;\n", + "E3=I_af*(2.6+R_a);#in volts\n", + "N3=E3*N_f/E_f;\n", + "#Results\n", + "print'Speed under regenerative braking(in rpm)=',round(N1,1)\n", + "print 'Speed under plugging (in rpm)=',round(N2,1)\n", + "print 'Speed under dynamic braking(in rpm)=',round(N3,1)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Speed under regenerative braking(in rpm)= 649.0\n", + "Speed under plugging (in rpm)= 73.2\n", + "Speed under dynamic braking(in rpm)= 342.7\n" + ] + } + ], + "prompt_number": 25 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 38 - pg 114" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Speed\n", + "#Initialization of variables\n", + "import math\n", + "V=230.;#in volts\n", + "I_a=100.;#in amperes\n", + "R_a=0.05;#in ohms\n", + "N=870.;#in rpm\n", + "#Calculations\n", + "E_b=V-I_a*R_a;#in volts\n", + "T=E_b*I_a/(2*math.pi*N/60);#torque developed (in N-m)\n", + "T_l=400;#in N-m\n", + "I_an=I_a*T_l/T;#in amperes\n", + "E=V+I_an*R_a;#in volts\n", + "N1=N*E/230;\n", + "#Results\n", + "print'Speed (in rpm)=',round(N1,0)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Speed (in rpm)= 901.0\n" + ] + } + ], + "prompt_number": 26 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 39 - pg 114" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the flux and speed\n", + "#Initialization of variables\n", + "import math\n", + "I_a1=100;#in Amperes\n", + "V=230;#in volts\n", + "R_a=0.1;#in ohms\n", + "E_b1=V-I_a1*R_a;#in volts\n", + "N1=500;#in rpm\n", + "N2=800;#in rpm\n", + "#Calculations\n", + "x=(V-math.sqrt((V**2)-4*10*352))/(2*10);\n", + "I_a2=I_a1*x;#in amperes\n", + "E_b2=V-I_a2*R_a;#in volts\n", + "T_2=E_b2*I_a2*60/(2*math.pi*N2);#in N-m\n", + "T_3=800;#in N-m\n", + "I_a3=I_a2*T_3/T_2;#in Amperes\n", + "E_b3=V+I_a3*R_a;#in amperes\n", + "N3=E_b3*N2/E_b2;\n", + "#Results\n", + "print'Flux is reduced by',round(x**-1,4)\n", + "print('times to get motor speed of 800 rpm');\n", + "print 'Speed (in rpm)=',math.ceil(N3)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 40 - pg 123" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the plugging Torque\n", + "#Initialization of variables\n", + "import math\n", + "f=50.;#in hertz\n", + "P=4.;#Number of poles\n", + "s_f=0.05;#Full load Slip\n", + "#Calculations\n", + "N_s=120*f/P;#Synchronous Speed (in rpm)\n", + "N_f=N_s*(1-s_f);#Full load speed (in rpm)\n", + "P_d=30*1000;#in watts\n", + "T_f=P_d/(2*math.pi*N_f/60.);#In N-m\n", + "s_2=2-s_f;#Slip at plugging\n", + "T_p=(s_2/s_f)*T_f*(1+16*s_f**2)/(1+16*s_2**2);\n", + "#Results\n", + "print'Plugging Torque (in N-m)=',round(T_p,2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Plugging Torque (in N-m)= 131.86\n" + ] + } + ], + "prompt_number": 27 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 41 - pg 123" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Initial braking Torque and during dc dynamic\n", + "#Initialization of variables\n", + "import math\n", + "from math import sqrt\n", + "R2=0.5;#in ohms\n", + "X2=2.4;#in ohms\n", + "a=0.5;#ratio\n", + "s_f=0.05;#slip\n", + "f=50.;#in hertz\n", + "P=8.;#Number of Poles\n", + "#Calculations\n", + "R_2=R2*a**2;#in ohms\n", + "X_2=X2*a**2;#in ohms\n", + "s=2-s_f;#Slip during Plugging\n", + "N_s=120*f/P;#in rpm\n", + "V=400/sqrt(3);#in volts\n", + "R_L=2;#in ohms\n", + "R_1=0.1;#in ohms\n", + "X_1=0.6;#in ohms\n", + "I_2=V/sqrt(((R_1+(R_2+R_L)/s)**2)+(X_1+X_2)**2);#in amperes\n", + "T_b=3*60*I_2**2*(R_2+R_L)/(2*math.pi*N_s*s);\n", + "E_2=V*sqrt(((R_2/s_f)**2+(X_2**2))/(((R_2/s_f)+R_1)**2)+1.2**2)/sqrt(3.);\n", + "S=1-s_f;#Slip during breaking\n", + "I_2b=E_2/sqrt((X_2**2)+((R_L+R_2)/S)**2);\n", + "T_bn=3*60.*I_2b**2*(R_2+R_L)/(2*math.pi*N_s*S);\n", + "#Results\n", + "print 'Initial Braking Torque (in N-m)=',int(T_b)\n", + "print'Initial Braking Torque during dc dynamic braking(in N-m)=',round(T_bn,1)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Initial Braking Torque (in N-m)= 777\n", + "Initial Braking Torque during dc dynamic braking(in N-m)= 684.7\n" + ] + } + ], + "prompt_number": 28 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 42 - pg 125" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Time taken and no. of revolutions made\n", + "#Initialization of variables\n", + "import math\n", + "J=630.;#in kg-m**2\n", + "T_f=1.4*9.81;#in N-m\n", + "T_e=165*9.81;#in N-m\n", + "t2=45.3\n", + "n2=90\n", + "#Calculations\n", + "T_b=T_e+T_f;#in N-m\n", + "Beta=T_b/J;#in rad/sec**2\n", + "f=50.;#in hertz\n", + "P=8.;#no of poles\n", + "N_s=120.*f/P;#in rpm\n", + "w_1=2*math.pi*N_s/60.;#in rad/sec\n", + "t=w_1/Beta;\n", + "n=w_1**2/(2*math.pi*Beta*2);\n", + "#Results\n", + "print 'case 1'\n", + "print 'Time taken to stop the motor (in seconds)=',round(t,1)\n", + "print'Number of revolutions made=',round(n,0)\n", + "print 'case 2'\n", + "print 'Time taken to stop the motor (in seconds)=',round(t2,1)\n", + "print'Number of revolutions made=',round(n2,0)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "case 1\n", + "Time taken to stop the motor (in seconds)= 30.3\n", + "Number of revolutions made= 189.0\n", + "case 2\n", + "Time taken to stop the motor (in seconds)= 45.3\n", + "Number of revolutions made= 90.0\n" + ] + } + ], + "prompt_number": 30 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 43 - pg 126" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate he time taken and no. of Revolutions\n", + "#Initialization of variables\n", + "import math\n", + "P_o=37.5*1000;#in Watts\n", + "N=750.;#in rpm\n", + "Eff=0.9;#Efficiency\n", + "V_L=400.;#in Volts\n", + "pf=0.85;#Power Factor\n", + "R_b=2.5;#in ohms\n", + "#Calculations\n", + "T_f=P_o*60/(2*math.pi*N);#in N-m\n", + "I_L=P_o/(math.sqrt(3)*V_L*pf*Eff);#in Amperes\n", + "I_b=V_L/(math.sqrt(3)*R_b);#in Amperes\n", + "T_E=T_f*I_b/I_L;#in N-m\n", + "T_i_total=T_f+T_E;#in N-m\n", + "w=2*math.pi*N/60;#in rad/sec\n", + "K=T_E/w;\n", + "J=20;#kg-m**2\n", + "t=(J/K)*math.log((T_f+K*w)/T_f);\n", + "n=(1/(2*math.pi*K))*(((J/K)*(T_f+K*w)*(1-math.exp(-K*t/J)))-T_f*t);\n", + "#Results\n", + "print'Time taken (in Seconds)=',round(t,1)\n", + "print'Number of Revolutions Made=',round(n,2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Time taken (in Seconds)= 2.1\n", + "Number of Revolutions Made= 11.35\n" + ] + } + ], + "prompt_number": 31 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 44 - pg 127" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the time taken in both cases\n", + "#Initialization of variables\n", + "import math\n", + "E=240.;#in volts\n", + "R=15.;#in ohms\n", + "N=1500.;#in rpm\n", + "#Calculations\n", + "P=E**2/R;#in Watts\n", + "T_b=P*60/(2*math.pi*N);#in N-m\n", + "T_e=T_b;\n", + "w_1=2*math.pi*N/60;#in rad/sec\n", + "K=T_e/w_1;\n", + "J=20;#kg-m^2\n", + "t=(J/K)*math.log(w_1/62.832);\n", + "T_f=1.5*9.81;#in N-m\n", + "t_o=(J/K)*math.log((T_f+T_e)/(T_f+(T_e*600/1500)));\n", + "#Results\n", + "print'Time taken to bring motor from 1500 rpm to 600 rpm (in seconds)=',round(t,1)\n", + "print 'Time taken for fall of speed if there exist frictional torque (in seconds)=',round(t_o,1)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Time taken to bring motor from 1500 rpm to 600 rpm (in seconds)= 117.8\n", + "Time taken for fall of speed if there exist frictional torque (in seconds)= 60.3\n" + ] + } + ], + "prompt_number": 32 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 45 - pg 144" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the final temperature rise and Heating time constant\n", + "#Initialization of variables\n", + "import math\n", + "d=0.65;#in meters\n", + "l=1.;#in meters\n", + "P_o=12.*735.5;#in watts\n", + "Eff=0.9;#Efficiency\n", + "m=400.;#in kg\n", + "C_p=700.;#in J/Kg/Celcius\n", + "alpha=12.;#in watts/m^2/Celcius\n", + "#Calculations\n", + "P_in=P_o/Eff;#in watts\n", + "P_L=P_in-P_o;#in watts\n", + "S=math.pi*d*l;#in m^2\n", + "Theta=P_L/(S*alpha);#in Celcius\n", + "t=m*C_p/(S*alpha);\n", + "#Results\n", + "print'Final temperature rise (in degree celcius)=',round(Theta,0)\n", + "print 'Heating time constant (in seconds)=',math.ceil(t)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Final temperature rise (in degree celcius)= 40.0\n", + "Heating time constant (in seconds)= 11427.0\n" + ] + } + ], + "prompt_number": 35 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 46 - pg 145" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Final steady state temperature and Heating time constant\n", + "#Initialization of variables\n", + "import matplotlib\n", + "from matplotlib import pyplot\n", + "t=([.2,.4,.6,1,1.5,2,3])\n", + "temp=([7,13.5,19.3,29.1,39.1,46.7,57.3])\n", + "#Calculations\n", + "tf=74 #C\n", + "tff=tf*.632\n", + "time=2\n", + "#Results\n", + "print 'Final steady state temperature = ',tf\n", + "print 'Heating time constant = ',time\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Final steady state temperature = 74\n", + "Heating time constant = 2\n" + ] + } + ], + "prompt_number": 36 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 47 - pg 145" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Heating time constant and Final steady state temperature\n", + "theta_1=20.;#in degree celcius\n", + "theta_2=34.;#in degree celcius\n", + "import math\n", + "t=-1./math.log((theta_2/theta_1)-1.);#in hours\n", + "theta_F=theta_1/(1-math.exp(-1./t));\n", + "theta_f=theta_F/(1-math.exp(-1./t));\n", + "x=math.sqrt(2*(theta_f/theta_F)-1);\n", + "print 'Final steady temperature rise (in degree celcius)=',round(theta_F,2)\n", + "print 'Heating time constant (in hours)=',round(t,1)\n", + "print 'one hour rating of motor is'\n", + "print 'times full load rating',round(x,2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Final steady temperature rise (in degree celcius)= 66.67\n", + "Heating time constant (in hours)= 2.8\n", + "one hour rating of motor is\n", + "times full load rating 2.38\n" + ] + } + ], + "prompt_number": 37 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 48 - pg 146" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Half hour rating of a 25 KW Motor\n", + "#Initialization of variables\n", + "import math\n", + "P=25.;#in KW\n", + "t=1.5;#in hours\n", + "#Calculations\n", + "P_L=math.sqrt((((1/(1-math.exp(-0.5/t)))*1.9)-0.9)*P**2);\n", + "#Results\n", + "print 'Half hour rating of a 25KW Motor (in KW)=',round(P_L,1)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Half hour rating of a 25KW Motor (in KW)= 60.2\n" + ] + } + ], + "prompt_number": 38 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 49 - pg 147" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Time of operation\n", + "#Initialization of variables\n", + "import math\n", + "t=60.;#in minutes\n", + "theta_F=20.;#in degree celcius\n", + "P_L1=2.5625;#Total losses at P KW\n", + "P_L2=7.25;#Total losses at 2P KW\n", + "#Calculations\n", + "theta_f=theta_F*P_L2/P_L1;#in degree celcius\n", + "t_o=t*math.log(1/(1.-(theta_F/theta_f)));\n", + "#Results\n", + "print'Time of operation (in minutes)=',round(t_o,2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Time of operation (in minutes)= 26.17\n" + ] + } + ], + "prompt_number": 39 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 51 - pg 148" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Continuous Rating of Motor\n", + "#Initialization of variables\n", + "import math\n", + "Eff=0.8;#Efficiency\n", + "P1=400.;#in watts\n", + "t1=60.;#in minutes\n", + "t2=15.;#in minutes\n", + "#Calculations\n", + "P=math.sqrt((((2.5625/(1-math.exp(-t2/t1)))-1)**(-1))*(P1/Eff)**2);\n", + "#Results\n", + "print 'Continuous Rating of Motor (in Watts)=',round(P,1)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Continuous Rating of Motor (in Watts)= 153.7\n" + ] + } + ], + "prompt_number": 40 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 52 - pg 148" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Steady state temperature rise and time taken\n", + "#Initialization of variables\n", + "import math\n", + "theta_1=50.;#in degree Celcius\n", + "theta_F=80.;#in degree celcius\n", + "t=0.75;#in hours\n", + "#Calculations\n", + "theta=theta_F*(1-math.exp(-1./t));\n", + "theta_f=theta_F/(1-math.exp(-1/t));\n", + "T=-t*math.log(1-(theta_1/theta_f));\n", + "print 'Temperature rise after 1 hour (in degree celcius)=',theta_F\n", + "print'Steady state temperature rise at 1 hour rating (in degree celcius)=',round(theta_f,2)\n", + "#Results\n", + "print 'Time taken to increase temperature from 50 to 80 degree celcius (in minutes)=',round(60-T*60,2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Temperature rise after 1 hour (in degree celcius)= 80.0\n", + "Steady state temperature rise at 1 hour rating (in degree celcius)= 108.64\n", + "Time taken to increase temperature from 50 to 80 degree celcius (in minutes)= 32.25\n" + ] + } + ], + "prompt_number": 41 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 53 - pg 149" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Value of load in kW during load period\n", + "#Initialization of variables\n", + "import math\n", + "P_cont=100.;#in KWs\n", + "Eff=0.8;#Efficiency\n", + "T_1=50.;#in minutes\n", + "T_2=70.;#in minutes\n", + "t_1=10.;#in minutes\n", + "t_2=10.;#in minutes\n", + "#Calculations\n", + "r=(1-math.exp(-((t_1/T_1)+(t_2/T_2))))/(1.-math.exp(-t_1/T_1));# r=theta_f/theta_F\n", + "P_L=2.5625;#Losses at 100 KW Load \n", + "P_L1=Eff*P_cont;#in Kws\n", + "P=math.sqrt(((P_L*r)-1)*P_L1**2);\n", + "#Results\n", + "print'Value of Load in KW during load period=',round(P,2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Value of Load in KW during load period= 140.93\n" + ] + } + ], + "prompt_number": 42 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 54 - pg 149" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Heating time constant and Final Temperature rise\n", + "#Initialization of variables\n", + "import math\n", + "theta_1=20.;#in degree celcius\n", + "theta_2=30.;#in degree celcius\n", + "t_1=30.;#in minutes\n", + "t_2=60.;#in minutes\n", + "#Calculations\n", + "t=-(t_2-t_1)/math.log((theta_2/theta_1)-1);#in minutes\n", + "theta_F=theta_1/(1-math.exp(-t_1/t));\n", + "#Results\n", + "print 'Heating Time Contant (in minutes)=',round(t,2)\n", + "print 'Final Temperature Rise (in Degree Celcius)=',theta_F" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Heating Time Contant (in minutes)= 43.28\n", + "Final Temperature Rise (in Degree Celcius)= 40.0\n" + ] + } + ], + "prompt_number": 43 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 55 - pg 150" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Maximum Overload\n", + "#Initialization of variables\n", + "import math\n", + "theta_1=30.;#in degree celcius\n", + "theta_2=40.;#in degree celcius\n", + "t_1=1.;#in hours\n", + "t_2=2.;#in hours\n", + "#Calculations\n", + "x=(theta_2/theta_1)-1;\n", + "theta_F=theta_1/(1-x);#in degree celcius\n", + "theta_f=50./(1-x);#in degree celcius\n", + "P_L=25.;#in KWs\n", + "P=P_L*math.sqrt(theta_f/theta_F);\n", + "#Results\n", + "print'Maximum Overload (in KWs)=',round(P,1)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Maximum Overload (in KWs)= 32.3\n" + ] + } + ], + "prompt_number": 44 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 56 - pg 151" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Temperature rise in both cases\n", + "#Initialization of variables\n", + "import math\n", + "theta_1=20.;#in degree celcius\n", + "theta_2=35.;#in degree celcius\n", + "t_1=1/2.;#in hours\n", + "t_2=1.;#in hours\n", + "#Calculations\n", + "t=-(t_2-t_1)/math.log((theta_2/theta_1)-1);#in minutes\n", + "theta_F=theta_1/(1-math.exp(-t_1/t));\n", + "theta=theta_F*(1-math.exp(-2/t));\n", + "theta_F1=theta_F*0.8;#in Degree Celcius\n", + "t_o=0.8*t;#in hours\n", + "theta_o=theta_F1*(1-math.exp(-1/t_o));\n", + "#Results\n", + "print'Temperature Rise After 2 hrs (in Degree Celcius)=',round(theta,1)\n", + "print'Temperature Rise from cold After 1 hr at full load (in Degree Celcius)=',round(theta_o,1)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Temperature Rise After 2 hrs (in Degree Celcius)= 54.7\n", + "Temperature Rise from cold After 1 hr at full load (in Degree Celcius)= 32.8\n" + ] + } + ], + "prompt_number": 46 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 57 - pg 152" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the rating of motor\n", + "#Initialization of variables\n", + "import math\n", + "P_1=100.;#in KWs\n", + "P_2=50.;#in KWs\n", + "t_1=10.;#in minutes\n", + "t_2=8.;#in minutes\n", + "t_3=5.;#in minutes\n", + "t_4=4.;#in minutes\n", + "#Calculations\n", + "P=math.sqrt(((t_1*P_1**2)+(t_2*P_2**2))/(t_1+t_2+t_3+t_4));\n", + "#Results\n", + "print'Rating Of Continuously Rated Motor (in KWs)=',round(P,2)\n", + "print'Adequate rating of motor=70 Kws'" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Rating Of Continuously Rated Motor (in KWs)= 66.67\n", + "Adequate rating of motor=70 Kws\n" + ] + } + ], + "prompt_number": 47 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 58 - pg 152" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Power rating of Motor\n", + "#Initialization of variables\n", + "import math\n", + "T_1=240.;#in N_m\n", + "T_2=140.;#in N-m\n", + "T_3=300.;#in N-m\n", + "T_4=200.;#in N-m\n", + "t_1=20.;#in minutes\n", + "t_2=10.;#in minutes\n", + "t_3=10.;#in minutes\n", + "t_4=20.;#in minutes\n", + "#Calculations\n", + "T=math.sqrt(((t_1*T_1**2)+(t_2*T_2**2)+(t_3*T_3**2)+(t_4*T_4**2))/(t_1+t_2+t_3+t_4));\n", + "N=720.;#in rpm\n", + "P=T*2*math.pi*N/60.;\n", + "#Results\n", + "print'Power rating of Motor(in KWs)=',round(P,0)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Power rating of Motor(in KWs)= 16994.0\n" + ] + } + ], + "prompt_number": 48 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 59 - pg 152" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Power Rating of Motor\n", + "import math\n", + "#Initialization of variables\n", + "t=90.;#in seconds\n", + "#Calculations\n", + "T_eq=math.sqrt(40750./t);#in Kg-m\n", + "N=750.;#in rpm\n", + "P=T_eq*9.81*2*math.pi*N/60.;\n", + "#Results\n", + "print'Power Rating Of Motor (in Kws)=',round(P,0)\n", + "print 'The answers are a bit different from textbook due to rounding off error'" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Power Rating Of Motor (in Kws)= 16395.0\n", + "The answers are a bit different from textbook due to rounding off error\n" + ] + } + ], + "prompt_number": 49 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 60 - pg 153" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Initialization of variables\n", + "import math\n", + "t1=15.\n", + "t2=0.\n", + "t3=85.\n", + "t4=15.\n", + "t5=95.\n", + "t6=83.\n", + "#Calculations\n", + "Hpx=4900./3 *(t1**3-t2**3) + 360000*(t3-t4) + 400./3 *((t5-t3)**3 - (t6-t3)**3)\n", + "Hp=math.sqrt(Hpx/120.)\n", + "#Results\n", + "print 'Hp rating of motor (in hp) = ',round(Hp,0)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Hp rating of motor (in hp) = 507.0\n" + ] + } + ], + "prompt_number": 50 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 61 - pg 158" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the speed at the end of deceleration period\n", + "#Initialization of variables\n", + "import math\n", + "T_l=100*9.81;#in N-m\n", + "t=10;#in seconds\n", + "J=1000;#kg-m^2\n", + "f=50;#in hertz\n", + "P=4;#no.of poles\n", + "s=0.06;#slip\n", + "#Calculations\n", + "N_s=120*f/P;#synchronous speed (in rpm);\n", + "w_s=s*N_s*2*math.pi/60;#slip speed (in rad/sec)\n", + "K=w_s/(50*9.81);\n", + "T_m=T_l-T_l*math.exp(-t/(K*J));\n", + "N_sn=K*T_m*60/(2*math.pi);#in rpm\n", + "N=N_s-N_sn;\n", + "#Results\n", + "print'Speed at the end of deceleration period (in rpm)=',round(N,0)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Speed at the end of deceleration period (in rpm)= 1427.0\n" + ] + } + ], + "prompt_number": 51 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 62 - pg 158" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Moment of Inertia\n", + "#Initialization of variables\n", + "import math\n", + "P_o=500*735.5;#in watts\n", + "N_o=40.;#in rpm\n", + "s_f=0.12;\n", + "#Calculations\n", + "N_f=N_o*(1-s_f);#full load speed (in rpm)\n", + "T_f=P_o/(2*math.pi*N_f/60);#Full load torque (N-m)\n", + "T_m=2*T_f;#Motor torque (in N-m)\n", + "T_l=41500*9.81;#Load torque (in N-m)\n", + "t=10;#seconds\n", + "w_s=s_f*N_o*2*math.pi/60;#slip speed (in rad/sec)\n", + "K=w_s/T_f;\n", + "J=-t/(K*math.log(1-(T_m/T_l)));\n", + "#Results\n", + "print '%s %.3e' %('Moment of Inertia (in Kg-m^2)=',J)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Moment of Inertia (in Kg-m^2)= 2.947e+06\n" + ] + } + ], + "prompt_number": 52 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 63 - pg 159" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the weight of flywheel and time taken\n", + "#Initialization of variables\n", + "import math\n", + "P_o=50*1000.;#in watts\n", + "f=50.;#in hertz\n", + "s_f=0.04;#slip\n", + "P=6.;#no.of poles\n", + "t1=300. #N-m\n", + "t2=1500. #N-m\n", + "r=.9\n", + "T_x=700.\n", + "#Calculations\n", + "N_s=120.*f/P;#Synchronous Speed (in rpm)\n", + "N_f=N_s*(1.-s_f);\n", + "T_f=P_o/(2*math.pi*N_f/60.)\n", + "T_m=2*T_f\n", + "T_L=t1+t2\n", + "T0=t1\n", + "t=10 #sec\n", + "SS=s_f*1000/60.*2*math.pi\n", + "K=SS/T_f\n", + "J=-t/K/math.log((T_L-T_m)/(T_L-T0))\n", + "w=J/r**2\n", + "tx=K*J*math.log((T_m-T0)/(T_x-T0))\n", + "#Results\n", + "print 'Weight of flywheel (in kg) = ',round(w,0)\n", + "print 'Time required (in sec) = ',round(tx,3)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Weight of flywheel (in kg) = 2357.0\n", + "Time required (in sec) = 8.875\n" + ] + } + ], + "prompt_number": 53 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 64 - pg 160" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Moment of Inertia of Flywheel\n", + "#Initialization of variables\n", + "import math\n", + "T_L=600.;#in N-m\n", + "T_m=450.;#in N-m\n", + "N=600.;#in rpm\n", + "#Calculations\n", + "w_o=2*math.pi*N/60.;#in rad/sec\n", + "s=0.08;#slip\n", + "w=s*w_o;#in rad/sec\n", + "K=w/T_m;#Torque constant\n", + "J=(-10./K)/math.log(0.25);#in Kg-m^2\n", + "J_m=10;#in Kg-m^2\n", + "J_F=J-J_m;\n", + "#Results\n", + "print 'Moment Of Inertia Of Flywheel (in Kg-m^2)=',round(J_F,1)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Moment Of Inertia Of Flywheel (in Kg-m^2)= 635.8\n" + ] + } + ], + "prompt_number": 55 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 65 - pg 160" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the weight of flywheel and time taken\n", + "#Initialization of variables\n", + "import math\n", + "P_o=100*1000.;#in watts\n", + "f=50.;#in hertz\n", + "N=960. #rpm\n", + "s_f=0.04;#slip\n", + "P=6.;#no.of poles\n", + "t1=600. #N-m\n", + "t2=2400. #N-m\n", + "r=.9\n", + "T_x=700.\n", + "t=10 #s\n", + "J_M=200.\n", + "#Calculations\n", + "N_s=120.*f/P;#Synchronous Speed (in rpm)\n", + "SS=(N_s-N)*math.pi*2/60.\n", + "T_f=P_o/(2*math.pi*N/60.)\n", + "T_m=2*T_f\n", + "T_L=t1+t2\n", + "T0=t1\n", + "K=SS/T_f\n", + "J=-t/K/math.log((T_L-T_m)/(T_L-T0))\n", + "J_F=J-J_M\n", + "#Results\n", + "print 'Moment of Inertia of flywheel (in kg-m^2) = ',round(J_F,1)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Moment of Inertia of flywheel (in kg-m^2) = 2545.5\n" + ] + } + ], + "prompt_number": 56 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Elements_of_Electric_drives_by_J.B._Gupta/Chapter3.ipynb b/Elements_of_Electric_drives_by_J.B._Gupta/Chapter3.ipynb new file mode 100755 index 00000000..ed18a8f7 --- /dev/null +++ b/Elements_of_Electric_drives_by_J.B._Gupta/Chapter3.ipynb @@ -0,0 +1,1133 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:d7bcb2cff24daf3bf697643c2949d172c753aada733ca26e5769ceae0bfe8259" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 3 - Thyristor control of electric motors" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 1 - pg 215" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Efficiency, Form Factor, Ripple Factor, Transformer Utilisation Factor and Peak Inverse Voltage\n", + "#Initialization of variables\n", + "import math\n", + "from math import sqrt\n", + "V=120.;#in Volts\n", + "V_dc=40.5;#in volts\n", + "V_rms=76.1;#in volts\n", + "R=10.;#in ohms\n", + "#Calculations\n", + "I_dc=V_dc/R;#in Amperes\n", + "I_rms=V_rms/R;#in Amperes\n", + "P_dc=V_dc*I_dc;#in watts\n", + "P_ac=V_rms*I_rms;#in watts\n", + "Eff=P_dc/P_ac;#in per unit\n", + "K_f=V_rms/V_dc;#in per unit\n", + "Y=sqrt(K_f**2-1);\n", + "T_f=P_dc/(V*I_rms);\n", + "P_iv=sqrt(2)*V;\n", + "#Results\n", + "print '(a) Efficiency (in Per Unit=)',round(Eff,3)\n", + "print '(b) Form Factor (in Per Unit=)',round(K_f,3)\n", + "print '(c) Ripple Factor (in Per Unit=)',round(Y,2)\n", + "print'(d) Transformer Utilisation Factor=',round(T_f,2)\n", + "print '(e) Peak Inverse Voltage (in volts)=',round(P_iv,1)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Efficiency (in Per Unit=) 0.283\n", + "(b) Form Factor (in Per Unit=) 1.879\n", + "(c) Ripple Factor (in Per Unit=) 1.59\n", + "(d) Transformer Utilisation Factor= 0.18\n", + "(e) Peak Inverse Voltage (in volts)= 169.7\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2 - pg 216" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the field current, firing angle and power factor of the converter\n", + "#Initialization of variables\n", + "import math\n", + "from math import sqrt\n", + "alpha_f=0;\n", + "R_f=250.;#in ohms\n", + "K_f=0.8;#torque constant\n", + "R_a=0.2;#in ohms\n", + "V_const=0.8;#in volt/Amperes-radian/sec\n", + "N=1000.;# in rpm\n", + "T_d=50.;#In Newton-meter\n", + "V_rms=220.;#in volts\n", + "#Calculations\n", + "V_f=int(V_rms*sqrt(2.)*(1+math.cos(alpha_f*math.pi/180.))/math.pi);# Feild Circuit Voltage (in volts)\n", + "I_f=V_f/R_f;#in Amperes\n", + "I_a=T_d/(K_f*I_f);#in amperes\n", + "w=2*N*math.pi/60;# in radian/sec\n", + "E_b=V_const*w*I_f;#Back emf (in volts)\n", + "V_a=E_b+(I_a*R_a);#armature voltage (in volts)\n", + "alpha_a=math.acos(((V_a*math.pi/(V_rms*sqrt(2))))-1)*180/math.pi;\n", + "P_o=int(V_a*I_a);#in watts\n", + "I=52.66;#in amperes\n", + "pf=P_o/(V_rms*I);\n", + "#Results\n", + "print '(a) Field Current (in Amperes)=',I_f\n", + "print '(b) Firing angle of the converter (in degrees)=',round(alpha_a,2)\n", + "print '(c) Power factor of the converter=',round(pf,2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Field Current (in Amperes)= 0.792\n", + "(b) Firing angle of the converter (in degrees)= 99.83\n", + "(c) Power factor of the converter= 0.56\n" + ] + } + ], + "prompt_number": 30 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3 - pg 217" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Speed of Motor and Motor Torque\n", + "#Initialization of variables\n", + "import math\n", + "from math import sqrt\n", + "alpha_a=45.;#in degrees\n", + "V=230.;#in volts\n", + "K=1.668;#K_a*Phy (in volt/radian/second)\n", + "R_a=0.2;#in ohms\n", + "I_a=30.;#in amperes\n", + "#Calculations\n", + "V_a=2*V*math.sqrt(2)*math.cos(alpha_a*math.pi/180.)/math.pi;#in volts\n", + "E_b=V_a-(I_a*R_a);# in volts\n", + "w=E_b/K;#in radian/seconds\n", + "N=math.ceil(w*60./(2*math.pi));\n", + "T=K*I_a;\n", + "#Results\n", + "print '(a) Speed Of Motor (in rpm)=',N\n", + "print '(b) Motor Torque (in Newton-meter)=',T" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Speed Of Motor (in rpm)= 804.0\n", + "(b) Motor Torque (in Newton-meter)= 50.04\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4 - pg 217" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Firing angle\n", + "#Initialization of variables\n", + "import math\n", + "R_a=0.06;#in ohms\n", + "N1=875.;# in rpm\n", + "N2=750.;#in rpm\n", + "V_rms=220.;#in volts\n", + "V_dc=200.;#in volts\n", + "I_a=150.;#in amperes\n", + "#Calculations\n", + "E_b1=V_dc-(I_a*R_a);#Back emf (in volts)\n", + "E_b2=E_b1*(N2/N1);# in volts\n", + "V_a=E_b2+(I_a*R_a);#armature voltage (in volts)\n", + "alpha_a=math.acos((V_a*math.pi/(2*V_rms*math.sqrt(2))))/math.pi*180.;\n", + "#Results\n", + "print 'Firing angle (in degrees)=',round(alpha_a,2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Firing angle (in degrees)= 29.31\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5 - pg 217" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Average Load Voltage, Current and Input Power Factor\n", + "#Initialization of variables\n", + "import math\n", + "alpha=30.;#in degrees\n", + "V=230.;#in volts\n", + "R=2.;#in ohms\n", + "#Calculations\n", + "V_avg=2*V*math.sqrt(2)*math.cos(alpha*math.pi/180.)/math.pi;#in volts\n", + "I_avg=V_avg/R;#in amperes\n", + "I_rms=I_avg;#in amperes (as ripple free)\n", + "P=V_avg*I_avg;#in watts\n", + "Q=2*V*math.sqrt(2)*I_avg*math.sin(alpha*math.pi/180.)/math.pi;# in VAR\n", + "pf=math.cos(math.atan(Q/P));\n", + "#Results\n", + "print '(a) Average Load Voltage (in Volts)=',round(V_avg,2)\n", + "print '(b) Average Load Current (in Amperes)=',round(I_avg,3)\n", + "print '(c) Input Power Factor (lagging)=',round(pf,3)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Average Load Voltage (in Volts)= 179.33\n", + "(b) Average Load Current (in Amperes)= 89.665\n", + "(c) Input Power Factor (lagging)= 0.866\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6 - pg 218" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the motor Armature Current and motor Speed\n", + "#Initialization of variables\n", + "import math\n", + "alpha=60.;#in degrees\n", + "V=250.;#in volts\n", + "T=140.;#in Newton-Meter\n", + "K_a=2.5;#motor voltage constant (in Volt/radian/sec)\n", + "R_a=0.2;#in ohms\n", + "#Calculations\n", + "V_a=2*V*math.sqrt(2)*math.cos(alpha*math.pi/180.)/math.pi;#in volts\n", + "I_a=T/K_a;#in amperes\n", + "E_b=V_a-(I_a*R_a);#in volts\n", + "w=E_b*I_a/T;\n", + "#Results\n", + "print '(a) Motor Armature Current (in amperes)=',I_a\n", + "print '(b) Motor Speed (in radian/sec)=',round(w,3)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Motor Armature Current (in amperes)= 56.0\n", + "(b) Motor Speed (in radian/sec)= 40.536\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 7 - pg 218" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the firing angle in both cases\n", + "#Initialization of variables\n", + "import math\n", + "V_dc=220.;#in volts\n", + "V=230.;#in volts\n", + "I_a1=10.;#in amperes\n", + "N1=1500.;#in rpm\n", + "N2=500.;#in rpm\n", + "N3=-1000.;#in rpm\n", + "R_a=2.;#in ohms\t\n", + "#Calculations\n", + "E_b1=V_dc-(I_a1*R_a);#in volts\n", + "E_b2=E_b1*(N2/N1);#in volts\n", + "I_a2=I_a1/2;#in amperes\n", + "V_a1=E_b2+(I_a2*R_a);#in volts\n", + "alpha_a1=math.acos((V_a1*math.pi/(2*V*math.sqrt(2))))*180/math.pi;\n", + "E_b3=E_b1*(N3/N1);#in volts\n", + "I_a3=I_a1;#in amperes\n", + "V_a2=E_b3+(I_a3*R_a);#in volts\n", + "alpha_a2=math.acos((V_a2*math.pi/(2*V*math.sqrt(2))))*180/math.pi;\n", + "#Results\n", + "print '(a) Firing angle (in degrees) at half the rated torque=',round(alpha_a1,2)\n", + "print '(b) Firing angle (in degrees) at rated motor torque=',round(alpha_a2,2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Firing angle (in degrees) at half the rated torque= 68.27\n", + "(b) Firing angle (in degrees) at rated motor torque= 123.18\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 8 - pg 219" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Torque developed and motor Speed\n", + "#Initialization of variables\n", + "import math\n", + "alpha_f=0;#in degrees\n", + "alpha_a=30.;#in degrees\n", + "V=220.;#in volts\n", + "I_a=40.;#in amperes\n", + "R_a=0.2;#in amperes\n", + "K_t=1.12;#motor voltage constant (in Volt/radian/sec)\n", + "R_f=200.;#in ohms\n", + "#Calculations\n", + "V_f=2*V*math.sqrt(2)*math.cos(alpha_f*math.pi/180.)/math.pi;#in volts\n", + "I_f=V_f/R_f;#in amperes\n", + "V_a=2*V*math.sqrt(2)*math.cos(alpha_a*math.pi/180.)/math.pi;#in volts\n", + "E_b=V_a-(I_a*R_a);#in volts\n", + "T_d=K_t*I_a*I_f;\n", + "N=E_b*60/(2*math.pi*K_t*I_f);\n", + "#Results\n", + "print '(a) Torque developed (in N-m)=',round(T_d,3)\n", + "print '(b) Motor Speed (in rpm)=',math.ceil(N)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Torque developed (in N-m)= 44.368\n", + "(b) Motor Speed (in rpm)= 1408.0\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 9 - pg 221" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Firing Angle\n", + "#Initialization of variables\n", + "import math\n", + "from math import sqrt\n", + "R_a=0.2;#in ohms\n", + "alpha_f=0;#in degrees\n", + "V=400.;#in volts\n", + "R_f=250.;#in ohms\n", + "K=1.3;#Volts/Ampere-radian/second\n", + "N=1200.;#in rpm\n", + "I_a=60.;#in amperes\n", + "#Calculations\n", + "V_f=3*sqrt(3)*V*sqrt(2)/(sqrt(3)*math.pi);#in volts\n", + "I_f=V_f/R_f;#in amperes\n", + "E_b=K*I_f*2*math.pi*N/60;#in volts\n", + "V_a=E_b+(I_a*R_a);#in volts\n", + "alpha_a=math.acos((V_a*math.pi)/(3*V*sqrt(2)))*180/math.pi;\n", + "#Results\n", + "print'Firing Angle (in degrees)=',round(alpha_a,2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Firing Angle (in degrees)= 47.49\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 10 - pg 221" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the No-Load Speed and Firing Angle\n", + "#Initialization of variables\n", + "import math\n", + "from math import sqrt\n", + "alpha_a=45.;#in degrees\n", + "R_a=0.2;#in ohms\n", + "K=0.25;#in volts/rpm\n", + "V=400.;#in volts\n", + "I_ao=5.;#in amperes (no load armature current)\n", + "N=1500.;#in rpm\n", + "I_a=100.;#in amperes\n", + "#Calculations\n", + "V_ao=3*sqrt(3)*V*sqrt(2)*(1+math.cos(180/math.pi*alpha_a))/(sqrt(3)*math.pi*2);#in volts\n", + "E_bo=V_ao-(I_ao*R_a);#in volts\n", + "N_o=E_bo/K;\n", + "E_b=N*K;#in volts\n", + "V_a=E_b+(I_a*R_a);#in volts\n", + "alpha_ao=math.acos(((V_a*math.pi*2)/(3*V*sqrt(2)))-1)*180/math.pi;\n", + "#Results\n", + "print'No-Load Speed (in rpm)=',int(N_o)\n", + "print 'Firing Angle (in degrees)=',round(alpha_ao,2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "No-Load Speed (in rpm)= 436\n", + "Firing Angle (in degrees)= 62.45\n" + ] + } + ], + "prompt_number": 12 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 11 - pg 222" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the speed-torque characteristics\n", + "#Initialization of variables\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "import math\n", + "import numpy\n", + "import matplotlib\n", + "from matplotlib import pyplot\n", + "Vm=400. #V\n", + "alp=90 #degrees\n", + "Ia=([5,10,20,30,40])\n", + "Ra=0.8\n", + "Kt=2.\n", + "n=len(Ia)\n", + "Ta=numpy.zeros(n)\n", + "Eb=numpy.zeros(n)\n", + "RPM=numpy.zeros(n)\n", + "#Calculations\n", + "Va=3*math.sqrt(2)/2./math.pi *Vm*(1+math.cos(alp*math.pi/180.))\n", + "for i in range (0,n):\n", + "\tTa[i] = 2*Ia[i]\n", + "\tEb[i] = Va-Ia[i]*Ra\n", + "\tRPM[i] = round(Eb[i] /Kt *60./2/math.pi,0)\n", + "\n", + "#Results\n", + "print RPM\n", + "pyplot.plot(Ta,RPM)\n", + "pyplot.xlabel('Ta')\n", + "pyplot.ylabel('RPM')\n", + "pyplot.title('speed-torque characteristic curve')\n", + "pyplot.show()" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "[ 1271. 1251. 1213. 1175. 1137.]\n" + ] + }, + { + "metadata": {}, + "output_type": "display_data", + "png": "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEZCAYAAABrUHmEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAABJRU5ErkJggg==\n", + "text": [ + "" + ] + } + ], + "prompt_number": 15 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 12 - pg 226" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Average Load Voltage, thyristor current, Diode current, Effective input resistance\n", + "#Initialization of variables\n", + "alpha=0.4;#duty cycle\n", + "V_dc=200.;#in volts\n", + "R=10;#in ohms\n", + "#Calculations\n", + "V_a=alpha*V_dc;\n", + "I=V_a/R;\n", + "I_d=0;\n", + "R_eff=R/alpha;\n", + "#Results\n", + "print '(a) Average Load Voltage (in volts)=',V_a\n", + "print '(b) Average thyristor current (in amperes)=',I\n", + "print '(c) Diode Current (in amperes)=',I_d\n", + "print '(d) Effective input resistance (in ohms)=',R_eff" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Average Load Voltage (in volts)= 80.0\n", + "(b) Average thyristor current (in amperes)= 8.0\n", + "(c) Diode Current (in amperes)= 0\n", + "(d) Effective input resistance (in ohms)= 25.0\n" + ] + } + ], + "prompt_number": 16 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 13 - pg 228" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the average load Current and Firing Angle\n", + "#Initialization of variables\n", + "V_dc=220.;#in volts\n", + "V_a=250.;#average load voltage (in volts)\n", + "R=10.;#in ohms\n", + "#Calculations\n", + "alpha=1.-(V_dc/V_a);\n", + "I=V_a/R;\n", + "#Results\n", + "print 'Average Load Current (in amperes)=',I\n", + "print 'Firing Angle (in degrees)=',alpha" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Average Load Current (in amperes)= 25.0\n", + "Firing Angle (in degrees)= 0.12\n" + ] + } + ], + "prompt_number": 17 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 14 - pg 229" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Frequency of Switching pulse\n", + "#Initialization of variables\n", + "V_dc=125.;#in volts\n", + "V_a=200.;#average output voltage (in volts)\n", + "T_on=1*10**-3;#in seconds\n", + "#Calculations\n", + "alpha=V_a/(V_a+V_dc);#duty cycle\n", + "f=alpha/T_on;\n", + "#Results\n", + "print'Frequency Of Switching pulse (in hertz)=',round(f,1)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Frequency Of Switching pulse (in hertz)= 615.4\n" + ] + } + ], + "prompt_number": 18 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 15 - pg 234" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Frequency\n", + "#Initialization of variables\n", + "alpha=0.25;#duty cycle\n", + "V=400;#in volts\n", + "L=0.5;#in henery\n", + "I=10;#ripple current (in amperes)\n", + "#Calculations\n", + "V_a=alpha*V;#in volts\n", + "T_on=L*I/(V-V_a);#in seconds\n", + "T=T_on/alpha;#in seconds\n", + "f=1./T;\n", + "#Results\n", + "print 'Frequency (in hertzs)=',f" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Frequency (in hertzs)= 15.0\n" + ] + } + ], + "prompt_number": 19 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 16 - pg 234" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Range of Speed Control and duty cycle\n", + "#Initialization of variables\n", + "V_a=120.;#in volts\n", + "I_a=20.;#in amperes\n", + "R_a=0.5;#in ohms\n", + "K=0.05;#Motor constant (in volts/rpm)\n", + "#Calculations\n", + "E_b=V_a-(I_a*R_a);#in volts\n", + "N=E_b/K;#in rpm\n", + "E_bo=0;#in volts\n", + "V_a1=E_bo+(I_a*R_a);#in volts\n", + "alpha=V_a1/V_a;\n", + "#Results\n", + "print 'Range of Speed Control is :'\n", + "print 'Lowest Speed (in rpm) = 0'\n", + "print 'Highest Speed (in rpm)=',N\n", + "print 'Range of duty cycle is :'\n", + "print 'lowest value of duty cycle=',round(alpha,3)\n", + "print 'Highest value of duty cycle= 1'" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Range of Speed Control is :\n", + "Lowest Speed (in rpm) = 0\n", + "Highest Speed (in rpm)= 2200.0\n", + "Range of duty cycle is :\n", + "lowest value of duty cycle= 0.083\n", + "Highest value of duty cycle= 1\n" + ] + } + ], + "prompt_number": 21 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 17 - pg 235" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Duty Cycle of the Chopper\n", + "#Initialization of variables\n", + "V=200;#in volts\n", + "I_a=100;#in amperes\n", + "R_a=0.02;#in ohms\n", + "N1=940;#in rpm\n", + "N2=500;#in rpm\n", + "#Calculations\n", + "E_b1=V-(I_a*R_a);#in volts\n", + "E_b2=E_b1*N2/N1;#in volts\n", + "V_a=E_b2+(I_a*R_a);#in volts\n", + "alpha=V_a/V;\n", + "#Results\n", + "print 'Duty Cycle Of The Chopper=',round(alpha,4)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Duty Cycle Of The Chopper= 0.5366\n" + ] + } + ], + "prompt_number": 22 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 18 - pg 235" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the power input, motor speed, Torque developed, Minimum and Maximum speed\n", + "#Initialization of variables\n", + "import math\n", + "alpha=0.6;#duty cycle\n", + "alpha1=0.1;#duty cycle\n", + "alpha2=0.9;#duty cycle\n", + "V=400.;#in volts\n", + "R_a=0.1;#in ohms\n", + "K=4;#Motor Constant (in Volts/radians)\n", + "I_a=150.;#in Amperes\n", + "#Calculations\n", + "P_in=alpha*V*I_a/1000;\n", + "V_a=alpha*V;#in volts\n", + "E_b=V_a-(I_a*R_a);#in volts\n", + "N=60*E_b/(2*math.pi*K);\n", + "T=E_b*I_a*60/(2*math.pi*N);\n", + "E_b1=(alpha1*V)-(I_a*R_a);#in volts\n", + "N1=60*E_b1/(2*math.pi*K);\n", + "E_b2=(alpha2*V)-(I_a*R_a);#in volts\n", + "N2=60*E_b2/(2*math.pi*K);\n", + "#Results\n", + "print '(a) Power input (in Kilo-Watts)=',P_in\n", + "print '(b) Motor Speed (in rpm)=',int(N)\n", + "print '(c) Torque developed (in Newton-meter)=',T\n", + "print '(d) Minimum Speed (in rpm)=',math.ceil(N1)\n", + "print ' Maximum Speed (in rpm)=',math.ceil(N2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Power input (in Kilo-Watts)= 36.0\n", + "(b) Motor Speed (in rpm)= 537\n", + "(c) Torque developed (in Newton-meter)= 600.0\n", + "(d) Minimum Speed (in rpm)= 60.0\n", + " Maximum Speed (in rpm)= 824.0\n" + ] + } + ], + "prompt_number": 23 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 19 - pg 236" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Average Voltage, Power Dissipated and Speed\n", + "#Initialization of variables\n", + "import math\n", + "alpha=0.4;#duty cycle\n", + "R_b=7.5;#in ohms\n", + "R_a=0.1;#in ohms\n", + "I_f=1.5;#in amperes\n", + "K=1.6;#Voltage Constant (in V/A-rad/sec)\n", + "I_a=150;#in amperes\n", + "#Calculations\n", + "V_b=(1-alpha)*R_b*I_a;\n", + "P_b=I_a**2*R_b*(1-alpha);\n", + "E_g=V_b+(I_a*R_a);#in volts\n", + "N=60*E_g/(K*I_f*2*math.pi);\n", + "#Results\n", + "print'(a) Average Voltage (in volts)=',V_b\n", + "print'(b) Power Dissipated (in kilo-watts)=',P_b/1000.\n", + "print'(c) Speed (in rpm)=',int(N)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Average Voltage (in volts)= 675.0\n", + "(b) Power Dissipated (in kilo-watts)= 101.25\n", + "(c) Speed (in rpm)= 2745\n" + ] + } + ], + "prompt_number": 24 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 20 - pg 236" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Firing Angle and Power Supplied\n", + "#Initialization of variables\n", + "import math\n", + "E_g=-163.53;#in volts\n", + "I_a=40.;#in amperes\n", + "R_a=0.2;#in ohms\n", + "V=220.;#in volts\n", + "#Calculations\n", + "V_a=E_g+(I_a*R_a);#in volts\n", + "alpha_a=math.acos(V_a*math.pi/(2*V*math.sqrt(2)))*180/math.pi;\n", + "P=V_a*I_a*(-1);\n", + "#Results\n", + "print 'Firing Angle (in degrees)=',round(alpha_a,2)\n", + "print 'Power Supplied (in Kilo-Watts)=',P/1000." + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Firing Angle (in degrees)= 141.74\n", + "Power Supplied (in Kilo-Watts)= 6.2212\n" + ] + } + ], + "prompt_number": 25 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 21 - pg 236" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Pulse Width\n", + "#Initialization of variables\n", + "E_b=100;#in volts\n", + "I_a=25;#in amperes\n", + "R=0.2;#(R_a+R_se) in ohms\n", + "V=220.;#in volts\n", + "f=200.;#in hertz\n", + "#Calculations\n", + "V_a=E_b+(I_a*R);#in volts\n", + "T_on=V_a/(V*f);\n", + "#Results\n", + "print ' Pulse Width (in mili-seconds)',round(T_on*1000,2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + " Pulse Width (in mili-seconds) 2.39\n" + ] + } + ], + "prompt_number": 26 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 22 - pg 244" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Armature Current and Motor Torque\n", + "#Initialization of variables\n", + "import math\n", + "N=1000.;#in rpm\n", + "V=240.;#in volts\n", + "w=2*math.pi*N/60.;#in rad/sec\n", + "alpha=30*math.pi/180.;#in radians\n", + "R=0.25;#in ohms\n", + "K=0.025;#in Nm/A**2\n", + "#Calculations\n", + "V_a1=math.sqrt(2)*V*(1+math.cos(alpha))/math.pi;#in volts\n", + "I_a1=V_a1/(R+(K*w));\n", + "T_1=K*I_a1**2;\n", + "V_a2=2*math.sqrt(2)*V*math.cos(alpha)/math.pi;#in volts\n", + "I_a2=V_a2/(R+(K*w));\n", + "T_2=K*I_a2**2;\n", + "#Results\n", + "print 'When controlled through semiconverter'\n", + "print 'Armature Current (in Amperes)=',round(I_a1,1)\n", + "print 'Motor Torque (in N-m)=',round(T_1,2)\n", + "print 'When controlled through full converter'\n", + "print 'Armature Current (in Amperes)=',round(I_a2,2)\n", + "print 'Motor Torque (in N-m)=',round(T_2,2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "When controlled through semiconverter\n", + "Armature Current (in Amperes)= 70.3\n", + "Motor Torque (in N-m)= 123.53\n", + "When controlled through full converter\n", + "Armature Current (in Amperes)= 65.25\n", + "Motor Torque (in N-m)= 106.43\n" + ] + } + ], + "prompt_number": 27 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 23 - pg 244" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Average Motor Current and Speed\n", + "#Initialization of variables\n", + "import math\n", + "from math import sqrt\n", + "V=230.;#in volts\n", + "K_t=0.3;#torque constant (in N-m/A^2)\n", + "T_L=30.;#in N-m\n", + "#Calculations\n", + "V_dc=sqrt(2)*V*2/math.pi;#in volts\n", + "I_a=sqrt(T_L/K_t);\n", + "w=(207.-I_a)/(K_t*I_a);# in rad/sec\n", + "N=w*60./(2*math.pi);\n", + "#Results\n", + "print 'Average Motor Current (in Amperes)=',I_a\n", + "print 'Speed (in rpm)=',round(N,0)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Average Motor Current (in Amperes)= 10.0\n", + "Speed (in rpm)= 627.0\n" + ] + } + ], + "prompt_number": 28 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 24 - pg 245" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#calculate the Armature current and Firing angle\n", + "#Initialization of variables\n", + "import math\n", + "from math import sqrt\n", + "I_a1=36;#in amperes\n", + "N1=400;#in amperes\n", + "N2=600;#in amperes\n", + "alpha_1=100*math.pi/180.;#in radians\n", + "V=675;#in volts\n", + "R=0.4;#in ohms\n", + "#Calculations\n", + "V_a1=sqrt(2)*V*(1+math.cos(alpha_1))/math.pi;#in volts\n", + "E_b1=V_a1-I_a1*R;#in volts\n", + "I_a2=I_a1*N2/N1;#in amperes\n", + "E_b2=E_b1*I_a2*N2/(I_a1*N1);#in volts\n", + "V_a2=E_b2+21.6;#/in volts\n", + "alpha=math.acos((V_a2*math.pi/(sqrt(2)*V))-1)*180/math.pi;\n", + "#Results\n", + "print 'Armature current (in Amperes)=',I_a2\n", + "print 'Firing angle (in degrees)=',round(alpha,2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Armature current (in Amperes)= 54\n", + "Firing angle (in degrees)= 34.54\n" + ] + } + ], + "prompt_number": 29 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Elements_of_Electric_drives_by_J.B._Gupta/screenshots/chap1.png b/Elements_of_Electric_drives_by_J.B._Gupta/screenshots/chap1.png new file mode 100755 index 00000000..4bfe703f Binary files /dev/null and b/Elements_of_Electric_drives_by_J.B._Gupta/screenshots/chap1.png differ diff --git a/Elements_of_Electric_drives_by_J.B._Gupta/screenshots/chap12.png b/Elements_of_Electric_drives_by_J.B._Gupta/screenshots/chap12.png new file mode 100755 index 00000000..86719f19 Binary files /dev/null and b/Elements_of_Electric_drives_by_J.B._Gupta/screenshots/chap12.png differ diff --git a/Elements_of_Electric_drives_by_J.B._Gupta/screenshots/chap3.png b/Elements_of_Electric_drives_by_J.B._Gupta/screenshots/chap3.png new file mode 100755 index 00000000..8fd3f884 Binary files /dev/null and b/Elements_of_Electric_drives_by_J.B._Gupta/screenshots/chap3.png differ -- cgit