From 64874ad005ac7fea242828c5094fc827e7736851 Mon Sep 17 00:00:00 2001 From: root Date: Mon, 7 Jul 2014 17:05:00 +0530 Subject: adding book --- .../Chapter_1.ipynb | 90 + .../Chapter_3.ipynb | 598 ++++++ .../Chapter_4.ipynb | 622 ++++++ .../Chapter_5.ipynb | 2202 ++++++++++++++++++++ .../Chapter__6.ipynb | 1223 +++++++++++ .../README.txt | 10 + .../screenshots/5_17.png | Bin 0 -> 30075 bytes .../screenshots/5_41.png | Bin 0 -> 22101 bytes .../screenshots/5_9.png | Bin 0 -> 31865 bytes 9 files changed, 4745 insertions(+) create mode 100644 Fundamentals_of_Electric_Drives_and_Control/Chapter_1.ipynb create mode 100644 Fundamentals_of_Electric_Drives_and_Control/Chapter_3.ipynb create mode 100644 Fundamentals_of_Electric_Drives_and_Control/Chapter_4.ipynb create mode 100644 Fundamentals_of_Electric_Drives_and_Control/Chapter_5.ipynb create mode 100644 Fundamentals_of_Electric_Drives_and_Control/Chapter__6.ipynb create mode 100644 Fundamentals_of_Electric_Drives_and_Control/README.txt create mode 100644 Fundamentals_of_Electric_Drives_and_Control/screenshots/5_17.png create mode 100644 Fundamentals_of_Electric_Drives_and_Control/screenshots/5_41.png create mode 100644 Fundamentals_of_Electric_Drives_and_Control/screenshots/5_9.png (limited to 'Fundamentals_of_Electric_Drives_and_Control') diff --git a/Fundamentals_of_Electric_Drives_and_Control/Chapter_1.ipynb b/Fundamentals_of_Electric_Drives_and_Control/Chapter_1.ipynb new file mode 100644 index 00000000..2272af44 --- /dev/null +++ b/Fundamentals_of_Electric_Drives_and_Control/Chapter_1.ipynb @@ -0,0 +1,90 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 1:Fundamentals of Electric Drives" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example no:1.1,Page no:10" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + " \n", + "import math \n", + "\n", + "\n", + "#Variable declaration\n", + "J=12 #journey per hour\n", + "Load=5500 #[Load] Kg\n", + "t_up=1.5 #[time] min\n", + "W_cage=500 #[Weight of cage] Kg\n", + "t_down=1.25 #[time] min\n", + "h=50 #[height] m\n", + "Wb=3000 #Kg(Balance weight)\n", + "Eff_hoist=0.8 #Effeciency of hoist \n", + "Eff_motor=0.85 #Efficiency of motor\n", + "g=9.81 #gravity constant\n", + "\n", + "#Calculation\n", + "E_upward=(Load+W_cage-Wb)*g*h #J\n", + "E_downward=(Wb-W_cage)*g*h #J\n", + "Edj=E_upward+E_downward #J(Energy used in double journey)\n", + "Ein=Edj/Eff_hoist/Eff_motor #J or W-s\n", + "Ein=Ein/1000/3600 #KWh\n", + "Ein_hour=Ein*J #KWh\n", + "\n", + "Rating=E_upward/Eff_hoist/t_up/60 #W\n", + "\n", + "#Result\n", + "print\"\\n\\n(a).Electrical energy used in upward journey :\",E_upward,\"J\"\n", + "print\" Electrical energy used in downward journey :\",E_downward,\"J\"\n", + "print\" Electrical energy used in each double journey :\",Edj,\"J\"\n", + "print\" Energy input in each double journey=\",round(Ein,3),\"kWh\\n\"\n", + "print\"(b).Electrical energy consumption in one hour : \",round(Ein_hour,3),\"kWh\\n\"\n", + "print\"(c) kW Rating of motor: \",Rating/1000,\"kW\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "\n", + "\n", + "(a).Electrical energy used in upward journey : 1471500.0 J\n", + " Electrical energy used in downward journey : 1226250.0 J\n", + " Electrical energy used in each double journey : 2697750.0 J\n", + " Energy input in each double journey= 1.102 kWh\n", + "\n", + "(b).Electrical energy consumption in one hour : 13.224 kWh\n", + "\n", + "(c) kW Rating of motor: 20.4375 kW\n" + ] + } + ], + "prompt_number": 1 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Fundamentals_of_Electric_Drives_and_Control/Chapter_3.ipynb b/Fundamentals_of_Electric_Drives_and_Control/Chapter_3.ipynb new file mode 100644 index 00000000..d03a01e6 --- /dev/null +++ b/Fundamentals_of_Electric_Drives_and_Control/Chapter_3.ipynb @@ -0,0 +1,598 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 3: Dynamics of Electric Drives" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example no:3.1,Page no:34" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "#Variable declaration\n", + "MoI=0.3 #Moment of inertia of motor[Kg-m**2]\n", + "T=20 #Torque developed[N-m]\n", + "MoIshaft=10 #Shaft load moment of inertia in Kg-m**2\n", + "LostT=10 #Torque lost [%]\n", + "\n", + "#Calculation\n", + "MoItotal=MoI+MoIshaft #Total moment of inertia in Kg-m**2\n", + "LoadTorque=T-T*LostT/100 # Load torque in N-m\n", + "\n", + "#Result\n", + "print\"Total Moment of Inertia: \",MoItotal,\"Kg-m**2\"\n", + "print\"Load Torque is:\",LoadTorque,\"N-m\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Total Moment of Inertia: 10.3 Kg-m**2\n", + "Load Torque is: 18 N-m\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example no:3.2,Page no:34" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "from fractions import Fraction\n", + "from decimal import Decimal\n", + "#Variable declaration\n", + "n=0.1 #teeth ratio\n", + "ETAg=90/100.0 #efficiency\n", + "J0=0.4 #Inertia of motor Kg-m**2\n", + "J1=10 #Load moment of inertia Kg-m**2\n", + "TL=50 #Torque N-m\n", + "N=1400 #speed in rpm\n", + "\n", + "#Calculation\n", + "J=J0+n**2*J1 #Kg-m**2\n", + "T=n*TL/ETAg #Load torque referred to motor side in [N-m]\n", + "MotorSpeed=2*math.pi*N/60 #Speed of motor [rad/sec]\n", + "Pdev=MotorSpeed*T #Power developed by motor [Watt]\n", + "\n", + "#Result\n", + "print\"Equivalent Inertia: \",J,\"Kg-m^2\"\n", + "print\"Load Torque refered to motor side : \",round(T,3),\"N-m,(which is equal to 50/9 N in fraction)\"\n", + "print\"Power developed by motor: \",round(Pdev,3),\"W\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Equivalent Inertia: 0.5 Kg-m^2\n", + "Load Torque refered to motor side : 5.556 N-m,(which is equal to 50/9 N in fraction)\n", + "Power developed by motor: 814.487 W\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example no:3.3,Page no:35" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "#Variable declaration\n", + "v=60.0 #Velocity of train Km/hr\n", + "w=400.0 #Total weight of train in KN\n", + "friction=5.0 #frictional resistance N/KN weight\n", + "tan_theta=1/100.0 #inclination\n", + "g=9.81 # gravity constant\n", + "\n", + "#Calculation\n", + "\n", + "#Part(a):\n", + "sin_theta=tan_theta \n", + "W_sin_theta=w*1000*sin_theta #N\n", + "R=friction*W_sin_theta/10.0 #frictional resistance in N\n", + "P=W_sin_theta+R #Total force opposing motion[N]\n", + "v=60*1000/60.0/60.0 #Speed of traing[m/s]\n", + "Power=P*v #Power[Watt]\n", + "Force=P #down the inclined force in N\n", + "\n", + "#Part(b):\n", + "u=v #initial velocity in m/s\n", + "v=0 #final velocity in m/s\n", + "m=w*1000/g #in Kg\n", + "KE=1.0/2.0*m*u**2 #in Joule\n", + "d=KE/P #distance in meter\n", + "\n", + "#Result\n", + "print\"(a).Final KW rating of the motor of train : \",Power/1000.0,\"KW\"\n", + "print\"(b).Distance covered : \",d,\"m\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a).Final KW rating of the motor of train : 100.0 KW\n", + "(b).Distance covered : 943.859251708 m\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example no:3.4,Page no:35" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "#Variable declaration\n", + "MotorOutput=200.0 #Increased output of motor in KW\n", + "v=60.0 #Velocity of train in Km/hr\n", + "w=400.0 #Total weight of train in KN\n", + "friction=5.0 #frictional resistance in N/KN weight\n", + "tan_theta=1/100.0 #inclination\n", + "g=9.81 # gravity constant\n", + "\n", + "#Calculation\n", + "sin_theta=tan_theta \n", + "W_sin_theta=w*1000*sin_theta #N\n", + "R=friction*W_sin_theta/10 #frictional resistance in N\n", + "P=W_sin_theta+R #N\n", + "v=60*1000.0/60.0/60.0 #Velocity of train[m/s]\n", + "Power=P*v #Power[Watt]\n", + "Pdash=MotorOutput*1000-Power #Power causes acceleration in watt or N-m/s\n", + "m=w*1000.0/g #Mass in Kg\n", + "a=Pdash/m #Acceleration of train in m/s**2\n", + "\n", + "#Result\n", + "print\"Acceleration is: \",round(a,3),\"m/s**2\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Acceleration is: 2.453 m/s**2\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example no:3.5,Page no:36" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "#Variable declaration\n", + "MotorSpeed=200 #Speed of motor [rpm]\n", + "d1=50 #diameter of motor pulley in cm\n", + "MachineSpeed=100 #Speed of machine [rpm]\n", + "\n", + "#Calculation\n", + "d2=MotorSpeed/MachineSpeed*d1 #diameter of machine pulley in cm\n", + "\n", + "#Result\n", + "print\"Diameter of machine pulley : \",d2,\"cm\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Diameter of machine pulley : 100 cm\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example no:3.6,Page no:36" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "#Variable declaration\n", + "v=1.2 #belt conveyer speed in m/s\n", + "TransRate=100 #rate of transportation of material in tons/hour\n", + "l=200 #length of belt in meter\n", + "MotorSpeed=1200 #Speed of motor in rpm\n", + "MoI=0.1 #Moment of Inertia in Kg-m**2\n", + "\n", + "\n", + "#Calculation\n", + "#Part A\n", + "TransRate=TransRate*1000/60.0/60.0 #rate of transportation of material in Kg/sec\n", + "TransTime=l/v #Time of transportation [sec]\n", + "omega=MotorSpeed*2*math.pi/60.0 #Angular velocity [rad/sec]\n", + "M=TransRate*TransTime #Mass of material carried[Kg]\n", + "J=M*(v/omega)**2 #Total inertia[Kg-m**2]\n", + "#Part B\n", + "t=8 #Time [sec]\n", + "a=v/t #Acceleration [m/s**2]\n", + "TorqueInertai=MoI*omega/t #Torque required for inertia [N-m]\n", + "F=M*a #Force[N]\n", + "Tload=F*v/omega #Totruq to accelerate load [N-m]\n", + "TotalTorque=Tload+TorqueInertai #Total torque[N-m]\n", + "\n", + "#Result\n", + "print\"(a).Load Inertia : \",round(J,4),\"Kg-m**2\"\n", + "print\"(b).Total Torque is: \",round(TotalTorque,2),\"N-m\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a).Load Inertia : 0.4222 Kg-m**2\n", + "(b).Total Torque is: 8.2 N-m\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example no:3.7,Page no:37" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "#Variable declaration\n", + "w=400 #Weight to be lifted Kg\n", + "v=1 #Uniform velocity m/s\n", + "MotorSpeed=1000 #Motor speed rpm\n", + "MoI=0.5 #Moment of Inertia in Kg-m**2\n", + "winch=0.3 #Moment of inertia of winch Kg-m**2\n", + "Tnl=80 #Torque in absence of wt in N-m\n", + "Speed_nl=1000 #speed of motor in rpm\n", + "g=9.81 #gravity constant\n", + "\n", + "#Calculation\n", + "mass=w*g #N\n", + "omega=MotorSpeed*2*math.pi/60 #rad/sec\n", + "TotTorque=Tnl+mass*v/omega #Total torque [N-m]\n", + "J=MoI+winch+w*(v/omega)**2 #Kg-m**2\n", + "\n", + "#Result\n", + "print\"Total Motor Torque : \",round(TotTorque,2),\"N-m\"\n", + "print\"Moment of Inertia refered to motor shaft : \",round(J,4),\"Kg-m**2\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Total Motor Torque : 117.47 N-m\n", + "Moment of Inertia refered to motor shaft : 0.8365 Kg-m**2\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example no:3.9,Page no:38" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "#Variable declaration\n", + "Jmotor=0.3 #Inertia of motor in Kg-m**2\n", + "Jgd_load=15.0 #Kg-m**2(Inertia gear driven load)\n", + "GSRratio=0.1 #gear speed reduction ratio\n", + "Jbd_load=0.6 #Kg-m**2(Inertia belt driven load)\n", + "d1=10.0 #cm(diameter of driver pulley)\n", + "d2=30.0 #cm(diameter of driven pulley)\n", + "MotorSpeed=1440.0 #Speed of motor in rpm\n", + "Tload1=100.0 #Troque on load 1 N-m\n", + "Tload2=35.0 #Torque on load 2 in N-m\n", + "\n", + "\n", + "#Calculation\n", + "MotorSpeed=MotorSpeed*2*math.pi/60.0 #Speed of motor [rad/sec]\n", + "Speed_gd=GSRratio*MotorSpeed #Speed of load driven gear[rad/sec]\n", + "Speed_bd=MotorSpeed*d1/d2 #Speed of belt driven load[rad/sec]\n", + "\n", + "#Equating Kinetic Energies\n", + "#1/2*J*MotorSpeed**2=1/2*Jmotor*MotorSpeed**2+1/2*Jgd_load*speed_gd**2+1/2*Jbd_load*speed_bd**2\n", + "J=(1/2.0*Jmotor*MotorSpeed**2+1/2.0*Jgd_load*Speed_gd**2+1/2.0*Jbd_load*Speed_bd**2)*2.0/MotorSpeed**2.0 #Equivalent inertia \n", + "\n", + "#Equating power of motor\n", + "#T*(MotorSpeed)=Tload1*Speed_gd+Tload2*Speed_bd\n", + "T=(Tload1*Speed_gd+Tload2*Speed_bd)/MotorSpeed #Torque at motor shaft[N-m]\n", + "Pdev=T*MotorSpeed #Power developed by motor [watt]\n", + "\n", + "\n", + "#Result\n", + "print\"Moment of Inertia refered to motor shaft : \",round(J,4),\"Kg-m^2\"\n", + "print\"Torque is: \",round(T,3),\"N-m\"\n", + "print\"Power developed by the motor: \",round(Pdev,1),\"W\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Moment of Inertia refered to motor shaft : 0.5167 Kg-m^2\n", + "Torque is: 21.667 N-m\n", + "Power developed by the motor: 3267.3 W\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example no:3.10,Page no:39" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "#Variable declaration\n", + "MotorSpeed=1440 #Motor speed rpm\n", + "Jmotor=0.4 # Moment of inertia of motor Kg-m**2\n", + "Jdc_load=0.6 #Kg-m**2(Inertia directly coupled load)\n", + "w_tl=100 #kg(weight of transratioonal load)\n", + "F_res=1.2 #N/Kg(Friction resistance for translational load)\n", + "v=10 #Velocity of translational load in m/s\n", + "T_RotLoad=1.5 #Torque of rotational load in N-m\n", + "g=9.81 #gravity constant\n", + "\n", + "#Calculation\n", + "MotorSpeed=MotorSpeed*2*math.pi/60 #Motor speed [rad/sec]\n", + "F_horz=w_tl*F_res #N(horizontal force of translational load)\n", + "mass=w_tl*g #Mass of load[N]\n", + "J=Jmotor+Jdc_load+mass*(v/MotorSpeed)**2 #Inertia [Kg-m**2]\n", + "T=T_RotLoad+F_horz*v/MotorSpeed #Torque at motor shaft[N-m]\n", + "\n", + "#Result\n", + "print\"Moment of Inertia at motor shaft is:\",round(J,3),\"Kg-m^2\"\n", + "print\"Torque at motor shaft: \",round(T,2),\"N-m\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Moment of Inertia at motor shaft is: 5.314 Kg-m^2\n", + "Torque at motor shaft: 9.46 N-m\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example no:3.11,Page no:41" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "import numpy as np\n", + "from scipy import misc\n", + "#Variable declaration\n", + "#T=0.6+1.9*omega_m\n", + "#TL=2.8*math.sqrt(omega_m)\n", + "def T(w):\n", + " return(0.6+1.9*w)\n", + "def Tl(w):\n", + " return(2.8*w**0.5)\n", + " \n", + "#Calculation\n", + "coeff = [3.61,-5.56,0.36]\n", + "W=np.roots(coeff)\n", + "dT_dw=range(2)\n", + "dTl_dw=range(2)\n", + "for i in range(0,2):\n", + " dT_dw[i]=scipy.misc.derivative(T,W[i],dx=1e-6)\n", + " dTl_dw[i]=scipy.misc.derivative(Tl,W[i], dx=1e-6)\n", + "\n", + "#Result \n", + "print\"w=\",round(W[0],2),\"or\",round(W[1],3),\"rad/sec\"\n", + "for i in range(0,2): \n", + " print\"At,w=\",round(W[i],3),\"rad/s\"\n", + " if dTl_dw[i] < dT_dw[i]:\n", + " print \"This operating point does not have steady state stability\"\n", + " elif dTl_dw[i] > dT_dw[i]:\n", + " print \"This operating point has steady state stability\" \n", + " print\"\\nANSWER: Thus,wm=\",round(W[i],3),\"rad/sec\"\n", + " \n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "w= 1.47 or 0.068 rad/sec\n", + "At,w= 1.472 rad/s\n", + "This operating point does not have steady state stability\n", + "At,w= 0.068 rad/s\n", + "This operating point has steady state stability\n", + "\n", + "ANSWER: Thus,wm= 0.068 rad/sec\n" + ] + } + ], + "prompt_number": 16 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example no:3.12,Page no:42" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import numpy as np\n", + "from scipy.optimize import fsolve\n", + "\n", + "\n", + "#Variable declaration\n", + "#T=15-0.5*omega_m\n", + "#TL=0.5*omega_m**2\n", + "def T(w):\n", + " return(15-0.5*w)\n", + "def Tl(w):\n", + " return(0.5*w**2)\n", + "\n", + " \n", + "#Calculation\n", + "P=[1,1,-30] #Polynomial for omega_m calculated by equating T=TL\n", + "omega_m=np.roots(P) #Angular velctiy rad/sec\n", + "coeff = [1,1,-30]\n", + "W=np.roots(coeff)\n", + "dT_dw=range(2)\n", + "dTl_dw=range(2)\n", + "for i in range(0,2):\n", + " dT_dw[i]=scipy.misc.derivative(T,W[i],dx=1e-6)\n", + " dTl_dw[i]=scipy.misc.derivative(Tl,W[i], dx=1e-6)\n", + "\n", + "#Result \n", + "print\"w=\",round(W[0],2),\"or\",round(W[1],3),\"rad/sec\"\n", + "for i in range(0,2): \n", + " print\"At,w=\",round(W[i],3),\"rad/s\"\n", + " if dTl_dw[i] < dT_dw[i]:\n", + " print \"This operating point does not have steady state stability\"\n", + " elif dTl_dw[i] > dT_dw[i]:\n", + " print \"This operating point has steady state stability\" \n", + " print\"\\nANSWER: Thus,wm=\",round(W[i],3),\"rad/sec\"\n", + "\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "w= -6.0 or 5.0 rad/sec\n", + "At,w= -6.0 rad/s\n", + "This operating point does not have steady state stability\n", + "At,w= 5.0 rad/s\n", + "This operating point has steady state stability\n", + "\n", + "ANSWER: Thus,wm= 5.0 rad/sec\n" + ] + } + ], + "prompt_number": 19 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Fundamentals_of_Electric_Drives_and_Control/Chapter_4.ipynb b/Fundamentals_of_Electric_Drives_and_Control/Chapter_4.ipynb new file mode 100644 index 00000000..e3ec0b71 --- /dev/null +++ b/Fundamentals_of_Electric_Drives_and_Control/Chapter_4.ipynb @@ -0,0 +1,622 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 4:Selection of Motor Power Rating" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.1,Page no:49" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "from scipy.optimize import fsolve\n", + "#Variable declaration\n", + "P=30.0 #[Power KW\n", + "theta1=30.0 #Temperature degree C\n", + "t1=40.0 # time in min\n", + "theta2=45.0 #Final temperature in degree C\n", + "\n", + "#Calculation\n", + "t2=80.0 #min(t2=2*t1)\n", + "#theta=theta_f*(1-exp(-t/T))\"\n", + "def f(T):\n", + " return((1-math.exp(-80.0/T))/(1-math.exp(-40/T))-(theta2/theta1))\n", + "T=fsolve(f,1)\n", + "theta_f=theta1/(1.0-math.exp(-t1/T)) #degreeC\n", + "#Result\n", + "print\"(a).Thermal time constant: \",round(T[0],2),\"minutes\"\n", + "print\"(b).Final temperature rise: \",theta_f,\"degrees\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + " (a).Thermal time constant: 57.71 minutes\n", + "(b).Final temperature rise: 60.0 degrees\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.2,Page no:50" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "#Variable declaration\n", + "P=30.0 #Power in KW\n", + "theta1=20.0 #Temerature degree C\n", + "t1=30.0 #Time in min\n", + "theta2=30.0 #Temperature in degree C\n", + "t2=60.0 #Final time innmin(t2=2*t1)\n", + "\n", + "#Calculation\n", + "#Let exp(-t1/T)=x then exp(-t2/T)=x**2\n", + "#theta1/theta2=(1-x)/(1-x**2)\n", + "#x**2*theta1-x*theta2+theta2-theta1=0\n", + "def f(T):\n", + " return(((1-math.exp(-t2/T))/(1-math.exp(-t1/T)))-theta2/theta1)\n", + "T=fsolve(f,1)\n", + "theta_f=theta1/(1-math.exp(-t1/T)) #degreeC\n", + "\n", + "#Result\n", + "print\"Thermal time constant : \",round(T[0],2),\"minutes\"\n", + "print\"Final temperature rise : \",theta_f,\"C\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + " Thermal time constant : 43.28 minutes\n", + "Final temperature rise : 40.0 C\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.3,Page no:51" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "#Variable declaration\n", + "T_ambient=30 #Ambient tmeperature in dgree C\n", + "P=30.0 #Power in KW\n", + "theta1=54.0-T_ambient #Temperature durin g full load operation degree C\n", + "t1=1.0 #Time in hour\n", + "theta2=67.0-T_ambient #Temperature in degree C\n", + "t2=2.0 #Time in hour(t2=2*t1)\n", + "\n", + "#Calculation\n", + "def f(T):\n", + " return(((1-math.exp(-2/T))/(1-math.exp(-1/T)))-theta2/theta1)\n", + "T=fsolve(f,1)\n", + "theta_f=theta1/(1-math.exp(-t1/T)) #degreeC\n", + "theta_steady=theta_f+30 #degreeC\n", + "\n", + "#Result\n", + "print\"(a) Final steady state temperature : \",round(theta_steady,2),\"C\"\n", + "print\"(b) Heating time constant :\",round(T[0],2),\"hour\"\n", + "theta2=theta_f #degree C\n", + "t=2.7 #hour\n", + "theta=40-30 #degree C\n", + "Tdash=-t/math.log(theta/theta2) #hour\n", + "print\"(c) Cooling time constant: \",round(Tdash,2),\"hour\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + " (a) Final steady state temperature : 82.36 C\n", + "(b) Heating time constant : 1.63 hour\n", + "(c) Cooling time constant: 1.63 hour\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.4,Page no:52" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "#Variable declaration\n", + "T=110.0 #Time in min\n", + "Tdash=150.0 #Final time in min\n", + "t=30.0 #Run time of motor min\n", + "tdash=45.0 #Switch off time in min\n", + "theta_f=50.0 #final temperature rise in degree C\n", + "\n", + "#Calculation\n", + "#theta=theta_f-(theta_f-theta1)*exp(-t/T)\n", + "#theta1=theta*exp(-tdash/Tdash) \n", + "theta=(theta_f-theta_f*math.exp(-t/T))/(1-math.exp(-tdash/Tdash)*math.exp(-t/T)) #degreeC\n", + "\n", + "#Result\n", + "print\"Maximum temperature rise of the motor: \",round(theta,2),\"C\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Maximum temperature rise of the motor: 27.37 C\n" + ] + } + ], + "prompt_number": 13 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.5,Page no:52" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "#Variable declaration\n", + "theta1=20.0 #Initial temperature in degreeC\n", + "theta2=28.0 #Final temperature in degreeC\n", + "dthetaBYdt1=0.08 #Rate of temp rise in degreeC/min\n", + "dthetaBYdt2=0.06 #Rate of temp rise in degreeC/min\n", + "\n", + "#Calculation\n", + "#theta=theta_f-(theta_f-theta1)*exp(-t/T)\n", + "#dtheta/dt=(theta_f-theta)/T\n", + "#dthetaBYdt1/dthetaBYdt2=(theta_f-theta1)/(theta_f-theta2)\n", + "theta_f=(theta2*dthetaBYdt1-theta1*dthetaBYdt2)/(dthetaBYdt1-dthetaBYdt2)\n", + "T=(theta_f-theta1)/dthetaBYdt1 #min\n", + "\n", + "#Result\n", + "print\"Final temperature rise,theta_f= : \",theta_f,\"C\"\n", + "print\"Heating time constant: \",T,\"minutes\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Final temperature rise,theta_f= : 52.0 C\n", + "Heating time constant: 400.0 minutes\n" + ] + } + ], + "prompt_number": 14 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.6,Page no:59" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "#Variable declaration\n", + "cycle1=50.0 #Duty cycle hp\n", + "t1=20.0 #Time in sec\n", + "cycle2=100.0 #Duty cycle in hp\n", + "t2=20.0 #Time in sec\n", + "cycle3=150.0 #3rd duty cycle in hp\n", + "t3=10.0 #time sec\n", + "cycle4=120.0 #4th duty cyclein hp\n", + "t4=20.0 #time sec\n", + "cycle5=0.0 #th duty cycle in hp\n", + "t5=15.0 #sec\n", + "\n", + "#Calculation\n", + "hp_rms=math.sqrt((cycle1**2*t1+cycle2**2*t2+cycle3**2*t3+cycle4**2*t4+cycle5**2*t5)/(t1+t2+t3+t4+t5)) #hp\n", + "\n", + "#Result\n", + "print\"hp(rms) for the motor : \",round(hp_rms,2),\"hp\"\n", + "print\"We should choose 100hp motor.\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "hp(rms) for the motor : 94.74 hp\n", + "We should choose 100hp motor.\n" + ] + } + ], + "prompt_number": 15 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.7,Page no:61" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "#Variable declaration\n", + "t_on=15.0 #Time for full load [min]\n", + "t_off=25.0 #time for off load in [min]\n", + "T=100.0 #Heating time constant in [min]\n", + "Tdash=140.0 #Cooling time constant in [min]\n", + "theta_f=55.0 #Continuous full load operation time in [degree C]\n", + "\n", + "#Calculation\n", + "#theta=theta_f-(theta_f-theta1)*exp(-t/T)\n", + "#theta1=theta*exp(-tdash/Tdash) \n", + "theta_max=theta_f*(1-math.exp(-t_on/T))/(1-math.exp(-(t_off/Tdash+t_on/T))) #degreeC\n", + "\n", + "#Result\n", + "print\"Maximum temperature rise: \",round(theta_max,2),\"C\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Maximum temperature rise: 27.36 C\n" + ] + } + ], + "prompt_number": 17 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.8,Page no:62" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "\n", + "#Variable declaration\n", + "Rating=100.0 #Rating in KW\n", + "alfa=0.9 #Ratio rating unitless\n", + "ts=20.0 #Running time in min\n", + "T=100.0 #Heating time constant in min\n", + "\n", + "#Calculation\n", + "S=math.sqrt((1.0+alfa)/(1.0-math.exp(-ts/T))) \n", + "ShortTimeRating=S*Rating #KW\n", + "\n", + "#Result\n", + "print\"Short time rating: \",round(ShortTimeRating,1),\"kW\"\n", + "print\"NOTE:Answer is wrong in the textbook.\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Short time rating: 323.8 kW\n", + "NOTE:Answer is wrong in the textbook.\n" + ] + } + ], + "prompt_number": 18 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.9,Page no:62" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "#Variable declaration\n", + "T=80.0 #Heating time constant in min\n", + "Tdash=110.0 #cooling time constant in min\n", + "Rating=50.0 #Full load rating in [KW]\n", + "ts=15.0 #Runt time in [min]\n", + "\n", + "#Calculation\n", + "S=math.sqrt(1.0/(1.0-math.exp(-ts/T))) \n", + "ShortTimeRating=S*Rating #KW\n", + "t_off=20.0 #min\n", + "S=math.sqrt((1.0-math.exp(-(ts/T+t_off/Tdash)))/(1.0-math.exp(-(ts/T))))\n", + "DutyRating=S*Rating #KW\n", + "\n", + "#Result\n", + "print\"(a) Short time rating of motor: \",round(ShortTimeRating,1),\"kW\"\n", + "print\"(b) Intermittent periodic duty rating: \",round(DutyRating,2),\"kW\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Short time rating of motor: 120.9 kW\n", + "(b) Intermittent periodic duty rating: 67.2 kW\n" + ] + } + ], + "prompt_number": 20 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.10,Page no:63" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "#Variable declaration\n", + "T=90.0 #Heating time constant in [min]\n", + "t=25.0 #time in min \n", + "ShortTimeRating=50.0 #Short time rating in KW\n", + "Eff=80/100.0 #Efficiency\n", + "\n", + "#Calculation\n", + "#Let full load rating is P KW and Losses=Pc\n", + "#CuLoss=(P/(P*Eff))**2 & alfa=Pc/CuLoss\n", + "alfa=(Eff)**2 #unitless\n", + "S=math.sqrt(((1.0+alfa)/(1.0-math.exp(-t/T))-alfa)) \n", + "ContinuousRating_fl=ShortTimeRating/S #KW\n", + "\n", + "#Result\n", + "print\"Full load continuous rating: \",round(ContinuousRating_fl,1),\"kW\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Full load continuous rating: 20.2 kW\n" + ] + } + ], + "prompt_number": 22 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.11,Page no:63" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "#Variable declaration\n", + "Rating=25.0 #Rating in [KW]\n", + "T=90.0 #Heating time constant in min\n", + "ts=30.0 #time in min\n", + "\n", + "#Calculation\n", + "S=math.sqrt(1.0/(1.0-math.exp(-ts/T))) \n", + "HalfHourRating=S*Rating #KW\n", + "\n", + "#Result\n", + "print\"Half hour rating of motor: \",round(HalfHourRating,2),\"kW\"\n", + "print\"Answer wrong in textbook.\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Half hour rating of motor: 46.96 kW\n", + "Answer wrong in textbook.\n" + ] + } + ], + "prompt_number": 23 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.12,Page no:63" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration:\n", + "ts=20 #rating itme in [min]\n", + "W=300 #rating in [W]\n", + "T=60 #time constant in [minutes]\n", + "max_eff_load=0.8 #Maximum effeciency of motor at load\n", + "\n", + "#Calculations\n", + "import sympy\n", + "P=sympy.Symbol('P')\n", + "pc=sympy.Symbol('pc')\n", + "Full_load_CL=(P/(0.8*P))**2*pc\n", + "alpha=pc/Full_load_CL\n", + "S=math.sqrt((1.0+alpha)/(1-math.exp(-ts/64.0))-alpha)\n", + "Cont_rating=W/round(S,1)\n", + "\n", + "#Result\n", + "print\"Continuous rating of motor is :\",round(Cont_rating,1),\"W\"\n", + "print\"NOTE:There is a slight error in book in calculation of S,approximate value is taken\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Continuous rating of motor is : 130.4 W\n", + "NOTE:There is a slight error in book in calculation of S,approximate value is taken\n" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Continuous rating of motor is : 130.4 W\n", + "NOTE:There is a slight error in book in calculation of S,approximate value is taken\n" + ] + } + ], + "prompt_number": 25 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.13,Page no:67" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "#Variable declaration\n", + "P=6.0 #poles\n", + "f=50.0 #Frequency in [Hz]\n", + "MoI=9.5 #Moment of inertia in [Kg-m**2]\n", + "Tr=550.0 #Torque in [N-m]\n", + "S=5.0/100.0 #Slip\n", + "Tmax=720.0 #MAximum torque in [N-m]\n", + "T_LH=1020.0 #Torque requirement in [N-m]\n", + "th=12.0 #Time in [sec]\n", + "Tmin=220.0 #Light torque req in [N-m]\n", + "Snl=3.0/100.0 #No load slip\n", + "Ns=120.0*f/P #Speed in rpm\n", + "\n", + "#Calculation\n", + "Nnl=Ns-Ns*Snl #rpm\n", + "Nrated=Ns-Ns*S #rpm\n", + "omega_mo=Nnl*2.0*math.pi/60.0 #rad/s\n", + "omega_mr=Nrated*2.0*math.pi/60.0 #rad/s\n", + "J=(Tr/(omega_mo-omega_mr))*(th/math.log((T_LH-Tmin)/(T_LH-Tmax))) #Kg-m**2\n", + "MoI_flywheel=J-MoI #Kg-m**2\n", + "\n", + "#Result\n", + "print\"Moment of inertia of flywheel : \",MoI_flywheel,\"kg-m^2\"\n", + "print\"NOTE:Answer in the book is wrong.\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Moment of inertia of flywheel : 3203.36081501 kg-m^2\n", + "NOTE:Answer in the book is wrong.\n" + ] + } + ], + "prompt_number": 26 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Fundamentals_of_Electric_Drives_and_Control/Chapter_5.ipynb b/Fundamentals_of_Electric_Drives_and_Control/Chapter_5.ipynb new file mode 100644 index 00000000..612b0c1e --- /dev/null +++ b/Fundamentals_of_Electric_Drives_and_Control/Chapter_5.ipynb @@ -0,0 +1,2202 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 5:DC Motor Drives" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.1 ,Page no:75" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "\n", + "#Variable declaration\n", + "T=10.0 #[turns]\n", + "Coil=144.0 #[no. of coils]\n", + "R=0.011 #[Resitance] ohm\n", + "fi=0.05 #Wb(flux per pole)\n", + "N=200.0 #[Speed] rpm\n", + "par_paths=2.0 #[Parallel paths] for wave winding\n", + "\n", + "#Calculation\n", + "T_path=Coil*T/par_paths #no. of turns in each parallel path\n", + "R_path=R*T_path #ohm\n", + "Ra=R_path/par_paths #ohm(armature resistance)\n", + "p=12.0 #poles\n", + "emf=par_paths*Coil*T*p*fi*N/60.0/2.0 #V\n", + "R1=1000.0 #ohm\n", + "IL=emf/R1 #A\n", + "Ia=IL #A\n", + "T=par_paths*Coil*T*p*fi*Ia/2.0/math.pi/par_paths #N-m\n", + "\n", + "#Result\n", + "print\"(a) Armature resistance : \",Ra,\"ohm\"\n", + "print\"(b) Torque: \",round(T,2),\"N-m\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Armature resistance : 3.96 ohm\n", + "(b) Torque: 396.03 N-m\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.2 ,Page no:75" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "Ia=110.0 #[Armature current] A\n", + "V=480.0 #[Volatge] volt\n", + "Ra=0.2 #[Resistance] ohm\n", + "p=6.0 #[poles]\n", + "C=864.0 #No of conductors\n", + "fi=0.05 #Wb[(flux per pole)]\n", + "\n", + "#Calculation\n", + "back_emf=V-(Ia*Ra) #Volt\n", + "N=back_emf*60.0*p/C/p/fi #rpm\n", + "T=C*p*fi*Ia/2.0/math.pi/p #N-m\n", + "\n", + "#Result\n", + "print\"Speed : \",round(N,1),\"rpm\"\n", + "print\"Torque: \",round(T,1),\"N-m\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Speed : 636.1 rpm\n", + "Torque: 756.3 N-m\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.3 ,Page no:79" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "Ia=100.0 #[Current] A\n", + "V=200.0 #[Voltage] volt\n", + "N=600.0 #[Speed] rpm\n", + "Ra=0.05 #[Resistance] ohm\n", + "Eff=85.0/100.0 # [Efficiency]\n", + "\n", + "#Calculation\n", + "Ia1=Ia*Eff #armature current in separately excited dc motor\n", + "emf=V-Ia*Ra #V(motoring mode induced emf)\n", + "N1=500.0 #rpm(generating mode speed)\n", + "Gen_emf=emf*N1/N #V\n", + "Vo=round(Gen_emf)-Ia1*Ra #V\n", + "\n", + "#Result\n", + "print\"Voltage of source : \",Vo,\"V\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Voltage of source : 158.75 V\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.4 ,Page no:79" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "Ia1=10.0 #[Current] A\n", + "V1=200.0 #[Voltage] volt\n", + "N1=1800.0 #[Speed] rpm\n", + "Ra=0.6 #[Resistance] ohm\n", + "Rfield=360.0 #[Field resistance] ohm\n", + "V2=180.0 #[Voltage] volt\n", + "I_line=20.0 #[Limit line surrent] A\n", + "\n", + "#Calculation\n", + "#fi2=V2/V1*fi1\n", + "fi2BYfi1=V2/V1 \n", + "#Ia1*fi1=Ia2*fi2\n", + "Ia2=Ia1/fi2BYfi1 #A\n", + "Eb1=V1-Ia1*Ra #V\n", + "Eb2=V2-Ia2*Ra #V\n", + "#Eb1/Eb2=fi1*N1/fi2/N2\n", + "N2=N1/(Eb1/Eb2*fi2BYfi1) #rpm\n", + "Ifield=V2/Rfield #A\n", + "Ia=I_line-Ifield\n", + "#V2=Ia*(R+Ra)\n", + "R=V2/Ia-Ra #ohm\n", + "\n", + "#Result\n", + "print\"(a) Motor speed after supply voltage decreases : \",round(N2,2),\"rpm\"\n", + "print\"(b) Additional resistance is: \",round(R,2),\"ohm\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Motor speed after supply voltage decreases : 1786.94 rpm\n", + "(b) Additional resistance is: 8.63 ohm\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.5 ,Page no:80" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "Ia1=10.0 #A\n", + "V1=200.0 #[Supply voltage] volt\n", + "N1=1800.0 #[Motor speed] rpm\n", + "Ra=0.6 #[Resistance] ohm\n", + "Rfield=360.0 #[Field resistace] ohm\n", + "V2=180.0 #[Voltage] volt\n", + "I_line=20.0 #[Limit line current] A\n", + "\n", + "#Calculation\n", + "Ia=Ia1-V1/Rfield #A(At changeover time)\n", + "emf=V1-Ia*Ra #volt\n", + "Ifield=emf/Rfield #A(At changeover time)\n", + "Iout=Ia1-Ifield #A\n", + "Rbraking=emf/Iout #ohm(Braking Resistance)\n", + "\n", + "#Result\n", + "print\"Braking resistance : \",round(Rbraking,3),\"ohm\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Braking resistance : 20.542 ohm\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.6 ,Page no:80" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "from scipy import integrate\n", + "import math \n", + "#Variable declaration\n", + "Ia1=10.0 #[Current] A\n", + "V1=200.0 #[Voltage] volt \n", + "N1=1800.0 #[Motor speed] rpm\n", + "Ra=0.6 #[Resistance] ohm\n", + "Rfield=360.0 #[Field resistnce] ohm\n", + "V2=180.0 #[VOltage] volt\n", + "I_line=20.0 #[Limit line current] A\n", + "\n", + "#Calculation\n", + "#Part (a)\n", + "Ia=Ia1-V1/Rfield #A(At changeover time)\n", + "emf=V1-Ia*Ra #volt\n", + "Ifield=emf/Rfield #A(At changeover time)\n", + "Iout=Ia1-Ifield #A\n", + "Rbraking=emf/Iout #ohm(Braking Resistance)\n", + "I_initial=Iout #A(Inotial current)\n", + "t=30.0 #sec(time taken to stop)\n", + "I_change_rate=I_initial/t #A/s\n", + "#i=I_initial-I_change_rate*t , for 0" + ] + }, + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Resistance for dynamic braking : 9.17 ohm\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.10 ,Page no:86" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + " \n", + "import math \n", + "#Variable declaration\n", + "V=240.0 #[DC voltage] V\n", + "Ra=0.4 #[Resistnce] ohm\n", + "N1=600.0 #[Motor speed] rpm\n", + "Ifl=25.0 #[Full load current] A\n", + "Radd=1.0 #[Added resistance] ohm\n", + "#If1=If2\n", + "#T1=T2 leads to If1*Ia1=If2*Ia2: Ia1=Ia2\n", + "Ia1=25.0 #A\n", + "Ia2=25.0 #A\n", + "\n", + "#Calculation\n", + "Eb1=V-Ia1*Ra #V\n", + "Eb2=V-Ia2*(Ra+Radd) #V\n", + "N2=N1*Eb2/Eb1 #rpm\n", + "#T3=2*T1\n", + "#If3=If1\n", + "Ia3=2*Ia1 #A\n", + "Eb3=V-Ia3*(Ra+Radd) #V\n", + "N3=N1*Eb3/Eb1 #rpm\n", + "Eb4=0.0 #V(at speed zero Eb=0)\n", + "Ia4=V/(Ra+Radd) #V\n", + "T4ByT1=Ia4/Ia1 #(field constant)\n", + "\n", + "#Result\n", + "print\"(a). Speed at full load torque in rpm : \",round(N2,2),\"rpm\"\n", + "print\"(b) Speed at twice the full load torque : \",round(N3,2),\"rpm\"\n", + "print\"(c) Stalling torque is \",round(T4ByT1,3),\" times of full load torque.\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a). Speed at full load torque in rpm : 534.78 rpm\n", + "(b) Speed at twice the full load torque : 443.48 rpm\n", + "(c) Stalling torque is 6.857 times of full load torque.\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.11 ,Page no:87" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "V=250.0 #[Voltage] V\n", + "Ra=1.0 #[Resistance] ohm\n", + "Ia1=25.0 #[Armature current] A\n", + "N1=900.0 #Speed rpm\n", + "If=2.0 #[Filed current ] A\n", + "N2=1100.0 #[Increased speed [rpm]\n", + "\n", + "#Calculation\n", + "Eb1=V-Ia1*Ra #V\n", + "#If1*Ia1=If2*Ia2\n", + "#Eb2=V-Ia2*Ra #V\n", + "#-Ia2**2*Ra+Ia2*V-Eb1*Ia1*N2/N1=0 \n", + "polynomial=[-Ra,V,-Eb1*Ia1*N2/N1] \n", + "Ia2=roots(polynomial) #A\n", + "Ia2=Ia2[1] #A(wide range not allowed)\n", + "If2=Ia1/Ia2*If #A\n", + "\n", + "#Result\n", + "print\"New value of field current: \",round(If2,2),\"A\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "New value of field current: 1.59 A\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.12 ,Page no:110" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "V=230.0 #[Votage] V\n", + "f=50.0 #[Frequency] Hz\n", + "Rf=200.0 #[Resistance] ohm\n", + "Ra=0.3 #[Resiatnce] ohm\n", + "T=50.0 #[Load torque] N-m\n", + "N=900.0 #[Speed at load torque] rpm\n", + "Kv=0.8 #[Voltage constant] V/A-rad/s\n", + "Kt=0.8 #[Voltage constant] N-m/A**2\n", + "\n", + "from scipy import integrate \n", + "#Calculation\n", + "Vm=V*math.sqrt(2) #V\n", + "Vf=2*Vm/math.pi #V\n", + "If=Vf/Rf #A\n", + "#T=Kt*If*Ia\n", + "Ia=T/Kt/If #A\n", + "omega=N*2*math.pi/60.0 #rad/s\n", + "Eb=Kv*omega*If #V\n", + "Va=Eb+Ia*Ra #V\n", + "#Va=Vm/math.pi*(1+cosd(alfa_a))\n", + "alfa_a=math.acos(Va/Vm*math.pi-1.0) #degree\n", + "Pout=Ia*Va #W\n", + "\n", + "def f(t):\n", + " return(1)\n", + "I=integrate.quad(f,math.degrees(alfa_a),math.degrees(math.pi))\n", + "\n", + "Iin=math.sqrt(2/(2.0*180.0)*(Ia**2)*I[0]) \n", + "VAin=V*Iin #VA\n", + "pf_in=Pout/VAin #lagging\n", + "\n", + "#Result\n", + "print\"(a) Field current:\",If,\"A\"\n", + "print\"(b) Fringe angle of converter in degree : \",round(math.degrees(alfa_a),3),\"degree\"\n", + "print\"(c) Power factor of convertyer(lagging) : \",round(pf_in,3)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Field current: 1.03536376358 A\n", + "(b) Fringe angle of converter in degree : 94.078 degree\n", + "(c) Power factor of convertyer(lagging) : 0.605\n" + ] + } + ], + "prompt_number": 12 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.13 ,Page no:111" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "V=230.0 #[Voltage] V\n", + "f=50.0 #[Frequency] Hz\n", + "Rf=200.0 #[Resistance] ohm\n", + "Ra=0.25#[Armature resistance] ohm\n", + "Kv=1.1 #[Torque constant] V/A-rad/s\n", + "Kt=1.1 #[Voltage constant] N-m/A**2\n", + "alfa_a=45.0 #[Firing angle] degree\n", + "Ia=50.0 #[Armature current] A\n", + "alfa_f=0.0 \n", + "\n", + "#Calculation\n", + "Vf=2*V*math.sqrt(2.0)/math.pi*math.cos(alfa_f) #V\n", + "#Va=(2*230.0*math.sqrt(2.0)/math.pi)*math.cos(alfa_a) #V\n", + "Va=(2.0*V/math.pi)\n", + "If=Vf/Rf #A\n", + "T=Kt*Ia*If #N-m\n", + "Eb=Va-Ia*Ra-2.0 #V\n", + "omega=Eb/Kv/If #rad/s\n", + "N=omega*60.0/(2.0*math.pi) #rpm\n", + "\n", + "#Result\n", + "print\"Torque developed : \",round(T,3),\"N-m\"\n", + "print\"Motor speed in rpm : \",round(N,1),\"rpm \"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Torque developed : 56.945 N-m\n", + "Motor speed in rpm : 1106.1 rpm \n" + ] + } + ], + "prompt_number": 13 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.14 ,Page no:111" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "\n", + "V=400 #[Voltage] V\n", + "Ra=0.3#Resiatnce armature inohm\n", + "Rf=250 #Filed resisatnce in ohm\n", + "Ia=50 #Armature current in A\n", + "Kv=1.3 #Voltage constantV/A-rad/s\n", + "N=1200 #Speed in rpm\n", + "alfa_f=0 \n", + "\n", + "#Calculation\n", + "Vf=3*math.sqrt(3)*V*math.sqrt(2)/math.sqrt(3)/math.pi*math.cos(alfa_f) #V\n", + "If=Vf/Rf #A\n", + "Eb=Kv*If*2*math.pi*N/60 #V\n", + "Va=Eb+Ia*Ra #V\n", + "alfa_a=math.acos(Va/3/math.sqrt(3)/V/math.sqrt(2)*math.sqrt(3)*math.pi) #degree\n", + "\n", + "#Result\n", + "print\"Fringe angle of converter in degree : \",round(math.degrees(alfa_a),2),\"degree\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Fringe angle of converter in degree : 47.06 degree\n" + ] + } + ], + "prompt_number": 14 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.15 ,Page no:112" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "\n", + "#Variable declaration\n", + "V=500.0 #V [Voltage]\n", + "Ia=200.0 # [Armature Current] A\n", + "Ra=0.1#ohm[Armature resistance]\n", + "Kv=1.4 #[Voltage constant] V/A-rad/s\n", + "Kt=1.4 #[torque constant] N-m/A**2\n", + "If=2.0 #[Field current] A\n", + "cycle=0.5 #[Duty cycle of chopper] sec\n", + "\n", + "#Calculation\n", + "Pin=cycle*V*Ia/1000.0 #KW\n", + "Va=cycle*V #V\n", + "Eb=Va-Ia*Ra #V\n", + "omega=Eb/Kv/2.0 #rad/s\n", + "N=omega*60.0/2.0/math.pi #rpm\n", + "T=Kt*2.0*Ia #N-m\n", + "\n", + "#Result\n", + "print\"(a) Input power in KW : \",Pin,\"kW\"\n", + "print\"(b) Speed in rpm : \",round(N,1),\"rpm\"\n", + "print\"(c) Torque in N-m : \",T,\"N-m\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Input power in KW : 50.0 kW\n", + "(b) Speed in rpm : 784.4 rpm\n", + "(c) Torque in N-m : 560.0 N-m\n" + ] + } + ], + "prompt_number": 15 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.16 ,Page no:112" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "Ra=0.1#[Resistance] ohm\n", + "Rb=7.5#[Braking resistance] ohm\n", + "Kv=1.4 #[Volate constant] V/A-rad/s\n", + "Ia=120.0 #[Armature current] A\n", + "If=1.6 #[Filed current] A\n", + "cycle=0.35 #[Duty cycle of chopper] sec\n", + "\n", + "#Calculation\n", + "Vavg=Rb*Ia*(1.0-cycle) #V\n", + "Pb=Ia**2*Rb*(1.0-cycle)**2 #W\n", + "emf=Vavg+Ra*Ia #V\n", + "omega=emf/Kv/If #rad/s\n", + "N=omega*60.0/2.0/math.pi #rpm\n", + "\n", + "#Result\n", + "print\"Average voltage across chopper : \",Vavg,\"V\"\n", + "print\"Power dissipated: \",Pb,\"W\"\n", + "print\"Speed : \",round(N),\"rpm\" \n", + "print \"NOTE:Answer of Pb & speed is wrong in the book.\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Average voltage across chopper : 585.0 V\n", + "Power dissipated: 45630.0 W\n", + "Speed : 2545.0 rpm\n", + "NOTE:Answer of Pb & speed is wrong in the book.\n" + ] + } + ], + "prompt_number": 16 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.17 ,Page no:113" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "%pylab inline\n", + "#Variable declaration\n", + "V=220.0 #[Voltage] V\n", + "f=50.0 #[Frequency] Hz\n", + "L=0.012 #[Inductance] H\n", + "Ra=0.72 #[Resistance] ohm\n", + "K=2.0 #[Armature constant] V/rad/s\n", + "T=60.0 #[Torque characterisitc] N-m\n", + "alfa=90.0 #degree\n", + "\n", + "#Calculation\n", + "Va=(3.0*math.sqrt(3.0)*V*math.sqrt(2.0)/(2.0*math.pi))*(1.0) #V\n", + "Ia=5.0 #A\n", + "print\"Armature Current : \",Ia,\"A\"\n", + "T1=Ia*K #N-m\n", + "print\"Torque : \",T1,\"N-m\"\n", + "Eb=Va-Ia*Ra #V\n", + "omega=Eb/K #rad/s\n", + "N1=omega*60.0/2.0/math.pi #rpm\n", + "print\"Speed :\",N1,\"rpm\"\n", + "\n", + "Ia=10.0 #A\n", + "print\"Armature Current : \",Ia,\"A\"\n", + "T2=Ia*K #N-m\n", + "print\"Torque : \",T2,\"N-m\"\n", + "Eb=Va-Ia*Ra #V\n", + "omega=Eb/K #rad/s\n", + "N2=omega*60.0/(2.0*math.pi) #rpm\n", + "print\"Speed : \",N2,\"rpm\" \n", + "Ia=20.0 #A\n", + "print\"Armature Current: \",Ia,\"A\"\n", + "T3=Ia*K #N-m\n", + "print\"Torque in N-m : \",T3,\"N-m\"\n", + "Eb=Va-Ia*Ra #V\n", + "omega=Eb/K #rad/s\n", + "N3=omega*60.0/2.0/math.pi #rpm\n", + "print\"Speed in rpm : \",N3,\"rpm\"\n", + "Ia=30.0 #A\n", + "print\"Armature Current : \",Ia,\"A\"\n", + "T4=Ia*K #N-m\n", + "print\"Torque: \",T4,\"N-m\"\n", + "Eb=Va-Ia*Ra #V\n", + "omega=Eb/K #rad/s\n", + "N4=omega*60.0/2.0/math.pi #rpm\n", + "print\"Speed : \",T4,\"rpm\"\n", + "plot([T1,T2,T3,T4],[N1,N2,N3,N4]) \n", + "title('Speed Torque Characteristics') \n", + "xlabel('Torque(N-m)') \n", + "ylabel('speed(RPM)') \n", + "plt.ylim(0.0,1500.0)\n", + "plt.xlim(0.0,60.0)\n", + "plt.show()" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n", + "Armature Current : 5.0 A\n", + "Torque : 10.0 N-m\n", + "Speed : 1211.32800644 rpm\n", + "Armature Current : 10.0 A\n", + "Torque : 20.0 N-m\n", + "Speed : 1194.13927258 rpm\n", + "Armature Current: 20.0 A\n", + "Torque in N-m : 40.0 N-m\n", + "Speed in rpm : 1159.76180487 rpm\n", + "Armature Current : 30.0 A\n", + "Torque: 60.0 N-m\n", + "Speed : 60.0 rpm\n" + ] + }, + { + "output_type": "stream", + "stream": "stderr", + "text": [ + "WARNING: pylab import has clobbered these variables: ['f']\n", + "`%pylab --no-import-all` prevents importing * from pylab and numpy\n" + ] + }, + { + "metadata": {}, + "output_type": "display_data", + "png": "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEZCAYAAABrUHmEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nEQAAAABJRU5ErkJggg==\n", + "text": [ + "" + ] + } + ], + "prompt_number": 17 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.18 ,Page no:114" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "V=400.0 #[Thyrisotr bridge voltage] V\n", + "f=50.0 #[Frequency] Hz\n", + "I=50.0 #[Rated current] A\n", + "Ra=0.1 #[Resustnce] ohm\n", + "K=0.3 #[Voltage constant] V/rpm\n", + "Ia=5.0 #[Currentarmature] A\n", + "alfa=30.0 #[Firing angle] degree\n", + "\n", + "#Calculation\n", + "Vavg=(3.0*math.sqrt(3)*V*math.sqrt(2)/(math.sqrt(3)*2.0*math.pi))*(1+math.cos(math.radians(alfa))) #V\n", + "Eb=Vavg-Ia*Ra #V\n", + "N=Eb/K #rpm\n", + "Speed=1600.0 #rpm\n", + "Eb=Speed*K #V\n", + "Vin=Eb+I*Ra #V\n", + "alfa=math.acos(Vin/3/math.sqrt(3)/V/math.sqrt(2)*math.sqrt(3)*2*math.pi-1.0) #degree\n", + "\n", + "#Result\n", + "print\"No load speed : \",round(N),\"rpm\"\n", + "print\"Fringe angle : \",round(math.degrees(alfa),2),\"degree\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "No load speed : 1678.0 rpm\n", + "Fringe angle : 37.28 degree\n" + ] + } + ], + "prompt_number": 18 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.19 ,Page no:114" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "V=230.0 #[Voltage] V\n", + "f=50.0 #[Frequency] Hz\n", + "Rf=200.0 #[Feild resistance] ohm\n", + "Ra=0.25#[Armature resistance] ohm\n", + "Kv=1.1 #[Volatge constant] V/A-rad/s\n", + "Kt=1.1 #[Torque constant] N-m/A**2\n", + "alfa_a=45.0 #[Firng angle] degree\n", + "Ia=50.0 #[armature current] A\n", + "alfa_f=0.0 #Final angle\n", + "\n", + "#Calculation\n", + "Vf=2.0*V*math.sqrt(2.0)/math.pi*math.cos(math.radians(alfa_f)) #V\n", + "Va=2.0*V*math.sqrt(2.0)/math.pi*math.cos(math.radians(alfa_a)) #V\n", + "If=Vf/Rf #A\n", + "T=Kt*Ia*If #N-m\n", + "Eb=Va-Ia*Ra-2.0 #V\n", + "omega=Eb/Kv/If #rad/s\n", + "Eg=-Eb #V\n", + "Va=Eg+Ia*Ra+2 #V\n", + "alfa=math.acos(Va/2.0/V/math.sqrt(2.0)*math.pi) #degree\n", + "\n", + "P=abs(Va)*Ia #W(power fed back to source)\n", + "\n", + "#Result\n", + "print\"Fringe angle to converter : \",round(math.degrees(alfa),2),\"degree\"\n", + "print\"Power fed back to source : \",round(P),\"W (approx)\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Fringe angle to converter : 124.55 degree\n", + "Power fed back to source : 5871.0 W (approx)\n" + ] + } + ], + "prompt_number": 19 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.20 ,Page no:115" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "V=240.0 #[Voltage] V\n", + "alfa=100.0 #degree [Firing angle] \n", + "Ra=6.0# [Armature resistanec] ohm\n", + "Ia=1.8 #[Armature current] A\n", + "\n", + "#Calculation\n", + "Vm=V*math.sqrt(2.0) #V\n", + "Vdc=Vm/math.pi*(1.0+math.cos(math.radians(alfa))) #Volt\n", + "Eb=Vdc-Ia*Ra #V\n", + "\n", + "#Result\n", + "print\"Back emf : \",round(Eb,2),\"V\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Back emf : 78.48 V\n" + ] + } + ], + "prompt_number": 20 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.21 ,Page no:115" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "V1=230.0 #[Voltage] V\n", + "N1=1500.0 #[Speed] rpm\n", + "Ra=1.0 #[Armature resistance] ohm\n", + "Ia=10.0 #[Armature current] A\n", + "T=5.0 #[Troque] N-m\n", + "#V=K*omega+Ia*Ra\n", + "\n", + "#Calculation\n", + "K=V1/(N1*2*math.pi/60.0+Ia*Ra) #V-s/rad or N-m/A\n", + "K=round(K,1)\n", + "Ia=T/K #A\n", + "Ia=round(Ia,2)\n", + "alfa1=30.0 #degree\n", + "V=(2*V1*math.sqrt(2)/math.pi)*math.cos(math.radians(alfa1)) #Volt\n", + "V=round(V,1)\n", + "omega=(V-Ia*Ra)/K #rad/s\n", + "\n", + "N=(omega*60.0)/(2.0*math.pi) #rpm\n", + "print\"Parrt(a) Speed:\",N,\"rpm\"\n", + "alfa=45.0 #degree\n", + "N=950.0 #rpm\n", + "V=(2*V1*math.sqrt(2)/math.pi)*math.cos(math.radians(alfa)) #Volt\n", + "V=round(V,2)\n", + "Ia=(V-K*2*math.pi/60.0*N)/Ra #A\n", + "Ia=round(Ia,2)\n", + "T=K*Ia #N-m\n", + "print\"Part(b) Torque : \",T,\"N-m\"\n", + "print\"\\nNOTE:Answer for (b) is wrong in the book.\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Parrt(a) Speed: 1198.64134927 rpm\n", + "Part(b) Torque : 9.996 N-m\n", + "\n", + "NOTE:Answer for (b) is wrong in the book.\n" + ] + } + ], + "prompt_number": 21 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.22 ,Page no:116" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "\n", + "V1=500.0 #[Voltage] V\n", + "N1=1500.0 #[Speed] rpm\n", + "Ia=100.0 #[Armature current] A\n", + "V2=350.0 #[Voltage] V\n", + "Ra=1.1 #[Resistance] ohm\n", + "alfa=45.0 #[Firing angle] degree\n", + "N2=1200.0 #[Motor speed] rpm\n", + "#V=K*omega+Ia*Ra\n", + "\n", + "#Calculation\n", + "K=(V1-Ia*Ra)/(N1*2*math.pi/60.0) #V-s/rad or N-m/A\n", + "V=3*math.sqrt(3)*V2*math.sqrt(2.0)/2.0/math.pi/math.sqrt(3.0)*(1+math.cos(math.radians(alfa))) #Volt\n", + "Ia=(V-K*N2*2*math.pi/60.0)/Ra #A\n", + "Vin_rms=Ia*math.sqrt(120.0/180.0) #V\n", + "Iavg=Ia/3.0 #A\n", + "Irms=Ia/math.sqrt(3) #A\n", + "pf_in=V*Ia/math.sqrt(3)/V2/Vin_rms #lagging\n", + "\n", + "#Result\n", + "print\"RMS source current : \",round(Ia,2),\"A\"\n", + "print\"RMS input voltage:\",round(Vin_rms,1),\"A\"\n", + "print\"Average thyristor current : \",round(Iavg,2),\"A\"\n", + "print\"RMS thyristor current : \",round(Irms,2),\"A\" \n", + "print\"Input power factor = \",round(pf_in,3),\"lagging\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "RMS source current : 83.13 A\n", + "RMS input voltage: 67.9 A\n", + "Average thyristor current : 27.71 A\n", + "RMS thyristor current : 48.0 A\n", + "Input power factor = 0.815 lagging\n" + ] + } + ], + "prompt_number": 22 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.23 ,Page no:117" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "T1=40.0 #[Torque] N-m\n", + "N1=500.0 #[Speed] rpm\n", + "J=0.01 #[Inertia of drive] N-m_sec**2/rad\n", + "T2=100.0 #[Troque] N-m\n", + "N2=1000.0 #[Speed]rpm\n", + "\n", + "#Calculation\n", + "#Te=J*d(omega)/dt+D*omega+TL\n", + "d_omegaBYdt=(T2-T1)/J #\n", + "#t=omega/d_omegaBYdt+A \n", + "omega1=N1*2*math.pi/60 #rad/s\n", + "t=0 #s(initial time)\n", + "A=t-omega1/d_omegaBYdt #\n", + "omega2=N2*2*math.pi/60 #rad/s\n", + "t=omega2/d_omegaBYdt+A #s\n", + "\n", + "#Result\n", + "print\"Time taken by the motor in sec : \",round(t,6),\"seconds\" \n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Time taken by the motor in sec : 0.008727 seconds\n" + ] + } + ], + "prompt_number": 23 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.24 ,Page no:118" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "from sympy import Symbol\n", + "#Variable declaration\n", + "f=400.0 #[Feed frequency] Hz\n", + "V=200.0 #[Voltage] V\n", + "T=30.0 #[Torque] N-m\n", + "N=1000.0 #[Speed] rpm\n", + "R=0.2 #[Resistance] ohm\n", + "L=2.0 #[Motor resistance] mH\n", + "Kv=1.5 #[Voltage constant] V-sec/rad\n", + "Kt=1.5 #[Troque constant] N-m/A\n", + "\n", + "#Calculation\n", + "Ia=T/Kt #A\n", + "omega=N*2*math.pi/60.0 #rad/s\n", + "Eb=Kv*omega #V\n", + "alfa=(Eb+Ia*R)/V \n", + "T=1.0/f*1000.0 #ms\n", + "Ton=alfa*T #ms\n", + "Toff=T-Ton #ms\n", + "Imax=V/R*((1-math.exp(-alfa*T*10**-3*R/(L*10**-3)))/(1-math.exp(-T*10**-3*R/(L*10**-3))))-Eb/R #A\n", + "\n", + "#Result\n", + "print\"(a) Maximum motor armature current : \",round(Imax,3),\"A\"\n", + "Imin=V/R*((math.exp(alfa*T*R/L)-1)/(math.exp(T*R/L)-1))-Eb/R #A\n", + "print\"(a) Minimum motor armature current : \",abs(round(Imin)),\"A\"\n", + "Iexc=Imax #A\n", + "print\"(b) Excursion of armature current : \",round(Iexc,3),\"A\"\n", + "import sympy\n", + "t_= Symbol('t`') \n", + "e=Symbol('e')\n", + "#yy=2*math.exp(-100*t_dash/2).expand()\n", + "L=L/1000\n", + "i=(round(Imax,1)*e**(-R*t_/L))\n", + "i2=round((Eb/R),1)*(1.0-e**(-R*t_/L))\n", + "print\"(c) Expression for armature current:\\n i=\", i,i2" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Maximum motor armature current : 39.078 A\n", + "(a) Minimum motor armature current : 0.0 A\n", + "(b) Excursion of armature current : 39.078 A\n", + "(c) Expression for armature current:\n", + " i= 39.1*e**(-100.0*t`) -785.4*e**(-100.0*t`) + 785.4\n" + ] + } + ], + "prompt_number": 26 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.25 ,Page no:128" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "V=230.0 #[Voltage] V\n", + "f=50.0 #[Frequency] Hz\n", + "Rf=1.5 #[Frequency] ohm\n", + "Kt=0.25 #[Torque constant] N-m/A\n", + "T=25.0 #[Torque] N-m\n", + "Kv=0.25 #[Voltage constant] V-sec/rad\n", + "\n", + "from scipy.optimize import fsolve\n", + "#Calculation\n", + "Vdc=2*math.sqrt(2)*V/math.pi #V\n", + "Em=Vdc #V\n", + "Ia=math.sqrt(T/Kt) #A\n", + "def f(omega_m):\n", + " return(1.5*Ia+Kt*omega_m*Ia-Em)\n", + "omega_m=fsolve(f,1)\n", + "N=omega_m*60.0/2.0/math.pi #RPM\n", + "\n", + "#Result\n", + "print\"Average motor current: \",Ia,\"A\"\n", + "print\"Motor speed : \",round(N[0],2),\"RPM\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Average motor current: 10.0 A\n", + "Motor speed : 733.66 RPM\n" + ] + } + ], + "prompt_number": 27 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.26 ,Page no:128" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "V1=675.0 #[Secondary voltage] V\n", + "alfa1=90.5 #[Firing angle] degree\n", + "N1=350.0 #[Motor speed] rpm\n", + "Ia1=30.0 #[Armature current] A\n", + "N2=500.0 #[Second motor speed] rpm\n", + "Rf=0.22 #[Field resistance] ohm\n", + "Ra=0.22 #[Armature resistance] ohm\n", + "\n", + "#Calculation\n", + "Ia2=Ia1*N2/N1 #A\n", + "Va1=V1*math.sqrt(2.0)/math.pi*(1.0+math.cos(math.radians(alfa1))) #V\n", + "Eb1=Va1-Ia1*(Ra+Rf) #V\n", + "#Eb1/Eb2=Ia1*N1/(Ia2*N2)\n", + "#Eb2=Va2-Ia2*(Ra+Rf)\n", + "Va2=Eb1*Ia2*N2/(Ia1*N1)+Ia2*(Ra+Rf) #V\n", + "alfa2=math.acos(Va2/V1/math.sqrt(2.0)*math.pi-1.0) #degree\n", + "\n", + "#Result\n", + "print\"Armature current of converter in A : \",round(Ia2,2),\"A\"\n", + "print\"Fringe angle of converter in degree : \",round(math.degrees(alfa2),2),\"degree\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Armature current of converter in A : 42.86 A\n", + "Fringe angle of converter in degree : 4.86 degree\n" + ] + } + ], + "prompt_number": 28 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.27 ,Page no:129" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "V1=230.0 #[Voltage] V\n", + "P=15.0 #[Power] hp\n", + "N=1500.0 #[Speed] rpm\n", + "V2=220.0 #[Voltage]] V\n", + "Ke=0.03 #[emf constant] V/A-s\n", + "Kt=0.03 #[torque constant] N-m/A**2\n", + "alfa=45.0 #[firing angle] degree\n", + "\n", + "#Calculation\n", + "Vm=V1*math.sqrt(2) #V\n", + "omega=N*2*math.pi/60 #rad/s\n", + "T=4*Kt*Vm**2*math.cos(math.radians(alfa))**2/(math.pi**2*(Ke*omega)**2) #N-m\n", + "Ia=math.sqrt(T/Kt) #A\n", + "\n", + "#Result\n", + "print\"part (a) : \"\n", + "print\"Torque in N-m : \",round(T,2),\"N-m\"\n", + "print\"Armature current : \",round(Ia,2),\"A\"\n", + "print\"part (b) : \"\n", + "Ia=Vm*(1+math.cos(math.radians(alfa)))/(math.pi*(Ke*omega)) #A\n", + "T=Kt*Ia**2 #N-m\n", + "print\"Armature current : \",round(Ia,1),\"A\"\n", + "print\"Torque : \",round(T,4),\"N-m\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "part (a) : \n", + "Torque in N-m : 28.96 N-m\n", + "Armature current : 31.07 A\n", + "part (b) : \n", + "Armature current : 37.5 A\n", + "Torque : 42.2033 N-m\n" + ] + } + ], + "prompt_number": 29 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.28 ,Page no:130" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "V1=230.0 #[Voltage] V\n", + "N=1000.0 #[Speed] rpm\n", + "P=15.0 #[Power rating] hp\n", + "Rt=0.2 #[Resistance] ohm\n", + "Ke=0.03 #[emf rating] V/A-s\n", + "Kt=0.03 #[torque rating] N-m/A**2\n", + "alfa=30.0 #[Firng angle] degree\n", + "\n", + "#Calculation\n", + "Vm=V1*math.sqrt(2) #V\n", + "omega=N*2*math.pi/60.0 #rad/s\n", + "V=Vm/math.pi*(1+math.cos(math.radians(alfa))) #V\n", + "#V=Ke*Ia*omega+Ia*Rt\n", + "Ia=V/(Ke*omega+Rt) #A\n", + "T=Kt*Ia**2 #N-m\n", + "\n", + "#Result\n", + "print\"Motor current : \",round(Ia,3),\"A\"\n", + "print\"Torque : \",round(T,2),\"N-m\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Motor current : 57.817 A\n", + "Torque : 100.28 N-m\n" + ] + } + ], + "prompt_number": 30 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.29 ,Page no:131" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "V=220.0 #[Voltage] V\n", + "Vin=230.0 #[input volatge] V\n", + "N1=1500.0 #[Speed of motor] rpm\n", + "Ia1=10.0 #[Armature current] A\n", + "Ra=3.0 #[Armature resistance] ohm\n", + "N2=600.0 #[Speed] rpm\n", + "\n", + "#Calculation\n", + "E1=V-Ia1*Ra #V\n", + "E2=E1*N2/N1 #V\n", + "Ia2=Ia1/2.0 #A(because of Tnew=T/2)\n", + "Vapp=E2+Ia2*Ra #V\n", + "alfa=math.acos(Vapp*math.pi/2/math.sqrt(2)/Vin) #degree\n", + "\n", + "#Result\n", + "print\"Firing angle of converter : \",round(math.degrees(alfa),1),\"degree\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Firing angle of converter : 63.9 degree\n" + ] + } + ], + "prompt_number": 31 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.30 ,Page no:131" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + " \n", + "import math \n", + "#Variable declaration\n", + "V=230.0 #[Volatge] V\n", + "N=870.0 #[Motor speed] rpm\n", + "Ia=100.0 #[Armaturecurrent] A\n", + "Ra=0.05 #[Armature resisatce]ohm\n", + "T=400.0 #[Torque] N-m\n", + "\n", + "#Calculation\n", + "E=V-Ia*Ra #V\n", + "Vgen=V+Ia*Ra #V\n", + "N2=N*Vgen/E #rpm\n", + "\n", + "#Result\n", + "print\"Motor speed in rpm : \",round(N2,2),\"rpm\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Motor speed in rpm : 908.67 rpm\n" + ] + } + ], + "prompt_number": 32 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.31 ,Page no:132" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "V=220.0 #[Voltage] V\n", + "P=2.2 #[Power of motor] KW\n", + "N1=1000.0 #[Motor speed] rpm\n", + "Ra=2.0 #[Resistance] ohm\n", + "f=250.0 #[Frequency] Hz\n", + "alfa=0.9 #[duty cycle] cycle\n", + "N2=1200.0 #[Load torque]rpm\n", + "N3=800.0 #[Final speed] rpm\n", + "\n", + "#Calculation\n", + "Ia1=P*1000.0/V #A\n", + "Ia2=Ia1*N2/N1 #A\n", + "Eb2=alfa*V-Ia2*Ra #V\n", + "Eb3=Eb2*N3/N2 #V\n", + "Ia3=Ia1*N3/N1 #A\n", + "alfa3=(Eb3+Ia3*Ra)/V #cycle\n", + "ton=alfa3/f #sec\n", + "\n", + "#Result\n", + "print\"On time of chopper %.1e\"%ton,\"sec\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "On time of chopper 2.4e-03 sec\n" + ] + } + ], + "prompt_number": 33 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.32 ,Page no:139" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + " \n", + "import math \n", + "#Variable declaration\n", + "V=230.0 #[Voltage]V\n", + "N1=1000.0 #[Motor speed]rpm\n", + "Ia1=100.0 #[Armature current]A\n", + "Ra=0.1 #[Armature resistance]ohm\n", + "Rf=0.1 #[Field ressiatnce]ohm\n", + "N2=800.0 #[Final speed of motor]rpm\n", + "\n", + "#Calculation\n", + "Ia2=math.sqrt(2)*Ia1 #A(As T2=2*T1 & T proportional to Ia**2)\n", + "Eb1=V-Ia1*(Ra+Rf) #V\n", + "Eb2=N2*Ia2/(N1*Ia1)*Eb1 #V\n", + "#Eb2=Ia2*(Ra+Rf+Rbraking)\n", + "Rbraking=Eb2/Ia2-Ra-Rf #ohm\n", + "Ibraking=Eb2/Rbraking #A\n", + "\n", + "\n", + "#Result\n", + "print'Braking resistance : ' ,Rbraking,\"ohm\"\n", + "print'Braking current : ',round(Ibraking,1),\"A\"\n", + "print\"NOTE:Braking current is not calculated in the textbook but asked in the example.\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Braking resistance : 1.48 ohm\n", + "Braking current : 160.5 A\n", + "NOTE:Braking current is not calculated in the textbook but asked in the example.\n" + ] + } + ], + "prompt_number": 34 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.33 ,Page no:139" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "P=6.0 #poles\n", + "V=220.0 #[Voltage] V\n", + "f=50.0 #[Frequency] Hz\n", + "Ra=0.2 #[Armature resistance] ohm\n", + "Rf=150.0 #[Field resistance] ohm\n", + "Z=150.0 #[no. of conductors]\n", + "fi=0.02027 #[Field flux per mole]Wb(flux)\n", + "alfa=0.0 #[Delay angle for field converter] degree\n", + "alfa_a=45.0 #[Delay angle for armature converters] degree\n", + "Ia=25.0 #[Armature current] A\n", + "A=2.0 # [Area]\n", + "\n", + "#Calculation\n", + "T=Z*P*fi*Ia/(2*math.pi*A) #N-m\n", + "Vm=V*math.sqrt(2) #V\n", + "Vdc=2*Vm/math.pi*math.cos(math.radians(alfa_a)) #V\n", + "Eb=Vdc-Ia*Ra #V\n", + "N=Eb*60*A/(Z*P*fi) #rpm\n", + "Pout=Vdc*Ia #W\n", + "pf=Pout/V/Ia #lagging\n", + "\n", + "#Result\n", + "print\"Totque : \",round(T,3),\"N-m\"\n", + "print\"Speed : \",round(N,2),\"rpm\"\n", + "print'Power factor : ',round(pf,4),\"Lagging\"\n", + "\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Totque : 36.293 N-m\n", + "Speed : 888.38 rpm\n", + "Power factor : 0.6366 Lagging\n" + ] + } + ], + "prompt_number": 35 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.34 ,Page no:140" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Variable declaration\n", + "R=0.1 #Armature resistance in [ohm]\n", + "V1=220.0 #Voltage in [V]\n", + "N1=1000.0 #speed in [rpm]\n", + "I=100.0 #Current in [A]\n", + "V2=200.0 #Dropped voltage in [V]\n", + "\n", + "#Calculation\n", + "Eb2=V2-I*R\n", + "Eb1=V1-I*R \n", + "N2=Eb2*N1/Eb1 #Motor speed after drop\n", + "\n", + "#Result\n", + "print\"Motor speed after voltage drop is\",round(N2,2),\"rpm\"" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Motor speed after voltage drop is 904.76 rpm\n" + ] + } + ], + "prompt_number": 36 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.35 ,Page no:140" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "V1=200.0 #[Voltage] V\n", + "N1=940.0 #[Speed] rpm\n", + "Ra=0.02 #[Armature resistance] ohm\n", + "Ia=100.0 #[Armature current] A\n", + "N2=500.0 #[Speed] rpm\n", + "\n", + "#Calculation\n", + "Eb1=V1-Ia*Ra #V\n", + "#Eb1/Eb2=N1/N2\n", + "#Eb2=V2-Ia*Ra #V\n", + "V2=Eb1*N2/N1+Ia*Ra #V\n", + "cycle=V2/V1 \n", + "\n", + "#Result\n", + "print\"Duty cycle : \",round(cycle,4)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Duty cycle : 0.5366\n" + ] + } + ], + "prompt_number": 37 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.36 ,Page no:141" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "V1=220.0 #[Voltage] V\n", + "Ra=0.05 #[Armature resistance]ohm\n", + "N1=1000.0 #[Speed]rpm\n", + "Ia=100.0 #[Armature current]A\n", + "N2=500.0 #[Speed]rpm\n", + "\n", + "#Calculation\n", + "Eb=V1-Ia*Ra #V\n", + "Ib=2*Ia #A\n", + "Rb=(V1+Eb)/Ib-Ra #ohm\n", + "Tb=Eb/(N1*2*math.pi/60.0)*Ib #N-m\n", + "Eb2=Eb*N2/N1 #V\n", + "Ib2=(V1+Eb2)/(Ra+Rb) #A\n", + "Tb2=Eb2/(N2*2*math.pi/60.0)*Ib2 #N-m\n", + "\n", + "#Result\n", + "print\"Resistance to be added:\",Rb,\"ohm\"\n", + "print\"Initial braking torque : \",round(Tb,2),\"N-m\"\n", + "print\"Initial braking torque: \",round(Tb2,1),\"N-m\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Resistance to be added: 2.125 ohm\n", + "Initial braking torque : 410.62 N-m\n", + "Initial braking torque: 309.1 N-m\n" + ] + } + ], + "prompt_number": 38 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.37 ,Page no:142" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "V1=230.0 #[Voltage] V\n", + "N1=870.0 #[Speed] rpm\n", + "Ia=100.0 #[Armature current] A\n", + "Ra=0.05 #[Armature resistance] ohm\n", + "T=400.0 #[Torqu] N-m\n", + "\n", + "#Calculation\n", + "Eb=V1-Ia*Ra #V\n", + "Vgen=V1+Ia*Ra #V\n", + "N2=N1*Vgen/Eb #rpm\n", + "\n", + "#Result\n", + "print\"Speed : \",round(N2,2),\"rpm\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Speed : 908.67 rpm\n" + ] + } + ], + "prompt_number": 39 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.38 ,Page no:142" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "P=10.0 #[Power] KW\n", + "V1=230.0 #[Voltage] V\n", + "N1=1200.0 #[Speed] rpm\n", + "Ra=0.5 #[Armature resistance] ohm\n", + "Ke=0.182 #[emf constant] V/rpm\n", + "V2=260.0 #[Voltage]V\n", + "alfa=30.0 #[Firing angle] degree\n", + "Ia=30.0 #[Armature current] A\n", + "\n", + "#Calculation\n", + "Vm=V2*math.sqrt(2) #V\n", + "Vdc=2*Vm/math.pi*math.cos(math.radians(alfa)) #V\n", + "Eb=Vdc-Ia*Ra #V\n", + "Kt=Ke*60/2/math.pi #N-m/A\n", + "T=Kt*Ia #N-m\n", + "N2=Eb/Ke #rpm\n", + "Pout=Vdc*Ia #W\n", + "pf=Pout/V2/Ia #lagging power factor\n", + "\n", + "#Result\n", + "print\"Torque in N-m : \",round(T,2),\"N-m\"\n", + "print\"Speed in rpm : \",round(N2,2),\"rpm\"\n", + "print\"Power factor : \",round(pf,3),\"lagging\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Torque in N-m : 52.14 N-m\n", + "Speed in rpm : 1031.43 rpm\n", + "Power factor : 0.78 lagging\n" + ] + } + ], + "prompt_number": 40 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.39 ,Page no:143" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration \n", + "P=2.2 #[Power] KW\n", + "V=220 #[Voltage] V\n", + "N1=1000 #[Speed] rpm\n", + "Ra=2 #[Resistance armature] ohm\n", + "f=250 #[frequency] Hz\n", + "alfa=0.9 #duty cycle\n", + "N2=1200 #[Speed]rpm\n", + "N3=800 #[Motor sped] rpm\n", + "\n", + "#Calculation\n", + "Ia1=P*1000/V #A\n", + "Ia2=Ia1*N2/N1 #A\n", + "Eb1=alfa*V-Ia2*Ra #V\n", + "Eb2=Eb1*N3/N2 #V\n", + "Ia3=Ia1*N3/N1 #A\n", + "alfa3=(Eb2+Ia3*Ra)/V #cycle\n", + "ton=alfa3/f #sec\n", + "\n", + "#Result\n", + "print'On time of chopper : ',ton*1000,\"milli seconds\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "On time of chopper : 2.4 milli seconds\n" + ] + } + ], + "prompt_number": 41 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.40,Page no:143" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "V=220.0 #[Voltage] V\n", + "Eff1=85/100.0 #Efficiency\n", + "Eff2=80/100.0 #Efficiency\n", + "Load=400.0 #[Load in Kg\n", + "t=2.5 #[time] ms\n", + "Ra=0.1 #[Armature resistance] ohm\n", + "g=9.81 #constant for gravity acceleration\n", + "\n", + "#Calculation\n", + "Pout=Load*g*t #W\n", + "IL=Pout/V/Eff1/Eff2 #A\n", + "Eb=V-IL*Ra #V\n", + "R=(V+Eb)/IL-Ra #ohm\n", + "\n", + "#Result\n", + "print\"Current drawn : \",round(IL,3),\"A\"\n", + "print\"Resistance to be added : \",round(R,2),\"ohm\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Current drawn : 65.575 A\n", + "Resistance to be added : 6.51 ohm\n" + ] + } + ], + "prompt_number": 42 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example:5.41 ,Page no:144" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "V1=220.0 #[Voltage] V\n", + "N1=1500.0 #[Speed] rpm\n", + "I=10.0 #[Current] A\n", + "Ra=3.0 #[Armature resistance] ohm\n", + "V2=230.0 #[Voltage]V\n", + "N2=600.0 #[Speed] rpm\n", + "\n", + "#Calculation\n", + "Eb1=V1-I*Ra #V\n", + "Eb2=Eb1*N2/N1 #V\n", + "Ia=I/2 #A(at half rated torque)\n", + "Vm=V1*math.sqrt(2) #V\n", + "alfa=math.acos((Eb2+Ia*Ra)*math.pi/2/Vm) #degree\n", + "\n", + "#Result\n", + "print\"Firing angle : \",round(math.degrees(alfa),2),\"degree\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Firing angle : 62.65 degree\n" + ] + } + ], + "prompt_number": 43 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Fundamentals_of_Electric_Drives_and_Control/Chapter__6.ipynb b/Fundamentals_of_Electric_Drives_and_Control/Chapter__6.ipynb new file mode 100644 index 00000000..da75e528 --- /dev/null +++ b/Fundamentals_of_Electric_Drives_and_Control/Chapter__6.ipynb @@ -0,0 +1,1223 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 6:AC Motor Drives" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.1,Page no:153" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "#Variable declaration\n", + "V=400.0 #[Voltage] volt\n", + "P=4.0 #[poles]\n", + "f=50.0 #[Frequency] Hz\n", + "Pout=10.0 #[Power out] hp\n", + "\n", + "#Calculation\n", + "Pout=Pout*735.5 #[Power out] in W\n", + "Snl=1.0/100.0 #No load Slip\n", + "Sfl=4.0/100.0 #Full load slip\n", + "Ns=120.0*f/P #[Synchronous speed] rpm\n", + "N1=Ns*(1.0-Snl) #[Speed at no load] rpm\n", + "N2=Ns*(1.0-Sfl) #[Speed at full load] rpm\n", + "\n", + "f2=Sfl*f #[Frequency at full load] Hz\n", + "omega_n=N2*2*math.pi/60.0 #[Angular velocity] rad/s\n", + "T=Pout/omega_n #[Full load torque] N-m\n", + "\n", + "#Result\n", + "print\"(a) Synchronous speed \",Ns,\"rpm\"\n", + "print\"(b) Speed at no load : \",N1,\"rpm\"\n", + "print\"(c) Speed at full load in rpm : \",N2,\"rpm\"\n", + "print\"(d) Frequency of rotor current at full load : \",f2,\"Hz\"\n", + "print\"(e) Full load Torque : \",round(T,2),\"N-m\\n\\n\"\n", + "print\"NOTE:Answer of Part (C) full load speed in the book is wrong.\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Synchronous speed 1500.0 rpm\n", + "(b) Speed at no load : 1485.0 rpm\n", + "(c) Speed at full load in rpm : 1440.0 rpm\n", + "(d) Frequency of rotor current at full load : 2.0 Hz\n", + "(e) Full load Torque : 48.77 N-m\n", + "\n", + "\n", + "NOTE:Answer of Part (C) full load speed in the book is wrong.\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.2,Page no:153" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "P=6.0 #poles\n", + "f1=50.0 #[Input frequency] Hz\n", + "Pg=80.0 #[Power of induction motor] KW\n", + "f2=100.0 #[alternation/min]\n", + "\n", + "#Calculation\n", + "f2=f2/60.0 #[Frequency] Hz\n", + "Ns=120*f1/P #[Synchronous speed] rpm\n", + "Ns=Ns/60.0 #rps\n", + "S=f2/f1 #[Slip]\n", + "print\"Slip is : \",S\n", + "N=Ns*(1.0-S) #[Motor speed] rps\n", + "print\"Motor speed : \",round(N*60.0,2),\"rpm\"\n", + "Pm=Pg*(1-S) #[Mechanical power developed] KW\n", + "print\"Developed mechanical power : \",round(Pm,3),\"kW\"\n", + "CuLoss=S*Pg #[Rotor copper loss] KW\n", + "CuLoss_per_phase=CuLoss/3.0 #KW\n", + "print\"Rotor Copper Loss per phase : \",round(CuLoss_per_phase*1000,1),\"W\"\n", + "I2=65 #A\n", + "r2=CuLoss_per_phase*1000.0/I2**2 #ohm/phase\n", + "print\"Rotor resistance per phase : \",round(r2,2),\"ohm/phase\"\n", + "T=Pg*1000.0/2.0/math.pi/Ns #N-m\n", + "\n", + "#Result\n", + "print\"Torque developed : \",round(T,2),\"N-m\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Slip is : 0.0333333333333\n", + "Motor speed : 966.67 rpm\n", + "Developed mechanical power : 77.333 kW\n", + "Rotor Copper Loss per phase : 888.9 W\n", + "Rotor resistance per phase : 0.21 ohm/phase\n", + "Torque developed : 763.94 N-m\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.3,Page no:154" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "N=288.0 #[Full load speed] rpm\n", + "f=50.0 #[Supply frequency] Hz\n", + "CuLoss=275.0 #[Copper loss] W\n", + "Ns=300.0 #[Synchronous speed] rpm(For S=0.03:0.05)\n", + "\n", + "#Calculation\n", + "P=120.0*f/Ns #poles\n", + "print\"No. of poles : \",P\n", + "S=(Ns-N)/Ns #Slip\n", + "print\"Slip : \",S\n", + "S=2.0*S #(as rotor reistance doubled, slip is doubled)\n", + "print\"Slip for full load if rotor resiatance doubled : \",S\n", + "#CuLoss=I2**2*r2\n", + "CuLoss=2*CuLoss #KW(rotor resiatance doubled & current constant)\n", + "\n", + "#Result\n", + "print\"New value of rotor copper loss : \",CuLoss,\"W\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "No. of poles : 20.0\n", + "Slip : 0.04\n", + "Slip for full load if rotor resiatance doubled : 0.08\n", + "New value of rotor copper loss : 550.0 W\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.4,Page no:158" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "T_directStartBYTfl=1.5 #[ratio]\n", + "\n", + "#Calculation\n", + "K=math.sqrt(T_directStartBYTfl) #Ratio of full load torque to starting torque direct starting\n", + "#Vapplied=1/K*Vline\n", + "VappliedBYVline=1/K \n", + "LineCurrentBYIfl=1/K**2*4 #V\n", + "\n", + "#Result\n", + "print\"Applied voltage is \",round(VappliedBYVline,3),\"* Line voltage.\"\n", + "print\"Line current at starting is \",round(LineCurrentBYIfl,2),\" * full load current.\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Applied voltage is 0.816 * Line voltage.\n", + "Line current at starting is 2.67 * full load current.\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.5,Page no:158" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "#Variable declaration\n", + "Ist=300.0 #[Starting current] A\n", + "X=50/100.0 #[Percentage tapping] tapping\n", + "Imotor=X*Ist #[Motor current] A\n", + "\n", + "#Calculation\n", + "\n", + "Iline=X**2*Ist #A\n", + "ratio=X**2 #Ratio of starting Torque 50% tapping to full voltage torque\n", + "\n", + "#Result\n", + "print\"(a) Motor current : \",Imotor,\"A\"\n", + "print\"(b) Line current : \",Iline,\"A\"\n", + "print\"(c) Ratio of starting Torque 50% tapping to full voltage torque : \",ratio\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Motor current : 150.0 A\n", + "(b) Line current : 75.0 A\n", + "(c) Ratio of starting Torque 50% tapping to full voltage torque : 0.25\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.6,Page no:163" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "V=400.0 #[Volatge] volt\n", + "P=8.0 #[pole]\n", + "f=50.0 #[Frequency] Hz\n", + "r1=1.2 #[Resistance] ohm\n", + "r2dash=1.2 #[R2] ohm\n", + "x1=2.5 #[Resistance parameter 3] ohm\n", + "x2dash=2.5 #[Resistance] ohm\n", + "N=720.0 #rpm\n", + "\n", + "#Calculation\n", + "Ns=120.0*f/P #rpm\n", + "S=(Ns-N)/Ns #full load slip\n", + "S2=2.0-S #Slip during plugging\n", + "V1=V/math.sqrt(3.0) #V\n", + "I2dash1=V1/math.sqrt((r1+r2dash/S2)**2.0+(x1+x2dash)**2.0) #A(Initial braking current)\n", + "Ifl=V1/math.sqrt((r1+r2dash/S)**2.0+(x1+x2dash)**2.0) #A(Full load current)\n", + "\n", + "RatioCurrent=I2dash1/Ifl #ratio of initial braking current to full load current\n", + "Tfl=3.0*Ifl**2*r1/(2.0*math.pi*S*Ns/60.0) #N-m\n", + "T2dash=3.0*I2dash1**2.0*r2dash/(2.0*math.pi*S2*Ns/60.0) #N-m(initail braking T)\n", + "RatioT=T2dash/Tfl #ratio of initial braking Torque to full load Torque\n", + "#Let R be the additional resistance\n", + "I2dash=2*Ifl #A\n", + "#I2dash=V1/math.sqrt((r1+r2dash/S2+R/S2)**2+(x1+x2dash)**2) #A(Initial braking current)\n", + "R=(math.sqrt(V1**2.0/I2dash**2.0-(x1+x2dash)**2.0)-r1-r2dash/S2)*S2 #in ohm\n", + "Ractual=R/2.0**2.0 #ohm\n", + "T_braking=3*I2dash**2*(r2dash+R)/(2.0*math.pi*S2*Ns/60.0) #N-m(initail braking T)\n", + "TbBYTfl=T_braking/T2dash #ratio\n", + "\n", + "#Calculation\n", + "print\"(a) Initial Braking current : \",round(I2dash1,2),\"A\"\n", + "print\" Full load current is:\",round(Ifl,2),\"A\"\n", + "print\" Ratio is \",round(RatioCurrent,3)\n", + "print\" Full load troque=\",round(Tfl,2),\"N-m\"\n", + "print\" Initial Braking torque: \",round(T2dash,2),\"N-m\"\n", + "print\" Ratio of braking \",RatioT,\" times of full load Torque.\\n\"\n", + "print\"(b) Actual additional rotor resistance per phase :\",round(Ractual,3),\"ohm\\n\"\n", + "print\"(c) Braking torque in N-m : \",round(T_braking,2),\"N-m\"\n", + "print\" Ratio of braking torque to full load torque : \",round(TbBYTfl,2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Initial Braking current : 43.42 A\n", + " Full load current is: 7.31 A\n", + " Ratio is 5.941\n", + " Full load troque= 61.21 N-m\n", + " Initial Braking torque: 44.1 N-m\n", + " Ratio of braking 0.720412943871 times of full load Torque.\n", + "\n", + "(b) Actual additional rotor resistance per phase : 6.456 ohm\n", + "\n", + "(c) Braking torque in N-m : 112.52 N-m\n", + " Ratio of braking torque to full load torque : 2.55\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.7,Page no:169" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "#Variable declaration\n", + "V=400.0 #[Volatge] volt\n", + "P=8.0 #[pole]\n", + "f=50.0 #Frequency Hz\n", + "r1=0.1 #Resistance ohm\n", + "r2dash=0.1 #Resistance ohm\n", + "x1=0.4 #Resistance ohm\n", + "x2dash=0.4 #Resistance ohm\n", + "J=10.0 #Inertia of motor Kg-m**2\n", + "\n", + "#Calculation\n", + "Sm=r2dash/math.sqrt(r1**2+(x1+x2dash)**2)\n", + "Ns=2*f/P #rps\n", + "omega_ms=2*math.pi*Ns #rad/s\n", + "V1=V/math.sqrt(3) #V\n", + "Tmax=1.5*V1**2/(2.0*math.pi*Ns)*(1.0/(r1+math.sqrt(r2dash**2+(2*x2dash)**2))) #N-m\n", + "tau_m=J*omega_ms/Tmax #sec\n", + "ts=tau_m*(1.5*Sm+0.25/Sm) #sec\n", + "E=0.5*J*omega_ms**2 #Watt-s\n", + "Etot=2*E #Watts-s\n", + "tb=tau_m*(0.7/Sm+0.334*Sm) #sec\n", + "E=1.4*J*omega_ms**2 #Watt-s\n", + "E=2*E/1000 #KW-s(taking cU loss into account)\n", + "\n", + "#Result\n", + "print\"(a) Starting time : \",round(ts,2),\"seconds\"\n", + "print\"(b) Energy dissipated during starting : \",round(Etot/1000,2),\"kW-s\"\n", + "print\"(c) Pluggingfg time : \",round(tb,2),\"secs\"\n", + "print\"(d) Energy dissipated during plugging : \",round(E,2),\"kW-s\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Starting time : 1.54 seconds\n", + "(b) Energy dissipated during starting : 61.69 kW-s\n", + "(c) Pluggingfg time : 3.97 secs\n", + "(d) Energy dissipated during plugging : 172.72 kW-s\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.8,Page no:177" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "V=400.0 #[Voltage] volt\n", + "P=4.0 #[pole]\n", + "f=50.0 #Frequency Hz\n", + "r1=0.64 #Resistances ohm\n", + "r2=0.08 #Resistance ohm\n", + "x1=1.1 #Resistance ohm \n", + "x2=0.12 #Resistance ohm\n", + "T1=40.0 #Load torque N-m\n", + "N=1440.0 #Speed rpm\n", + "n=2.0*f/P #[Load torque at1300] rps\n", + "n=n*60.0 #rpm\n", + "N1=1300.0 #[Motor speed] rpm\n", + "#Calculation\n", + "Tload=T1*(N1/N)**2 #N-m\n", + "S=(n-N1)/n #slip\n", + "r2dash=r2*2**2 #ohm\n", + "x2dash=x2*2**2 #ohm\n", + "#Tload=3*I2dash**2*r2dash/(2*math.pi*S*n/60)\n", + "I2dash=math.sqrt(Tload/3/r2dash*(2*math.pi*S*n/60)) #A\n", + "I2=2*I2dash #A\n", + "I1=I2dash #A\n", + "V1=I1*(r1+r2dash+r2dash*(1-S)/S+(1j)*(x1+x2dash)) #Vplt\n", + "StatorVoltage=abs(V1)*math.sqrt(3) #Volt\n", + "\n", + "#Result\n", + "print\"(a) Load torque : \",round(Tload,1),\"N-m\"\n", + "print\"Rotor current:\",round(I2,2),\"A\"\n", + "print\"Stator Applied Voltage : \",round(StatorVoltage,1),\"V\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Load torque : 32.6 N-m\n", + "Rotor current: 53.34 A\n", + "Stator Applied Voltage : 158.3 V\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.9,Page no:177" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "V=400.0 #[Voltage] volt\n", + "P=4.0 #[pole]\n", + "f=50.0 #[Frequecy] Hz\n", + "r1=0.64 #[Resistance] ohm\n", + "r2=0.08 #[Resistance] ohm\n", + "x1=1.1 #[Resistance] ohm\n", + "x2=0.12 #[Resistance] ohm\n", + "T1=40.0 #[Torqu] N-m\n", + "N=1440.0 #[Speed] rpm\n", + "N1=1300.0 #[Motor speed] rpm\n", + "\n", + "#Calculation\n", + "r2dash=r2*2**2 #ohm\n", + "x2dash=x2*2**2 #ohm\n", + "S=r2dash/math.sqrt(r1**2+(x1+x2dash)**2) #slip\n", + "print\"(a) Slip for maximum torque at 50 Hz : \",round(S,4)\n", + "V1=V/math.sqrt(3) #volt/phase\n", + "ns=2*f/P #rps\n", + "Tmax=1.5*V1**2/(2*math.pi*ns)*(1/(r1+math.sqrt(r1**2+(x1+x2dash)**2))) #Nm\n", + "print\"Maximum torque at 50 Hz : \",round(Tmax,1),\"N-m\"\n", + "n=ns*(1-S) #rps\n", + "N=n*60 #rpm\n", + "print\"Speed at 50 Hz : \",round(N,2),\"rpm\"\n", + "f=25 #Hz\n", + "x1=x1/2 #ohm\n", + "x2dash=x2dash/2 #ohm\n", + "S=r2dash/math.sqrt(r1**2+(x1+x2dash)**2) #slip\n", + "print\"(b) Slip for maximum torque at 25 Hz : \",round(S,4)\n", + "V1=V1/2 #volt/phase\n", + "ns=2*f/P #rps\n", + "Tmax=1.5*V1**2/(2*math.pi*ns)*(1/(r1+math.sqrt(r1**2+(x1+x2dash)**2))) #Nm\n", + "print\"Maximum torque at 25 Hz: \",round(Tmax,2),\"N-m\"\n", + "n=ns*(1-S) #rps\n", + "N=n*60 #rpm\n", + "\n", + "\n", + "#Result\n", + "print\"Speed at 25 Hz : \",round(N,3),\"rpm\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Slip for maximum torque at 50 Hz : 0.1877\n", + "Maximum torque at 50 Hz : 217.2 N-m\n", + "Speed at 50 Hz : 1218.43 rpm\n", + "(b) Slip for maximum torque at 25 Hz : 0.3147\n", + "Maximum torque at 25 Hz: 153.71 N-m\n", + "Speed at 25 Hz : 513.945 rpm\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.10,Page no:178" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "#Variable declaration\n", + "\n", + "V=400.0 #[Voltage[ volt\n", + "P=4.0 #[pole]\n", + "f=50.0 #[Frequency] Hz\n", + "r1=0.64 #[Resistance] ohm\n", + "r2=0.08 #[Resistance] ohm\n", + "x1=1.1 #[Resistance] ohm\n", + "x2=0.12 #[Resistance] ohm\n", + "T1=40.0 #[Troque] N-m\n", + "N=1440.0 #[Speed] rpm\n", + "N1=1300.0 #[Motor speed] rpm\n", + "\n", + "#Calculation\n", + "r2dash=r2*2**2 #ohm\n", + "x2dash=x2*2**2 #ohm\n", + "S=r2dash/math.sqrt(r1**2+(x1+x2dash)**2) #slip\n", + "V1=V/math.sqrt(3) #volt/phase\n", + "ns=2*f/P #rps\n", + "Tst1=3*V1**2*r2dash/(2*math.pi*ns*((r1+r2dash)**2+(x1+x2dash)**2)) #N-m\n", + "f=25 #Hz\n", + "x1=x1/2 #ohm\n", + "x2dash=x2dash/2 #ohm\n", + "V1=V1/2 #volt/phase\n", + "ns=2*f/P #rps\n", + "Tst2=3*V1**2*r2dash/(2*math.pi*ns*((r1+r2dash)**2+(x1+x2dash)**2)) #N-m\n", + "\n", + "#Calculation\n", + "print\"Starting torque at 50 Hz : \",round(Tst1,2),\"N-m\"\n", + "print\"Starting torque at 25 Hz : \",round(Tst2,2),\"N-m\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Starting torque at 50 Hz : 95.36 N-m\n", + "Starting torque at 25 Hz : 105.44 N-m\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.11,Page no:179" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "V=400.0 #[Voltage] volt\n", + "P=4.0 #[pole ]\n", + "f=50.0 #[Frequency] Hz\n", + "r2dash=1.0 #[Rotor resistance] ohm/phase\n", + "#Neglecting r1,x1,x2\n", + "f1=400.0 #[Frequency] Hz\n", + "S=4.0/100.0 #[Slip]\n", + "t2=1.5 #[Time] ms\n", + "\n", + "#Calculation\n", + "t2=t2*10**-3 #sec\n", + "t=1.0/f1 #sec\n", + "t1=t-t2 #sec\n", + "R=2.0 #ohm(additional resistance)\n", + "R2dash=(r2dash*t1+(r2dash+R)*t2)/t #ohm\n", + "V1=V/math.sqrt(3) #volt\n", + "T=3*V1**2*S/R2dash #N-m\n", + "\n", + "#Result\n", + "print\"Torque : \",round(T,1),\" synch.watts\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Torque : 2909.1 synch.watts\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.12,Page no:179" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "#Variable declaration\n", + "V1=400.0 #[Volatge] volt\n", + "P=4.0 #[pole]\n", + "f=50.0 #[Frequency] Hz\n", + "Sm=10.0/100.0 #[slip]\n", + "S1=0.04 #[slip]\n", + "N2=900.0 #[Speed] rpm\n", + "#r2dash=0.01*x2 #ohm/phase\n", + "r2dash=0.01 #[Stator resistance]\n", + "r1dash=0.1 #[Stator resistance]\n", + "\n", + "#Calculation\n", + "Ns=120.0*f/P #rpm\n", + "N1=Ns*(1-S1) #rpm\n", + "S2=(Ns-N2)/Ns #slip\n", + "T2ByT1=(N2/N1)**2 \n", + "#T=3/(2*math.pi*ns)*[V1**2/((rdash/S2)**2+xdash**2)]*(rdash/S2)\n", + "#T2/T1=V2**2/V1**2*S1/S2*[(1+625*r1dash**2)/(1+6.25*r1dash**2)]\n", + "V2=math.sqrt(T2ByT1*V1**2*S2/S1/((1+625*r1dash**2)/(1+6.25*r1dash**2))) #volt\n", + "\n", + "#Result\n", + "print\"Stator applied voltage: \",round(V2,2),\"V\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Stator applied voltage: 302.65 V\n" + ] + } + ], + "prompt_number": 12 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.13,Page no:180" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "P=4.0 #[pole]\n", + "f=50.0 #[Frequency] Hz\n", + "S=4/100.0 #[slip]\n", + "T=1000.0 #[Torque] synch.Watts\n", + "f1=25.0 #[New I/P frequency] Hz\n", + "\n", + "#Calculation\n", + "Tnew=T*f/f1 #synch.watts\n", + "\n", + "#Result\n", + "print\"Torque : \",Tnew,\"synch.Watts\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Torque : 2000.0 synch.Watts\n" + ] + } + ], + "prompt_number": 13 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.14,Page no:181" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "P=4.0 #pole\n", + "f=50.0 #[Frequency] Hz\n", + "r1=0.04 #[Resitance] ohm\n", + "r1dash=0.04 #[Rotor Resistance] ohm\n", + "r2dash=0.04 #[Rotor resistance] ohm\n", + "x1=0.2 #[Reactance] ohm\n", + "x2dash=0.2 #[Reactace] ohm\n", + "f1=20.0 #[New Frequency] Hz\n", + "\n", + "#Calculation\n", + "k=f1/f #ratio of frequencies\n", + "Tmax20BYTmax50=(r1+math.sqrt(r1**2+(x1+x2dash)**2))/(r1/k+math.sqrt((r1/k)**2+(x1+x2dash)**2)) \n", + "Tst20BYTst50=((r1+r2dash)**2+(x1+x2dash)**2)/k/((r1/k+r2dash/k)**2+(x1+x2dash)**2) \n", + "#at 20 Hz :\n", + "x11=x1*f1/f #ohm\n", + "x22dash=x2dash*f1/f #ohm\n", + "Ir20ByIr50=(f1/f)*(math.sqrt((r1+r2dash/r1dash)**2+(x1+x2dash)**2))/(math.sqrt((r1+r2dash/r1dash)**2+(x11+x22dash)**2)) \n", + "\n", + "#Result\n", + "print\"(a) Ratio of max torque at 20 Hz to max Torque at 50 Hz : \",round(Tmax20BYTmax50,3)\n", + "print\"(b) Ratio of starting torque at 20 Hz to starting Torque at 50 Hz : \",Tst20BYTst50\n", + "print\"(c) Ratio of rotor current at 20 Hz to rotor current at 50 Hz : \",round(Ir20ByIr50,3)\n", + "print\"\\nNOTE:Answer of rotor current ratio is wrong in the book.\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Ratio of max torque at 20 Hz to max Torque at 50 Hz : 0.863\n", + "(b) Ratio of starting torque at 20 Hz to starting Torque at 50 Hz : 2.08\n", + "(c) Ratio of rotor current at 20 Hz to rotor current at 50 Hz : 0.424\n", + "\n", + "NOTE:Answer of rotor current ratio is wrong in the book.\n" + ] + } + ], + "prompt_number": 14 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.15,Page no:182" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "P=4.0 #[pole]\n", + "f=50.0 #Frequency] Hz\n", + "S=0.04 #[slip]\n", + "r1=0.04 #[Resistance] ohm\n", + "r1dash=0.04 #[Resistance] ohm\n", + "r2dash=0.04 #[Resistance] ohm\n", + "x1=0.2 #ohm\n", + "x2dash=0.2 #ohm\n", + "f1=30.0 #[Frequency new ] Hz\n", + "\n", + "#Calculation\n", + "import numpy as np\n", + "k=f1/f #ratio of frequencies\n", + "S1=k*S #slip\n", + "#For 50 Hz\n", + "#T=3*V1**2*S*r2dash/(2*math.pi*ns)/[(S*r1+r2dash)**2+S**2*(x1+x2dash)**2] \n", + "#For 30 Hz\n", + "#T=3*V1**2/(2*math.pi*ns)*S/(0.6*S1)/[(S/0.6+S/0.6/S1)**2+S**2] \n", + "#0.16445*S1**2-0.74*S1+0.00445=0\n", + "p=[0.16445,-0.074,0.00445] #polynomial for S1\n", + "S1=np.roots(p) \n", + "S1=S1[1] #as another value is for unstable region\n", + "Ns=2*f1/P*60 #rpm\n", + "N=Ns-S1*Ns #rpm\n", + "\n", + "#Result\n", + "print\"Motor speed at 30 Hz operation m : \",round(N),\"rpm (approx)\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Motor speed at 30 Hz operation m : 836.0 rpm (approx)\n" + ] + } + ], + "prompt_number": 17 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.16,Page no:183" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "P=6.0 #[pole]\n", + "f=50.0 #[Frequency] Hz\n", + "S=0.04 #[slip] \n", + "Ton=40.0 #[Torque] N-m\n", + "Toff=30.0 #[Torque at off chopper] N-m\n", + "t_onBYt_off=1.0 #[ratio] \n", + "\n", + "#Calculation\n", + "Ns=2*f/P*60 #rpm\n", + "N=Ns*(1.0-S) #rpm\n", + "Tavg1=(Ton+Toff)/2.0 #N-m\n", + "Navg=math.sqrt((N**2)*Tavg1/Ton) #rpm\n", + "N1=800.0 #rpm\n", + "T=Ton*(N1/N)**2 #N-m\n", + "Tavg2=32.0 #N-m\n", + "#Tavg=32=(Ton*t_on+T*t_off)/(t_on+t_off) #N-m\n", + "tonBYtoff=(T-Tavg2)/(Tavg2-Ton) #\n", + "\n", + "#Result\n", + "print\"Part(a) : \"\n", + "print\"Average torque : \",Tavg1,\"N-m\"\n", + "print\"Average speed : \",round(Navg),\"rpm\"\n", + "print\"Part(b) : \"\n", + "print\"Ratio ton/toff is : \",round(tonBYtoff,4)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Part(a) : \n", + "Average torque : 35.0 N-m\n", + "Average speed : 898.0 rpm\n", + "Part(b) : \n", + "Ratio ton/toff is : 0.5278\n" + ] + } + ], + "prompt_number": 18 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.17,Page no:184" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "from scipy import integrate\n", + "#Variable declaration\n", + "Vrms=415.0 #[rms voltage] volt\n", + "f=50.0 #[Frequency] Hz\n", + "\n", + "#Calculation\n", + "def f(t):\n", + " return(1)\n", + "X=integrate.quad(f,0,2*math.pi/3.0) \n", + "Vdc=Vrms/math.sqrt(1.0/math.pi*X[0])\n", + "\n", + "#Result\n", + "print\"Value of Vdc : \",round(Vdc,2),\"V\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Value of Vdc : 508.27 V\n" + ] + } + ], + "prompt_number": 19 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.18,Page no:184" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "V=400.0 #[Volatge] volt\n", + "f=50.0 #[Frequency] Hz\n", + "P=4.0 #[poles]\n", + "N1=1350.0 #[Rotor speed] rpm\n", + "N2=900.0 #[Rotor speed] rpm\n", + "Rs=1.5 #[Resisatance] ohm\n", + "R=4.0 #[Resistance] ohm\n", + "X=4.0 #[Stator resistance] ohm\n", + "\n", + "#Calculation\n", + "ns=2*f/P*60.0 #rpm\n", + "S=(ns-N1)/ns #slip\n", + "T=3.0/2.0/math.pi/(ns/60)*((V/math.sqrt(3))**2*(P/S)/((Rs+P/S)**2+(R+X)**2))\n", + "T2=T*(N2/N1)**2 #N-m\n", + "Snew=(ns-N2)/ns #slip\n", + "V=math.sqrt((T2/3.0*2.0*math.pi*(ns/60.0))*((Rs+P/Snew)**2+(R+X)**2)/(P/Snew))*math.sqrt(3)\n", + "\n", + "#Calculation\n", + "print\"Torque at 900 rpm : \",round(T2,2),\"N-m\"\n", + "print\"Voltage at speed of 900 rpm : \",round(V,1),\"V\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Torque at 900 rpm : 10.14 N-m\n", + "Voltage at speed of 900 rpm : 176.8 V\n" + ] + } + ], + "prompt_number": 20 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.19,Page no:195" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "V=415.0 #[Voltage] volt\n", + "P=4.0 #[pole]\n", + "f=50.0 #[Frequency] Hz\n", + "N=1370.0 #[Speed] rpm\n", + "r1=2.0 #[Resistance] ohm\n", + "r2dash=3.0 #[Resitance] ohm\n", + "x1=3.5 #[Resitance] ohm\n", + "x2dash=3.5 #ohm\n", + "X0=55.0 #ohm\n", + "\n", + "#Calculation\n", + "Ns=120.0*f/P #rpm\n", + "S=(Ns-N)/Ns #slip\n", + "Nfl=Ns-N #rpm\n", + "Z=(r1+1j*x1)+1j*X0*(r2dash/S+1j*x2dash)/(r2dash/S+1j*(X0+x2dash)) #ohm\n", + "Istator=V/math.sqrt(3)/abs(Z) #A\n", + "I2dash=Istator*(1j*X0/(r2dash/S+1j*(X0+x2dash))) #A\n", + "Tfl=3*abs(I2dash)**2*r2dash/2/math.pi/S/(Ns/60) #N-m\n", + "#Torque is equal so stator current will be same.\n", + "N=1200 #rpm\n", + "Ns=N+Nfl #rpm\n", + "f_inv=4*Ns/120 #Hz\n", + "\n", + "#Result\n", + "print\"Part(a) : \"\n", + "print\"Slip speed : \",Nfl,\"rpm\"\n", + "print\"Stator current: \",round(Istator,2),\"A\"\n", + "print\"Motor torque : \",round(Tfl,2),\"N-m\"\n", + "print\"Part(b) : \" \n", + "print\"Stator current: \",round(Istator,2),\"A\"\n", + "print\"Inverter frequency : \",round(f_inv,2),\"Hz\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Part(a) : \n", + "Slip speed : 130.0 rpm\n", + "Stator current: 7.52 A\n", + "Motor torque : 24.45 N-m\n", + "Part(b) : \n", + "Stator current: 7.52 A\n", + "Inverter frequency : 44.33 Hz\n" + ] + } + ], + "prompt_number": 21 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.20,Page no:196" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "Is=6.0 #[Stator current] A\n", + "f=40.0 #[Frequency] Hz\n", + "SlipSpeed=100.0 #[Slip speed] rpm\n", + "V=415.0 #[Volage] volt\n", + "P=4.0 #[pole]\n", + "r1=2.0 #[Resistance] ohm\n", + "r2dash=3.0#[Resistance] ohm\n", + "x1=3.5 #[Resistance] ohm\n", + "x2dash=3.5 #[Resistance] ohm\n", + "X0=55.0 #[Resistance] ohm\n", + "N=1370.0 #[Motor speed] rpm\n", + "\n", + "#Calculation\n", + "Ns=120.0*50.0/P #rpm\n", + "S=(Ns-N)/Ns #slip\n", + "I2dash=Is*X0/abs(r2dash/S+1j*(X0+x2dash)) #A\n", + "T=3.0*I2dash**2.0*r2dash/(2.0*math.pi*S*(Ns/60.0)) #N-m\n", + "Ns2=120*f/P #rpm\n", + "MotorSpeed=Ns2-SlipSpeed #rpm\n", + "\n", + "#Result\n", + "print\"Rotor current :\",round(I2dash,3),\"A\"\n", + "print\"Full load torque : \",round(T,2),\"N-m\"\n", + "print\"Motor speed : \",MotorSpeed,\"rpm\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Rotor current : 4.855 A\n", + "Full load torque : 15.58 N-m\n", + "Motor speed : 1100.0 rpm\n" + ] + } + ], + "prompt_number": 22 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.20,Page no:205" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "Pout=2500.0 #[Power out] hp\n", + "V=2300.0 #[Voltage] volt\n", + "P=20.0 #[pole]\n", + "f=50.0 #[Frequency] Hz\n", + "Xs=1.77 #[ohm/phase]\n", + "\n", + "#Calculation\n", + "Pout=Pout*735.5/1000.0 #KW\n", + "V=V/math.sqrt(3) #Volt/phase\n", + "cos_theta=1.0 \n", + "I=Pout*10**3.0/3.0/V/cos_theta #A\n", + "Ixs=I*Xs #V\n", + "E=math.sqrt(V**2+Ixs**2) #V\n", + "Pout_max=3*V*E/Xs/1000.0 #KW\n", + "Tmax=Pout_max*1000.0 #synch. Watts\n", + "ns=2*f/P #rps\n", + "Tmax=Pout_max*1000.0/2.0/math.pi/ns #N-m\n", + "\n", + "#Result\n", + "print\"Maximum torque : %.3e\"%Tmax,\"N-m\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Maximum torque : 1.117e+05 N-m\n" + ] + } + ], + "prompt_number": 23 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 6.21,Page no:206" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#Variable declaration\n", + "Pout=2500.0 #[Power out] hp\n", + "V1=2300.0 #[Volatge] volt\n", + "P=20.0 #[pole]\n", + "f=50.0 #[Frequency] Hz\n", + "Xs=1.77 #[ohm/phase]\n", + "\n", + "#Calculation\n", + "Pout=Pout*735.5/1000.0 #KW\n", + "print Pout\n", + "V=V1/math.sqrt(3) #Volt/phase\n", + "cos_theta=1 \n", + "I=Pout*10**3.0/3.0/V/cos_theta #A\n", + "Ixs=I*Xs #V\n", + "E=math.sqrt(V**2.0+Ixs**2) #V\n", + "dell=math.acos(V/E) #degree\n", + "Pout=3*V*E/Xs*math.cos(dell) #W\n", + "\n", + "#Result\n", + "print\"Part(a) Power output : %.3e\"%Pout,\"W\"\n", + "T=Pout #synch. Watts\n", + "N=300 #rpm\n", + "ns=N/60.0 #rps\n", + "T=T/2.0/math.pi/ns #N-m\n", + "print\" Torque in N-m :%.2e\"%T,\"N-m\"\n", + "f1=25 #Hz\n", + "N1=2*f1/P*60 #rpm\n", + "print\"Part(b) Speed : \",N1,\"rpm\"\n", + "T=T*(N1/N)**2 #N-m\n", + "print\" Torque : %.3e\"%T,\"N-m\"\n", + "Vapplied=V1*f1/f #Volts\n", + "print\"Part(b) Applied voltage : \",Vapplied,\"VoltS\"\n", + "Pout=T*2*math.pi*N1/60 #W\n", + "print\"Part(b) Power output:\",round(Pout/1000,2),\"kW\"\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "1838.75\n", + "Part(a) Power output : 2.989e+06 W\n", + " Torque in N-m :9.51e+04 N-m\n", + "Part(b) Speed : 150.0 rpm\n", + " Torque : 2.378e+04 N-m\n", + "Part(b) Applied voltage : 1150.0 VoltS\n", + "Part(b) Power output: 373.59 kW\n" + ] + } + ], + "prompt_number": 24 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file diff --git a/Fundamentals_of_Electric_Drives_and_Control/README.txt b/Fundamentals_of_Electric_Drives_and_Control/README.txt new file mode 100644 index 00000000..555ea5ec --- /dev/null +++ b/Fundamentals_of_Electric_Drives_and_Control/README.txt @@ -0,0 +1,10 @@ +Contributed By: Anubhav Mishra +Course: btech +College/Institute/Organization: Sharda University,Greater Noida +Department/Designation: Electronics & Communication +Book Title: Fundamentals of Electric Drives and Control +Author: B. R. Gupta and V. Singhal +Publisher: S.K Kataria and Sons,New Delhi +Year of publication: 2013 +Isbn: 9789350143810 +Edition: 1 \ No newline at end of file diff --git a/Fundamentals_of_Electric_Drives_and_Control/screenshots/5_17.png b/Fundamentals_of_Electric_Drives_and_Control/screenshots/5_17.png new file mode 100644 index 00000000..8f21991d Binary files /dev/null and b/Fundamentals_of_Electric_Drives_and_Control/screenshots/5_17.png differ diff --git a/Fundamentals_of_Electric_Drives_and_Control/screenshots/5_41.png b/Fundamentals_of_Electric_Drives_and_Control/screenshots/5_41.png new file mode 100644 index 00000000..64b5fca8 Binary files /dev/null and b/Fundamentals_of_Electric_Drives_and_Control/screenshots/5_41.png differ diff --git a/Fundamentals_of_Electric_Drives_and_Control/screenshots/5_9.png b/Fundamentals_of_Electric_Drives_and_Control/screenshots/5_9.png new file mode 100644 index 00000000..d22ca9bb Binary files /dev/null and b/Fundamentals_of_Electric_Drives_and_Control/screenshots/5_9.png differ -- cgit