{
"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": {}
}
]
}