diff options
| author | Thomas Stephen Lee | 2015-08-28 16:53:23 +0530 |
|---|---|---|
| committer | Thomas Stephen Lee | 2015-08-28 16:53:23 +0530 |
| commit | db0855dbeb41ecb8a51dde8587d43e5d7e83620f (patch) | |
| tree | b95975d958cba9af36cb1680e3f77205354f6512 /Electrical_Machines_by_S._K._Bhattacharya | |
| parent | 5a86a20b9de487553d4ef88719fb0fd76a5dd6a7 (diff) | |
| download | Python-Textbook-Companions-db0855dbeb41ecb8a51dde8587d43e5d7e83620f.tar.gz Python-Textbook-Companions-db0855dbeb41ecb8a51dde8587d43e5d7e83620f.tar.bz2 Python-Textbook-Companions-db0855dbeb41ecb8a51dde8587d43e5d7e83620f.zip | |
add books
Diffstat (limited to 'Electrical_Machines_by_S._K._Bhattacharya')
| -rw-r--r-- | Electrical_Machines_by_S._K._Bhattacharya/ch2.ipynb | 1328 | ||||
| -rw-r--r-- | Electrical_Machines_by_S._K._Bhattacharya/ch3.ipynb | 1429 | ||||
| -rw-r--r-- | Electrical_Machines_by_S._K._Bhattacharya/ch4.ipynb | 1509 | ||||
| -rw-r--r-- | Electrical_Machines_by_S._K._Bhattacharya/ch5.ipynb | 989 | ||||
| -rw-r--r-- | Electrical_Machines_by_S._K._Bhattacharya/screenshots/2.png | bin | 0 -> 96108 bytes | |||
| -rw-r--r-- | Electrical_Machines_by_S._K._Bhattacharya/screenshots/4.png | bin | 0 -> 80001 bytes | |||
| -rw-r--r-- | Electrical_Machines_by_S._K._Bhattacharya/screenshots/5.png | bin | 0 -> 107328 bytes |
7 files changed, 5255 insertions, 0 deletions
diff --git a/Electrical_Machines_by_S._K._Bhattacharya/ch2.ipynb b/Electrical_Machines_by_S._K._Bhattacharya/ch2.ipynb new file mode 100644 index 00000000..0db63819 --- /dev/null +++ b/Electrical_Machines_by_S._K._Bhattacharya/ch2.ipynb @@ -0,0 +1,1328 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:cb9aa24547481a3c980ea8f6f78b2ee4b9225336fb41e32a30a8248c4be9ed70" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 2 : Direct Current Machines" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.4 Page No : 92" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Given Data\n", + "P = 2. #number of poles\n", + "Z = 400. #number of conducters\n", + "n = 300. #speed in rpm\n", + "E = 200. #voltage of generator\n", + "A = 2. #number of parallel paths\n", + "N = 1200. #number of turns in each field coil\n", + "\n", + "# Calculations and Results\n", + "phi = (E*60*A)/(Z*n*P) #flux at the end of 0.15sec\n", + "t = 0.15 #time\n", + "print \"magnitude of flux at the end of 15sec is %f wb\"%(phi)\n", + "e = N*(phi/t)\n", + "print \"induced emf in the field coil = %d volts\"%(e)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "magnitude of flux at the end of 15sec is 0.100000 wb\n", + "induced emf in the field coil = 800 volts\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.6 Page No : 93" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Given Data\n", + "P = 8. #number of poles\n", + "A = 8. #number of parallel paths in the armature\n", + "Z = 960. #number of conductors\n", + "N = 400. #speed in rpm\n", + "phi = 0.04 #flux per pole\n", + "\n", + "# Calculations\n", + "E = (phi*Z*N*P)/(60*A) #emf generated onopen circuit condition\n", + "\n", + "# Results\n", + "print \"emf generated on open circuit condition, E = %d volts\"%(E)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "emf generated on open circuit condition, E = 256 volts\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.7 Page No : 97" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Given Data\n", + "E = 180.; #induced emf at 500rpm\n", + "N = 500.; #speed in rpm\n", + "\n", + "# Calculations and Results\n", + "K1 = (E/N)\n", + "print \"K1 = %f\"%(K1)\n", + "E1 = (K1*600) #induced emf at 600rpm\n", + "print \" induced emf at 600rpm is = %d V\"%(E1)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "K1 = 0.360000\n", + " induced emf at 600rpm is = 216 V\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.8 Page No : 97" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Given Data\n", + "E1 = 220.; #induced emf at N1 speed in volts\n", + "N1 = 750.; # speed \n", + "K1 = (E1/N1)\n", + "E2 = 250.; #induced emf at speed N2\n", + "N2 = E2/K1\n", + "print \"speed at induced emf of 250V = %d rpm\"%(N2)\n", + "print (\"when induced emf is 250V and speed 700 rpm\")\n", + "E3 = 250.; #induced emf at N3 speed\n", + "N3 = 700.; #speed\n", + "ratio = (E3*N1)/(E1*N3)\n", + "Pi = (ratio-1)*100\n", + "print \"percentage increase in flux is %f percent\"%(Pi)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "speed at induced emf of 250V = 852 rpm\n", + "when induced emf is 250V and speed 700 rpm\n", + "percentage increase in flux is 21.753247 percent\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.9 Page No : 98" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Given Data\n", + "E = 200. #emf induced\n", + "I = 15. #armature current\n", + "n = 1200. #speed in rpm\n", + "\n", + "# Calculations and Results\n", + "omega = (2*3.14*n)/60;\n", + "print \"omega = %f \"%(omega)\n", + "T = (E*I)/omega;\n", + "print \"electromagnetic torque = %f Nm\"%(T)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "omega = 125.600000 \n", + "electromagnetic torque = 23.885350 Nm\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.10 Page No : 98" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Given Data\n", + "n = 10.; #number of turns in 1 coil\n", + "l = 0.2; \n", + "d = 0.2; #diameter in metres\n", + "B = 1.; #uniform magnetic field density in weber per m**2\n", + "N = 1500.; #speed in rpm\n", + "\n", + "# Calculations and Results\n", + "r = (d/2); #radius in metres\n", + "E = (B*l*((2*3.14*N)/60)*r*2*n);\n", + "print \"total induced emf = %f V\"%(E)\n", + "R = 4; #total resistance in ohms\n", + "I = E/R;\n", + "print \"The current through the armature coil when connected to the load, I = %f A\"%(I)\n", + "T = (E*I)/((2*3.14*N)/60)\n", + "print \"torque = %f Nm\"%(T)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "total induced emf = 62.800000 V\n", + "The current through the armature coil when connected to the load, I = 15.700000 A\n", + "torque = 6.280000 Nm\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.11 Page No : 99" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Given Data\n", + "V = 230.; #armature voltage supply in volts\n", + "Ia = 12.; #armature current in amperes\n", + "Ra = 0.8; #armature resistance in ohms\n", + "N = 100.; #speed in radian per second\n", + "\n", + "# Calculations and Results\n", + "E = (V-(Ia*Ra))\n", + "print \"induced emf, E = %fV\"%(E)\n", + "Te = (E*Ia)/N\n", + "print \"the electromagnetic torque = %fNm\"%(Te)\n", + "Pi = V*Ia\n", + "print \"electrical input to the armature, Pinput = %dW\"%(Pi)\n", + "Pd = Te*N\n", + "print \"mechanical developed = %fW\"%(Pd)\n", + "loss = (Ia**2*Ra)\n", + "print \"armature copper loss = %fW\"%(loss)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "induced emf, E = 220.400000V\n", + "the electromagnetic torque = 26.448000Nm\n", + "electrical input to the armature, Pinput = 2760W\n", + "mechanical developed = 2644.800000W\n", + "armature copper loss = 115.200000W\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.13 Page No : 101" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Given Data\n", + "P = 50000.; #power delivered in watts\n", + "V = 250.; #voltage in volts\n", + "Ra = 0.02; #armature resistance in ohms\n", + "Rf = 50.; #field resistance in ohms\n", + "\n", + "# Calculations and Results\n", + "If = V/Rf #field current in amperes\n", + "Ng = 400.; #speed in generating condition in rpm\n", + "print \"field current, If = %dA\"%(If)\n", + "Il = P/V #load current in amperes\n", + "print \"Load current, If = %dA\"%(Il)\n", + "Ia = If+Il #armature current in amperes\n", + "print \"Aramture current, If = %dA\"%(Ia)\n", + "Eg = (V+(Ia*Ra))\n", + "print (\"At motor condition\")\n", + "Ia = (Il-If)\n", + "print \"Aramture current, If = %dA\"%(Ia)\n", + "Em = (V-(Ia*Ra))\n", + "print \"Em = %fV\"%(Em)\n", + "Nm = (Ng*Em)/Eg\n", + "print \"Speed of the motor = %drpm\"%(Nm)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "field current, If = 5A\n", + "Load current, If = 200A\n", + "Aramture current, If = 205A\n", + "At motor condition\n", + "Aramture current, If = 195A\n", + "Em = 246.100000V\n", + "Speed of the motor = 387rpm\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.14 Page No : 101" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Given Data\n", + "V = 250.; #voltage supply in volts\n", + "Ra = 0.12; #armature resistance in ohms\n", + "Rf = 100.; #field resistance in ohms\n", + "Il = 80.; #load current in amperes\n", + "\n", + "# Calculations and Results\n", + "If = V/Rf \n", + "print \"Field current, If = %f\"%(If)\n", + "print (\"When machine is generating\")\n", + "Ia = Il+If\n", + "Eg = (V+(Ia*Ra))\n", + "print \"Ia = %fA\"%(Ia)\n", + "print \"Eg = %fV\"%(Eg)\n", + "print (\"When machine is motoring\")\n", + "Ia = Il-If\n", + "Em = (V-(Ia*Ra))\n", + "print \"Ia = %fA\"%(Ia)\n", + "print \"Eg = %fV\"%(Em)\n", + "ratio = Eg/Em\n", + "print \"Ratio of speeds = %f\"%(ratio)\n", + "\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Field current, If = 2.500000\n", + "When machine is generating\n", + "Ia = 82.500000A\n", + "Eg = 259.900000V\n", + "When machine is motoring\n", + "Ia = 77.500000A\n", + "Eg = 240.700000V\n", + "Ratio of speeds = 1.079767\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.15 Page No : 102" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Given Data\n", + "V = 550.; #voltage supply in volts\n", + "P = 16.; #number of poles\n", + "N = 150.; #speed in rpm\n", + "Z = 2500.; #number of armature conductors\n", + "A = 16.; \n", + "Power = 1500000.; #power in watt\n", + "Cl = 25000.; #full-load copper loss\n", + "B = 0.9; #flux density in the pole\n", + "\n", + "# Calculations and Results\n", + "Ia = Power/V\n", + "print \"Full load current = %fA\"%(Ia)\n", + "Ra = Cl/(Ia**2)\n", + "print \"Ra = %fohms\"%(Ra)\n", + "E = V+(Ia*Ra)\n", + "print \"Induced emf = %fvolts\"%(E)\n", + "phi = (E*60*A)/(Z*N*P)\n", + "print \"flux density = %fWb/m**2\"%(B)\n", + "print \"flux = %fWb\"%(phi)\n", + "area = (phi/B)\n", + "print \" Area of pole shoe = %fcm**2\"%(area*10000)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Full load current = 2727.272727A\n", + "Ra = 0.003361ohms\n", + "Induced emf = 559.166667volts\n", + "flux density = 0.900000Wb/m**2\n", + "flux = 0.089467Wb\n", + " Area of pole shoe = 994.074074cm**2\n" + ] + } + ], + "prompt_number": 12 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.16 Page No : 103" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Given Data\n", + "Cd = 0.76; #commutator diameter in metres\n", + "Cr = .38; #commutator radius in metres\n", + "bw = 1.5*10**(-2); #brush width in metres\n", + "N = 600.; #speed in rpm\n", + "n = 10.; #speed in rps\n", + "\n", + "# Calculations and Results\n", + "V = Cr*(2*3.14*n); \n", + "print \"peripheral speed of commutator, V = %fm/sec\"%(V);\n", + "Tc = bw/V;\n", + "print \"Time of commutation = %fseconds\"%(Tc)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "peripheral speed of commutator, V = 23.864000m/sec\n", + "Time of commutation = 0.000629seconds\n" + ] + } + ], + "prompt_number": 13 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.17 Page No : 123" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Given Data\n", + "V = 240.; #supply voltage in volts\n", + "N = 800.; #speed in rpm\n", + "Ia = 2.; #armeture current in amperes\n", + "Ra = 0.4; #armature resistance in ohms\n", + "Rf = 160.; #field resistance in ohms\n", + "Il1 = 30.; #line current in amperes\n", + "\n", + "# Calculations and Results\n", + "E = V-(Ia*Ra); #induced emf in volts\n", + "print (\"At no-load\")\n", + "print \"E = %fV\"%(E)\n", + "If = V/Rf; #field current in amperes\n", + "print \"If = %fA\"%(If)\n", + "K1 = E/(If*N);\n", + "print \"K1 = %f\"%(K1)\n", + "print (\"At a load of 30A\")\n", + "Ia1 = (Il1-If);\n", + "E1 = V-(Ia1*Ra);\n", + "N1 = 950; #speed in rpm\n", + "If1 = E1/(K1*N1);\n", + "print \"If1 = %fA\"%(If1);\n", + "Rr = V/If1;\n", + "R = (Rr-Rf);\n", + "print \"Extra resistance required in the field circuit, R = %fohms\"%(R)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "At no-load\n", + "E = 239.200000V\n", + "If = 1.500000A\n", + "K1 = 0.199333\n", + "At a load of 30A\n", + "If1 = 1.207182A\n", + "Extra resistance required in the field circuit, R = 38.810149ohms\n" + ] + } + ], + "prompt_number": 14 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.18 Page No : 124" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Given Data\n", + "V = 230.; #voltage supply in volts\n", + "Ia = 20.; #armature current in amperes\n", + "Ra = 0.5; #armature resistance in ohms\n", + "\n", + "# Calculations and Results\n", + "E = V-(Ia*Ra);\n", + "print \"E = %dV\"%(E)\n", + "print (\"when extra resistance is added in the armature circuit,the speed is halved\")\n", + "E2 = E/2;\n", + "R = ((V-E2)/Ia)-Ra;\n", + "print (\"The load torque is conmath.atant\")\n", + "print \"extra resistance in the armature circui, R = %fohms\"%(R)\n", + "print (\"The load torque directly proportional to square of speed\")\n", + "print (\"if N is halfed, Iais one-fourthed\")\n", + "Ia2 = Ia/4;\n", + "R = ((V-E2)/Ia2)-Ra;\n", + "print \"extra resistance in the armature circui, R = %fohms\"%(R)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "E = 220V\n", + "when extra resistance is added in the armature circuit,the speed is halved\n", + "The load torque is conmath.atant\n", + "extra resistance in the armature circui, R = 5.500000ohms\n", + "The load torque directly proportional to square of speed\n", + "if N is halfed, Iais one-fourthed\n", + "extra resistance in the armature circui, R = 23.500000ohms\n" + ] + } + ], + "prompt_number": 15 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.19 Page No : 125" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Given Data\n", + "V = 250.; #voltage supply in volts\n", + "Ia = 50.; #armature current in amperes\n", + "Ra = 0.3; #armature resistance in ohms\n", + "N = 1000.;\n", + "\n", + "# Calculations and Results\n", + "E = V-(Ia*Ra);\n", + "print \"E = %dV\"%(E)\n", + "print (\"when extra resistance is added in the armature circuit when the speed is 800rpm\")\n", + "N2 = 800.;\n", + "E2 = (E*N2)/N;\n", + "print \"E at 800rpm = %dV\"%(E2)\n", + "R = ((V-E2)/Ia)-Ra;\n", + "print \"extra resistance in the armature circui, R = %fohms\"%(R)\n", + "print (\"if load is halfed,Ia will be halfed\")\n", + "Ia2 = Ia/2;\n", + "E1 = V-(Ia2*(Ra+R));\n", + "print \"E1 = %dV\"%(E1)\n", + "N1 = (N2*E1)/E2;\n", + "print \"N1 = %frpm\"%(N1)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "E = 235V\n", + "when extra resistance is added in the armature circuit when the speed is 800rpm\n", + "E at 800rpm = 188V\n", + "extra resistance in the armature circui, R = 0.940000ohms\n", + "if load is halfed,Ia will be halfed\n", + "E1 = 219V\n", + "N1 = 931.914894rpm\n" + ] + } + ], + "prompt_number": 17 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.20 Page No : 125" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Given Data\n", + "Il = 5.; #current in amperes al no-load\n", + "V = 250.; #voltage in volts\n", + "Rf = 250.; #field resistance in ohms\n", + "\n", + "# Calculations and Results\n", + "If1 = V/Rf; #field current in amperes\n", + "Ia1 = Il-If1; #armature current\n", + "Ra = 0.2; #armature resistance in ohms\n", + "print (\"at a load current of 50A\")\n", + "Il2 = 50; #load current in amperes\n", + "#armature reaction weakens by 3percent\n", + "If2 = 0.97; #current in amperes\n", + "Ia2 = Il2-If2;\n", + "N1 = 1000; \n", + "E1 = (V-(Ia1*Ra));\n", + "E2 = (V-(Ia2*Ra));\n", + "N2 = (N1*E2)/(0.97*E1);\n", + "print \"N2 = %frpm\"%(N2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "at a load current of 50A\n", + "N2 = 993.670467rpm\n" + ] + } + ], + "prompt_number": 18 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.21 Page No : 126" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Given Data\n", + "P = 4; #pole\n", + "V = 500; #shunt motor in volts\n", + "Ia = 60; #armature current in amperes\n", + "Ra = 0.2; #armature resistance in ohms\n", + "\n", + "# Calculations and Results\n", + "E = V-(Ia*Ra)-2;\n", + "print \"voltage drop across each brush = %fV\"%(E)\n", + "phi = 0.03; #flux per pole in Wb\n", + "Z = 720.; #total armature current in volts\n", + "A = 2;\n", + "N = (E*60*A)/(phi*Z*P)\n", + "print \"full load speed of the motor = %frpm\"%(N)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "voltage drop across each brush = 486.000000V\n", + "full load speed of the motor = 675.000000rpm\n" + ] + } + ], + "prompt_number": 19 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.22 Page No : 126" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "# Given Data\n", + "V = 440; #primary voltage in volts\n", + "Ia = 50; #armature current in amperes\n", + "Ra = 0.2; #armature resistance in ohms\n", + "N = 600; #speed in rpm\n", + "E = V-(Ia*Ra); #emf induced in volts before adding extra resistance\n", + "#E = K*phi*N = K1*Ia*N\n", + "K1 = E/(Ia*N);\n", + "\n", + "# Calculations and Results\n", + "#we have the relation T = Kt1*Ia**2, T1 = Kt1*Ia1**2\n", + "#when torque is half, say torque be T1\n", + "#T1 = T/2. r = T/T1\n", + "r = 2;\n", + "Ia1 = math.sqrt(Ia**2/r);\n", + "print \"Ia1 = %fA\"%(Ia1);\n", + "#extra resistance R is introduced in the circuit\n", + "N1 = 400;\n", + "E1 = (K1*Ia1*N1);\n", + "R = ((V-E1)/Ia1)-Ra;\n", + "print \"value of extra resistance added = %fohms\"%(R)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Ia1 = 35.355339A\n", + "value of extra resistance added = 6.511746ohms\n" + ] + } + ], + "prompt_number": 21 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.23 Page No : 127" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Given Data\n", + "V = 200.; #voltage in volts\n", + "Ia = 20.; #armature current in amperes\n", + "Ra = 0.5; #armature resistance in ohms\n", + "Rse = 0.2; #field winding resistance in ohms\n", + "\n", + "# Calculations and Results\n", + "E = V-(Ia*(Ra+Rse));\n", + "print \"In first case, E = %fV\"%(E)\n", + "#E = k*phi*N\n", + "N = 1000; #speed in rpm\n", + "Kphi = E/N; \n", + "#a resistance R is connected in parallel with the series field which is called diverter\n", + "print (\"when resistace R is added and new conditions\")\n", + "I = 20; #total current flowing\n", + "#current is equally devided between series field and diverter\n", + "Ise2 = I/2;\n", + "#flux at 10A current is 20percent of flux at 20A current\n", + "p = 0.70; #percentage of flux\n", + "Kpih1 = p*Kphi;\n", + "E1 = (V-((Ia*Ra)+(Ise2*Rse)));\n", + "print \"Induced emf = %fV\"%(E1)\n", + "#new speed is N1\n", + "N1 = E1/(p*Kphi)\n", + "print \"N1 = %frpm\"%(N1)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "In first case, E = 186.000000V\n", + "when resistace R is added and new conditions\n", + "Induced emf = 188.000000V\n", + "N1 = 1443.932412rpm\n" + ] + } + ], + "prompt_number": 22 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.24 Page No : 128" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "V = 200.; #motor runs in volts\n", + "Ia = 15.; #current taken in amperes\n", + "Ra = 1.; #motor resistance in ohms\n", + "\n", + "# Calculations and Results\n", + "E1 = V-(Ia*Ra);\n", + "print \"resistance when 1ohm = %fV\"%(E1)\n", + "R = 5; #resistance \n", + "E2 = V-(Ia*(Ra+R))\n", + "print \"resistance when 5ohms connected in series = %fV\"%(E2)\n", + "N1 = 800; #speed of motor in rpm\n", + "N2 = N1*(E2/E1);\n", + "print \"speed at which motor will run when resistance is 5ohms = %frpm\"%(N2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "resistance when 1ohm = 185.000000V\n", + "resistance when 5ohms connected in series = 110.000000V\n", + "speed at which motor will run when resistance is 5ohms = 475.675676rpm\n" + ] + } + ], + "prompt_number": 23 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.25 Page No : 135" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "P = 8.; #pole\n", + "Z = 107.; #generator with slots\n", + "Ia = 1000.; #current containing in amperes\n", + "Bag = 0.32; #gap flux density in Wb/m**2\n", + "lg = 0.012; #interpole air gap in meters\n", + "pi = 3.14;\n", + "\n", + "# Calculations\n", + "Mu = (4*pi*10**-7)\n", + "AT = (((Ia*Z)/(2*P))+((Bag*lg)/Mu));\n", + "\n", + "# Results\n", + "print \"current for each commutating pole = %f\"%(AT)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "current for each commutating pole = 9744.824841\n" + ] + } + ], + "prompt_number": 24 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.26 Page No : 135" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "Bag = 0.3; #flux density in the interpole air gap in Wb/m**2\n", + "\n", + "# Calculations and Results\n", + "Ia = 200000./200; #armature current in amperes\n", + "print \"Armature current = %f\"%(Ia)\n", + "Z = 540.; #Number of armature conductors\n", + "Zt = 540./2; #Number armature winding turns \n", + "print \"Number armature winding turns = %f\"%(Zt)\n", + "A = 6.; #the winding lap\n", + "Ap = Zt/A; #Number of armature turns per parallel path\n", + "print \"Number of armature turns per parallel path = %f\"%(Ap)\n", + "P = 6; #pole\n", + "Np = ((Ia*Ap)/P);\n", + "print \"Number of armature ampere turns per pole = %f\"%(Np)\n", + "lg = 0.01; #inter pole air gap in meters\n", + "pi = 3.14;\n", + "Mu = (4*pi*10**-7)\n", + "Nipg = ((Bag*lg)/Mu); #Air gap\n", + "print \"ampere turns for the air gap = %f\"%(Nipg)\n", + "NipI = (Np+Nipg); #total interpole ampere\n", + "print \"Total interpole ampere turns = %f\"%(NipI)\n", + "Nip = (NipI/Ia);\n", + "print \"Number of turns needed on each commutating pole = %f\"%(Nip)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Armature current = 1000.000000\n", + "Number armature winding turns = 270.000000\n", + "Number of armature turns per parallel path = 45.000000\n", + "Number of armature ampere turns per pole = 7500.000000\n", + "ampere turns for the air gap = 2388.535032\n", + "Total interpole ampere turns = 9888.535032\n", + "Number of turns needed on each commutating pole = 9.888535\n" + ] + } + ], + "prompt_number": 25 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.27 Page No : 128" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "N = 960.; #speed in rpm\n", + "F = 23.; #effictive load in kgf\n", + "\n", + "# Calculations and Results\n", + "r = 45./2; #radius of the drum\n", + "print \"radius of the drum = %fcm\"%(r)\n", + "pi = 3.14;\n", + "OP = (2*pi*N*F*r*9.81)/(60*100);\n", + "print \"output power = %fW\"%(OP)\n", + "\n", + "Vi = 230.; #motor input in volts\n", + "Ci = 28.; #input current in amperes\n", + "IP = (Vi*Ci);\n", + "print \"input power = %fW\"%(IP)\n", + "Effi = (OP/IP)*100;\n", + "print \"Efficiency of the motor = %fpercent\"%(Effi)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "radius of the drum = 22.500000cm\n", + "output power = 5101.043040W\n", + "input power = 6440.000000W\n", + "Efficiency of the motor = 79.208743percent\n" + ] + } + ], + "prompt_number": 26 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.29 Page No : 145" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "I = 440.; #input at no-load in watt\n", + "V = 220.; #voltage in volts\n", + "Ic = I/V; #input current at no-load in amperes\n", + "i = 1; #input current in amperes\n", + "A = 2; #current in amperes\n", + "C = A-i; #armature current at no-load in amperes\n", + "L = I-((((C)**2)*0.5)+(V*C)); #iron,friction and windage losses in watt\n", + "a = 40; #motor current in amperes\n", + "OP = (V*a);\n", + "Ra = 0.5;\n", + "\n", + "# Calculations and Results\n", + "Effi = (OP*100)/(OP+(((a+i)**2)*Ra)+(V*i)+L)\n", + "print \"Efficiency as a generator when delivering 40A at 220V = %fpercent\"%(Effi)\n", + "Eff = ((OP-(((a-i)**2)*Ra)-(V*C)-L)/OP)*100;\n", + "print \"Efficiency as a motor when taking 40A from at 220V = %fpercent\"%(Eff)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Efficiency as a generator when delivering 40A at 220V = 87.301587percent\n", + "Efficiency as a motor when taking 40A from at 220V = 86.363636percent\n" + ] + } + ], + "prompt_number": 27 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.30 Page No : 147" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "V = 400.; #motor in volts\n", + "Rf = 200.; #field resistance in ohms\n", + "If = V/Rf; #current in amperes\n", + "i = 5; #current at no load in amperes\n", + "IP = V*i; #motor input at no load\n", + "Ia = 3; #aramture current in amperes\n", + "Ra = 0.5; #armature resistance in ohms\n", + "\n", + "# Calculations and Results\n", + "L = IP-(((Ia)**2)*Ra)-(V*If); #iron,friction and windage in losses in watt\n", + "print \"iron, friction and windage in losses = %fW\"%(L)\n", + "At = 50.; #armature total current in amperes\n", + "A = At-2; #armature current in amperes\n", + "Ls = (((A)**2)*Ra)+(V*If)+L; #Losses\n", + "Eff = (((V*At)-Ls)/(V*At))*100;\n", + "print \"Efficiency of full load = %fpercent\"%(Eff)\n", + "#flux is consmath.tant\n", + "E1 = V-(Ia*Ra); #induced emf in the armature at no load\n", + "E2 = V-(A*Ra); #induced emf in the armature at full load\n", + "# math.since N1/N2 = E1/E2\n", + "percentload = (1-(E2/E1))*100;\n", + "print \"Percentage change in speed from no load to full load = %fpercent\"%(percentload)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "iron, friction and windage in losses = 1195.500000W\n", + "Efficiency of full load = 84.262500percent\n", + "Percentage change in speed from no load to full load = 5.646173percent\n" + ] + } + ], + "prompt_number": 29 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.31 Page No : 148" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "Ra = 0.5; #armature resistance in ohms\n", + "Rf = 750.; #field circuit resistance in ohms\n", + "V = 500.; #voltage in volts\n", + "\n", + "# Calculations\n", + "If = V/Rf; #current in amperes \n", + "l = 3.; #line current in amperes\n", + "i = 2.33; #current in motor in amperes\n", + "I = 0.67; #current i amperes\n", + "L = (V*l)-(((i)**2)*Ra)-(V*I); #Iron,friction and windage losses\n", + "O = 20.; #generator \n", + "OP = (O*1000)/V; #output current of the generator under loaded condition in amperes\n", + "Ia = I+OP; #output in amperes\n", + "Effi = (O*1000*100)/((O*1000)+(((Ia)**2)*Ra)+(V*I)+L);\n", + "\n", + "# Results\n", + "print \"efficiency of the machine = %fpercent\"%(Effi)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "efficiency of the machine = 89.588435percent\n" + ] + } + ], + "prompt_number": 30 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.32 Page No : 149" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "Ig = 25.; #current of generator in amperes\n", + "I = 30.; #current in motor in amperes\n", + "Il = I-Ig; #current in amperes\n", + "Ra = 0.25; #resistance in ohms\n", + "Gl = ((Ig)**2)*Ra; #loss in generator in watt\n", + "M = ((I)**2)*Ra; #loss in motor in watt\n", + "T = Gl+M; #total loss in watt\n", + "V = 100.; #voltage in volts\n", + "P = V*Il; #power supplied from mains in watt\n", + "L = P-T; #iron,friction and windages losses in the two machines in ohms\n", + "l = L/2; #iron,friction and windages losses in each machines in ohms\n", + "IP = I*V; #input\n", + "\n", + "# Calculations and Results\n", + "Eff = ((IP-M-l)/IP)*100;\n", + "print \"Efficiency of the motor = %fpercent\"%(Eff)\n", + "OP = Ig*V; #output\n", + "Effi = ((OP)/(OP+Gl+l))*100;\n", + "print \"Efficiency of the generator = %fpercent\"%(Effi)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Efficiency of the motor = 90.520833percent\n", + "Efficiency of the generator = 92.059839percent\n" + ] + } + ], + "prompt_number": 31 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.33 Page No : 150" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "V = 440.; #voltage in volts\n", + "P = 200.*1000; #power in watt\n", + "Ig = P/V; #rated current of each machine in amperes\n", + "\n", + "# Calculations\n", + "#assume losses to be equal\n", + "I = 90; #addition currnet supply\n", + "Effi = math.sqrt(Ig/(Ig+I))*100;\n", + "\n", + "# Results\n", + "print \"approximate efficiency = %fpercent\"%(Effi)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "approximate efficiency = 91.363261percent\n" + ] + } + ], + "prompt_number": 32 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 2.34 Page No : 150" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "Ig = 2000.; #output current of generator in amperes\n", + "I = 380.; #Input current from supply mains in amperes\n", + "\n", + "# Calculations and Results\n", + "Effi = math.sqrt(Ig/(Ig+I))*100; #Efficiency of generator assuming equal efficiencies of the two machines\n", + "print \"Efficiences of the generator at full load assuming equal efficiencies = %fpercent\"%(Effi)\n", + "S = 22.; #Shunt field current of generator\n", + "G = Ig+S; #Armature current of generator in amperes\n", + "R = 0.01; #resistance of the armature circuit of each machine in ohms\n", + "Gc = ((G)**2)*R; #copper loss in arrmature circuit of generator in W\n", + "V = 500.; #Voltage in volts\n", + "L = V*S; #loss in the field circuit of the generator in W\n", + "T = Ig+I; #total current suuply in amperes\n", + "Sf = 17.; #shunt field current of motor in amperes\n", + "A = T-Sf; #armature current in motor in amperes\n", + "Lc = ((A)**2)*R; #loss in armature circuit of motor in amperes\n", + "Lf = V*Sf; #loss in the shunt field circuit of motor in W\n", + "Tin = V*I; #total input to motor and generator in W\n", + "Ml = Tin-(Gc+L+Lc+Lf); #iron,friction and windage loss in both machines in W\n", + "Me = Ml/2; #iron,friction and windage loss in each machine in W\n", + "p = 1000.; #power in kW\n", + "OP = (Ig*V)/p; #full load output of the generator\n", + "Eff = (p*100)/(p+((Gc+L+Me)/1000));\n", + "print \"Efficiency of the generator at full load = %fpercent\"%(Eff)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Efficiences of the generator at full load assuming equal efficiencies = 91.669850percent\n", + "Efficiency of the generator at full load = 91.846461percent\n" + ] + } + ], + "prompt_number": 33 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Electrical_Machines_by_S._K._Bhattacharya/ch3.ipynb b/Electrical_Machines_by_S._K._Bhattacharya/ch3.ipynb new file mode 100644 index 00000000..09c62b0c --- /dev/null +++ b/Electrical_Machines_by_S._K._Bhattacharya/ch3.ipynb @@ -0,0 +1,1429 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:f7ea291c8e2293a8fc339d930ac29424b99d2f3c6350ea4ec55a2d06cfae4c2d" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 3 : Transformers" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.1 Page No : 196" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "kVA = 500.; #rating\n", + "V1 = 11000.; #primary voltage in volts\n", + "V2 = 400.; #secondary voltage in volts\n", + "N2 = 100.; #number of turns in secondary winding\n", + "f = 50.; #frequency in hertz\n", + "\n", + "# Calculations and Results\n", + "N1 = (V1*N2)/V2; #number of turns in primary winding\n", + "print \"number of turns in primary winding, N1 = %dturns\"%(N1)\n", + "I1 = (kVA*1000)/V1;\n", + "I2 = (kVA*1000)/V2\n", + "print \"primary current, I1 = %fA\"%(I1)\n", + "print \"secondary current, I2 = %fA\"%(I2)\n", + "E1 = V1;\n", + "phi = E1/(4.44*f*N1)\n", + "print \"maximium flux in the core = %fWb\"%(phi)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "number of turns in primary winding, N1 = 2750turns\n", + "primary current, I1 = 45.454545A\n", + "secondary current, I2 = 1250.000000A\n", + "maximium flux in the core = 0.018018Wb\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.2 Page No : 196" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "V1 = 6600.; #primary voltage in volts\n", + "V2 = 230.; #secondary voltage in volts\n", + "f = 50.; #frequency in hertz\n", + "Bm = 1.1; #flux density in Wb/m**2\n", + "\n", + "# Calculations and Results\n", + "A = (25*25*10**(-4)); #area of the core in m**2\n", + "phi = Bm*A\n", + "print \"flux = %fWb\"%(phi)\n", + "E1 = V1;\n", + "E2 = V2;\n", + "N1 = E1/(4.44*f*phi);\n", + "N2 = E2/(4.44*f*phi);\n", + "print \"number of turns in primary winding, N1 = %dturns\"%(N1)\n", + "print \"number of turns in secondary winding, N2 = %dturns\"%(N2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "flux = 0.068750Wb\n", + "number of turns in primary winding, N1 = 432turns\n", + "number of turns in secondary winding, N2 = 15turns\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.3 Page No : 197" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Given Data\n", + "V1 = 230.; #primary voltage in volts\n", + "f = 50.; #frequency in hertz\n", + "N1 = 100.; #number of primary turns\n", + "N2 = 400.; #number of secondary turns\n", + "\n", + "# Calculations and Results\n", + "A = 250.*10**(-4); #cross section area of core in m**2\n", + "print (\"since at no-load E2 = V2\")\n", + "E2 = (V1*N2)/N1;\n", + "print \"induced secondary winding, E2 = %dV\"%(E2);\n", + "phi = E2/(4.44*f*N2);\n", + "Bm = phi/A;\n", + "print \"Maximium flux density in the core = %fWb/m**2\"%(Bm)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "since at no-load E2 = V2\n", + "induced secondary winding, E2 = 920V\n", + "Maximium flux density in the core = 0.414414Wb/m**2\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.4 Page No : 197" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "kVA = 40.; #rating of the transformer\n", + "V1 = 2000.; #primary side voltage in volts\n", + "V2 = 250.; #secondary side voltage in volts\n", + "R1 = 1.15; #primary resistance in ohms\n", + "R2 = 0.0155; #secondary resistance in ohms\n", + "\n", + "# Calculations and Results\n", + "R = R2+(((V2/V1)**2)*R1)\n", + "print \"Total resistance of the transformer in terms of the secondary winding = %fohms\"%(R)\n", + "I2 = (kVA*1000)/V2;\n", + "print \"Full load secondary current = %dA\"%(I2)\n", + "print \"Total resistance load on full load = %fVolts\"%(I2*R)\n", + "print \"Total copper loss on full load = %fWatts\"%((I2)**2*R)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Total resistance of the transformer in terms of the secondary winding = 0.033469ohms\n", + "Full load secondary current = 160A\n", + "Total resistance load on full load = 5.355000Volts\n", + "Total copper loss on full load = 856.800000Watts\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.5 Page No : 206" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "# Given Data\n", + "I2 = 300.; #Secondary current in amperes\n", + "N1 = 1200.; #number of primary turns\n", + "N2 = 300.; #number of secondary turns\n", + "I0 = 2.5; #load current in amperes\n", + "\n", + "# Calculations\n", + "I1 = (I2*N2)/N1;\n", + "phi0 = math.degrees(math.acos(0.2));\n", + "phi2 = math.degrees(math.acos(0.8));\n", + "I1c = (I1*math.cos(math.radians(phi2)))+(I0*math.cos(math.radians(phi0)));\n", + "I1s = (I1*math.sin(math.radians(phi2)))+(I0*math.sin(math.radians(phi0)));\n", + "I = math.sqrt(I1c**2+I1s**2);\n", + "phi = math.radians(math.atan(I1s/I1c))\n", + "\n", + "# Results\n", + "print \"primary power factor = %fdegrees\"%(math.cos(math.radians(phi)));" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "primary power factor = 1.000000degrees\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.6 Page No : 207" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "# Given Data\n", + "I0 = 1.5; #no-load current\n", + "phi0 = math.degrees(math.acos(0.2))\n", + "I2 = 40; #secondary current in amperes\n", + "phi2 = math.degrees(math.acos(0.8))\n", + "r = 3; #ratio of primary and secondary turns\n", + "I1 = I2/r; \n", + "\n", + "# Calculations\n", + "I1c = (I1*math.cos(math.radians(phi2)))+(I0*math.cos(math.radians(phi0)));\n", + "I1s = (I1*math.sin(math.radians(phi2)))+(I0*math.sin(math.radians(phi0)));\n", + "I = math.sqrt(I1c**2+I1s**2);\n", + "\n", + "# Results\n", + "print \"I1 = %fA\"%(I)\n", + "\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "I1 = 14.156879A\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.7 Page No : 208" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Given Data\n", + "V1 = 230.; #voltage in volts\n", + "f = 50.; #frequency of supply in hertz\n", + "N1 = 250.; #number of primary turns\n", + "I0 = 4.5; #no-load current in amperes\n", + "\n", + "# Calculations and Results\n", + "phi0 = math.degrees(math.acos(0.25));\n", + "Im = I0*math.sin(math.radians(phi0))\n", + "print \"magnetimath.sing current, Im = %fA\"%(Im);\n", + "\n", + "Pc = V1*I0*math.cos(math.radians(phi0));\n", + "print \"Core loss = %dW\"%(Pc)\n", + "print (\"neglecting I**2R loss in primary winding at no-load\")\n", + "E1 = V1;\n", + "phi = E1/(4.44*f*N1);\n", + "print \"Maximium value of flux in the core = %fWb\"%(phi)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "magnetimath.sing current, Im = 4.357106A\n", + "Core loss = 258W\n", + "neglecting I**2R loss in primary winding at no-load\n", + "Maximium value of flux in the core = 0.004144Wb\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.8 Page No : 209" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Given Data\n", + "I2 = 30.; #Secondary current in amperes\n", + "I0 = 2.; #load current in amperes\n", + "V1 = 660.; #primary voltage in volts\n", + "V2 = 220.; #secondary voltage in volts\n", + "\n", + "# Calculations\n", + "I1 = (I2*V2)/V1;\n", + "phi0 = math.degrees(math.acos(0.225));\n", + "phi2 = math.degrees(math.acos(0.9));\n", + "I1c = (I1*math.cos(math.radians(phi2)))+(I0*math.cos(math.radians(phi0)));\n", + "I1s = (I1*math.sin(math.radians(phi2)))+(I0*math.sin(math.radians(phi0)));\n", + "I = math.sqrt(I1c**2+I1s**2);\n", + "phi = math.degrees(math.atan(I1s/I1c))\n", + "\n", + "# Results\n", + "print \"I1 = %fA\"%(I)\n", + "print \"primary power factor = %fdegrees\"%(math.cos(math.radians(phi)));\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "I1 = 11.361713A\n", + "primary power factor = 0.831741degrees\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.9 Page No : 210" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Given Data\n", + "phi_m = 7.5*10**(-3); #maximium flux\n", + "f = 50.; #frequecy in hertz\n", + "N1 = 144.; #number of primary turns\n", + "N2 = 432.; #number of secondary turns\n", + "kVA = 0.24; #rating of transformer\n", + "\n", + "# Calculations and Results\n", + "E1 = (4.44*phi_m*f*N1)\n", + "V1 = E1;\n", + "print \"V1 = %dV\"%(V1)\n", + "I0 = (kVA*1000)/V1;\n", + "phi0 = math.degrees(math.acos(0.26));\n", + "Im = I0*math.sin(math.radians(phi0));\n", + "print \"Im = %fA\"%(Im);\n", + "V2 = (E1*N2)/N1\n", + "print \"V2 = %fV\"%(V2)\n", + "print (\"At a load of 1.2kVA and power factor of 0.8 lagging\")\n", + "kVA = 1.2;\n", + "phi2 = math.degrees(math.acos(0.8));\n", + "I2 = (kVA*1000)/V2;\n", + "I = (I2*N2)/N1;\n", + "I1c = (I*math.cos(math.radians(phi2)))+(I0*math.cos(math.radians(phi0)));\n", + "I1s = (I*math.sin(math.radians(phi2)))+(I0*math.sin(math.radians(phi0)));\n", + "I = math.sqrt(I1c**2+I1s**2);\n", + "print \"I1 = %fA\"%(I);\n", + "phi = math.degrees(math.acos(((I*math.cos(math.radians(phi2)))+(I0*math.cos(math.radians(phi0))))/I));\n", + "print \"primary power factor = %flagging\"%(math.cos(math.radians(phi)))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "V1 = 239V\n", + "Im = 0.966575A\n", + "V2 = 719.280000V\n", + "At a load of 1.2kVA and power factor of 0.8 lagging\n", + "I1 = 5.825933A\n", + "primary power factor = 0.844673lagging\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.10 Page No : 211" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "# Given Data\n", + "V1 = 6600.; #primary voltage in volts\n", + "V2 = 240.; #secondary voltage in volts\n", + "kW1 = 10.; #power\n", + "phi1 = math.degrees(math.acos(0.8));\n", + "I2 = 50.; #current in amperes\n", + "kW3 = 5.; #power\n", + "phi2 = math.degrees(math.acos(0.7))\n", + "kVA = 8; #rating\n", + "phi4 = math.degrees(math.acos(0.6)) \n", + "\n", + "# Calculations and Results\n", + "I1 = (kW1*1000)/(math.cos(math.radians(phi1))*V2);\n", + "I3 = (kW3*1000)/(1*V2);\n", + "I4 = (kVA*1000)/V2;\n", + "Ih = ((I1*math.cos(math.radians(phi1)))+(I2*math.cos(math.radians(phi2)))+I3+(I4*math.cos(math.radians(phi4))));\n", + "Iv = ((I1*math.sin(math.radians(phi1)))+(I2*math.sin(math.radians(phi2)))-(I4*math.sin(math.radians(phi4))));\n", + "I5 = math.sqrt((Ih**2)+(Iv**2))\n", + "print \"I5 = %dA\"%(I5)\n", + "Ip = (I5*V2)/V1;\n", + "print \"The current drawn by the primary from 6600Vmains is equal to, Ip = %fA\"%(Ip);\n", + "phi = math.degrees(math.atan(Iv/Ih));\n", + "print \"power factor = %flagging\"%math.cos(math.radians(phi))\n", + "\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "I5 = 124A\n", + "The current drawn by the primary from 6600Vmains is equal to, Ip = 4.516939A\n", + "power factor = 0.945934lagging\n" + ] + } + ], + "prompt_number": 12 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.11 Page No : 212" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Given Data\n", + "kVA = 100.; #rating of the tronsfromer\n", + "N1 = 400.; #number of primary turns\n", + "N2 = 80.; #number of secondary turns\n", + "R1 = 0.3; #primary resistance in ohms\n", + "R2 = 0.01; #secondary resistance in ohms\n", + "X1 = 1.1; #primary leakage reactance in ohs\n", + "X2 = 0.035; #secondary leakage reactance in ohms\n", + "\n", + "# Calculations and Results\n", + "Rr2 = (((N1/N2)**2)*R2)\n", + "print \"R2 = %f ohms\"%(Rr2);\n", + "Xx2 = (((N1/N2)**2)*X2);\n", + "print \"X2 = %f ohms\"%(Xx2);\n", + "Ze = math.sqrt((R1+Rr2)**2+(X1+Xx2)**2);\n", + "print \"Equivqlent impedence = %f\"%(Ze);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "R2 = 0.250000 ohms\n", + "X2 = 0.875000 ohms\n", + "Equivqlent impedence = 2.050152\n" + ] + } + ], + "prompt_number": 13 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.12 Page No : 216" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "f = 50.; #frequency in hertz\n", + "r = 6.; #turns ratio\n", + "R1 = 0.90; #primary resistance in ohms\n", + "R2 = 0.03; #secondary resistance in ohms\n", + "X1 = 5.; #primary reactance in ohms\n", + "X2 = 0.13; #secondary reactance in ohms\n", + "I2 = 200.; #full-load current\n", + "\n", + "# Calculations and Results\n", + "Re = (R1+(R2*r**2));\n", + "print \"equivalent resistance reffered to primary, Re = %fohms\"%(Re);\n", + "Xe = (X1+(X2*r**2));\n", + "print \"equivalent reactance reffered to primary, Xe = %fohms\"%(Xe);\n", + "Ze = math.sqrt(Re**2+Xe**2);\n", + "print \"equivalent impedance reffered to primary, Ze = %fohms\"%(Ze);\n", + "Ii2 = r*I2;\n", + "print \"secondary current reffered to primary side = %fA\"%(Ii2);\n", + "print \"a)Voltage to be applied to the high voltage side = %dvolts\"%(Ii2*Ze);\n", + "print \"b)Power factor = %f\"%(Re/Ze);\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "equivalent resistance reffered to primary, Re = 1.980000ohms\n", + "equivalent reactance reffered to primary, Xe = 9.680000ohms\n", + "equivalent impedance reffered to primary, Ze = 9.880425ohms\n", + "secondary current reffered to primary side = 1200.000000A\n", + "a)Voltage to be applied to the high voltage side = 11856volts\n", + "b)Power factor = 0.200396\n" + ] + } + ], + "prompt_number": 14 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.13 Page No : 216" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "R1 = 0.21; #primary resistance in ohms\n", + "X1 = 1.; #primary reactance in ohms\n", + "R2 = 2.72*10**(-4); #secondary resistance in ohms\n", + "X2 = 1.3*10**(-3); #secondary reactanced in ohms\n", + "V1 = 6600.; #primary voltage in volts\n", + "V2 = 250.; #secondary voltage in volts\n", + "\n", + "# Calculations and Results\n", + "r = V1/V2; #turns ratio\n", + "Re = R1+(r**2*R2);\n", + "print \"Equivalent resistance referred to primary side = %fohms\"%(Re);\n", + "Xe = X1+(r**2*X2);\n", + "print \"Equivalent reactance referred to primary side = %fohms\"%(Xe);\n", + "Ze = math.sqrt(Re**2+Xe**2);\n", + "print \"equivalent impedance reffered to primary, Ze = %fohms\"%(Ze);\n", + "V = 400.; #voltage in volts\n", + "I1 = V/Ze;\n", + "print \"I1 = %f\"%(I1);\n", + "print \"Power input = %fW\"%(I1**2*Re);\n", + "\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Equivalent resistance referred to primary side = 0.399573ohms\n", + "Equivalent reactance referred to primary side = 1.906048ohms\n", + "equivalent impedance reffered to primary, Ze = 1.947480ohms\n", + "I1 = 205.393656\n", + "Power input = 16856.612924W\n" + ] + } + ], + "prompt_number": 17 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.14 Page No : 217" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "N1 = 90.; #number of primary turns\n", + "N2 = 180.; #number of secondary turns\n", + "R1 = 0.067; #primary resistance in ohms\n", + "R2 = 0.233; #secondary resistance in ohms\n", + "\n", + "# Calculations and Results\n", + "print \"Primary winding resistance referred to secondary side = %fohms\"%((R1*N2/N1)**2)\n", + "print \"secondary winding resistance referred to primary side = %fohms\"%((R2*N1/N2)**2)\n", + "print \"Total resistance of the transformer refferred to primary side = %fohms\"%((((R1*N2/N1)**2)+R2*N2/N1)**2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Primary winding resistance referred to secondary side = 0.017956ohms\n", + "secondary winding resistance referred to primary side = 0.013572ohms\n", + "Total resistance of the transformer refferred to primary side = 0.234213ohms\n" + ] + } + ], + "prompt_number": 18 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.15 Page No : 217" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "kVA = 30.; #rating of the transformer\n", + "V1 = 6000.; #primary voltage in volts\n", + "V2 = 230.; #secondary voltage in volts\n", + "R1 = 10.; #primary resistance in ohms\n", + "R2 = 0.016; #secondary resistance in ohms\n", + "Xe = 23.; #total reactance reffered to the primary\n", + "\n", + "# Calculations and Results\n", + "phi = math.degrees(math.acos(0.8)); #lagging\n", + "Re = (R1+((V1/V2)**2*R2))\n", + "print \"equivalent resistance, Re = %fohms\"%(Re)\n", + "I2dash = (kVA*1000)/V1;\n", + "V2dash = 5847;\n", + "Reg = ((I2dash*((Re*math.cos(math.radians(phi)))+(Xe*math.sin(math.radians(phi)))))*100)/V2dash;\n", + "print \"percentage regulation = %fpercent\"%(Reg)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "equivalent resistance, Re = 20.888469ohms\n", + "percentage regulation = 2.609097percent\n" + ] + } + ], + "prompt_number": 19 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.16 Page No : 218" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "kVA = 10.; #rating of the transformer\n", + "V1 = 2000.; #primary voltage in volts\n", + "V2 = 400.; #secondary voltage in volts\n", + "R1 = 5.5; #primary voltage in ohms\n", + "R2 = 0.2; #secondary voltage in ohms\n", + "X1 = 12.; #primary reactance in ohms\n", + "X2 = 0.45; #secondary reactance in ohms\n", + "\n", + "# Calculations and Results\n", + "#assuming (V1/V2) = (N1/N2)\n", + "Re = R2+(R1*(V2/V1)**2);\n", + "print \"equivalent resistance referred to the secondary = %fohms\"%(Re);\n", + "Xe = X2+(X1*(V2/V1)**2);\n", + "print \"equivalent reactance referred to the secondary = %fohms\"%(Xe);\n", + "Ze = math.sqrt(Re**2+Xe**2);\n", + "print \"equivalent impedance referred to the secondary = %fohms\"%(Ze);\n", + "phi = math.degrees(math.acos(0.8));\n", + "Vl = 374.5;\n", + "print \"Voltage across the full load and 0.8 p.f lagging = %fV\"%(Vl);\n", + "reg = ((V2-Vl)*100)/Vl;\n", + "print \"percentage voltage regulation = %f percent\"%(reg);\n", + "\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "equivalent resistance referred to the secondary = 0.420000ohms\n", + "equivalent reactance referred to the secondary = 0.930000ohms\n", + "equivalent impedance referred to the secondary = 1.020441ohms\n", + "Voltage across the full load and 0.8 p.f lagging = 374.500000V\n", + "percentage voltage regulation = 6.809079 percent\n" + ] + } + ], + "prompt_number": 20 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.17 Page No : 219" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "kVA = 80.; #rating of the transformer\n", + "V1 = 2000.; #primary voltage in volts\n", + "V2 = 200.; #secondary voltage in volts\n", + "f = 50.; #frequency in hertz\n", + "Id = 8.; #impedence drop\n", + "Rd = 4.; #resistance drop\n", + "\n", + "# Calculations and Results\n", + "phi = math.degrees(math.acos(0.8))\n", + "I2Ze = (V2*Id)/100;\n", + "I2Re = (V2*Rd)/100;\n", + "I2Xe = math.sqrt(I2Ze**2-I2Re**2)\n", + "reg = ((I2Re*math.cos(math.radians(phi)))+(I2Xe*math.sin(math.radians(phi))))*(100/V2)\n", + "print \"percentage regulation = %fpercent\"%(reg)\n", + "pf = I2Xe/math.sqrt(I2Re**2+I2Xe**2)\n", + "print \"Power factor for zero regulation = %fleading)\"%(pf)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "percentage regulation = 7.356922percent\n", + "Power factor for zero regulation = 0.866025leading)\n" + ] + } + ], + "prompt_number": 21 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.19 Page No : 225" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "kVA = 50.; #rating of the transformer\n", + "V1 = 3300.; #open circuit primary voltage\n", + "Culoss = 540.; #copper loss from short circuit test\n", + "coreloss = 460.; #core loss from open circuit test\n", + "V1sc = 124.; #short circuit primary voltage in volts\n", + "I1sc = 15.4; #short circuit primary current in amperes\n", + "Psc = 540. #short circuit primary power in watts \n", + "\n", + "# Calculations and Results\n", + "phi = math.degrees(math.acos(0.8))\n", + "effi = (kVA*1000*math.cos(math.radians(phi))*100)/((kVA*1000*math.cos(math.radians(phi)))+Culoss+coreloss)\n", + "print \"From the open-circuit test, core-loss = %dW\"%(coreloss);\n", + "print \"From short circuit test, copper loss = %dW\"%(Culoss);\n", + "print \"The efficiency at full-load and 0.8 lagging power factor = %f\"%(effi);\n", + "Ze = V1sc/I1sc;\n", + "Re = Psc/I1sc**2;\n", + "Xe = math.sqrt(Ze**2-Re**2);\n", + "V2 = 3203;\n", + "phi2 = math.degrees(math.acos(0.8));\n", + "phie = math.degrees(math.acos(Culoss/(V1sc*I1sc)));\n", + "reg = (V1sc*math.cos(math.radians(phie-phi2))*100)/V1;\n", + "print \"Voltage regulation = %dpercent\"%(reg)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "From the open-circuit test, core-loss = 460W\n", + "From short circuit test, copper loss = 540W\n", + "The efficiency at full-load and 0.8 lagging power factor = 97.560976\n", + "Voltage regulation = 3percent\n" + ] + } + ], + "prompt_number": 22 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.20 Page No : 226" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Given Data\n", + "kVA = 100.;\n", + "V1 = 6600.; #primary voltage in volts\n", + "V2 = 330.; #secondary voltage in volts\n", + "f = 50.; #frequency in hertz\n", + "V1sc = 100.; #short circuit primary voltage in volts\n", + "I1sc = 10.; #short circuit primary current in amperes\n", + "Psc = 436.; #short circuit primary power in watts \n", + "\n", + "# Calculations and Results\n", + "Ze = V1sc/I1sc;\n", + "Re = Psc/I1sc**2;\n", + "phi = math.degrees(math.acos(0.8));\n", + "Xe = math.sqrt(Ze**2-Re**2);\n", + "print \"Total resistance = %fohms\"%(Re);\n", + "print \"Total impedence = %fohms\"%(Ze)\n", + "Il = (kVA*1000)/V1;\n", + "V1dash = (math.sqrt(((V1*math.cos(math.radians(phi)))+(Il*Re))**2+((V1*math.sin(math.radians(phi)))+(Il*Xe))**2));\n", + "print \"full voltage current, V1 = %dV\"%(V1dash)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Total resistance = 4.360000ohms\n", + "Total impedence = 10.000000ohms\n", + "full voltage current, V1 = 6735V\n" + ] + } + ], + "prompt_number": 23 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.21 Page No : 227" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Given Data\n", + "V2 = 500.; #secondary voltage in volts\n", + "V1 = 250.; #primary voltage in short circuit test in volts\n", + "I0 = 1.; #current in short circuit test in amperes\n", + "P = 80.; #core loss in watt\n", + "Psc = 100.; #power in short circuit test in watts\n", + "Vsc = 20.; #short circuit voltage in volts \n", + "Isc = 12.; #short circuit current in amperes\n", + "\n", + "# Calculations and Results\n", + "phi0 = math.degrees(math.acos(P/(V1*I0)));\n", + "print \"From open circuit test , math.cos(phi0) = %f\"%(math.cos(phi0));\n", + "Ic = I0*math.cos(math.radians(phi0));\n", + "print \"Loss component of no-load current, Ic = %fA\"%(Ic)\n", + "Im = math.sqrt(I0**2-Ic**2);\n", + "print \"Magnetising current, Im = %fA\"%(Im);\n", + "Rm = V1/Ic;\n", + "Xm = V1/Im;\n", + "Re = Psc/(Isc**2);\n", + "Ze = Vsc/Isc;\n", + "Xe = math.sqrt(Ze**2-Re**2);\n", + "print \"Equvalent resistance referred to secondary = %fohms\"%(Re);\n", + "print \"Equvalent reactance referred to secondary = %fohms\"%(Xe);\n", + "print \"Equvalent impedance referred to secondary = %fohms\"%(Ze);\n", + "K = V2/V1; #turns ratio\n", + "print \"Equvalent resistance referred to primary = %fohms\"%(Re/K**2);\n", + "print \"Equvalent reactance referred to primary = %fohms\"%(Xe/K**2);\n", + "print \"Equvalent impedance referred to primary = %fohms\"%(Ze/K**2);\n", + "V = 500; #output in volts\n", + "I = 10; #output current in amperes\n", + "phi = math.degrees(math.acos(0.80));\n", + "effi = (V*I*math.cos(math.radians(phi))*100)/((V*I*math.cos(math.radians(phi)))+P+((I)**2*Re));\n", + "print \"Effiency = %fpercent\"%(effi);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "From open circuit test , math.cos(phi0) = -0.606173\n", + "Loss component of no-load current, Ic = 0.320000A\n", + "Magnetising current, Im = 0.947418A\n", + "Equvalent resistance referred to secondary = 0.694444ohms\n", + "Equvalent reactance referred to secondary = 1.515099ohms\n", + "Equvalent impedance referred to secondary = 1.666667ohms\n", + "Equvalent resistance referred to primary = 0.173611ohms\n", + "Equvalent reactance referred to primary = 0.378775ohms\n", + "Equvalent impedance referred to primary = 0.416667ohms\n", + "Effiency = 96.398447percent\n" + ] + } + ], + "prompt_number": 26 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.22 Page No : 231" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Given Data\n", + "kVA = 200.; #Rating of the transformer\n", + "Pin = 3.4; #power input to two transformer in watt\n", + "Pin2 = 5.2;\n", + "coreloss = Pin; #core loss of two transformers\n", + "\n", + "# Calculations and Results\n", + "phi = math.degrees(math.acos(0.8));\n", + "print \"Core loss of two transformer = %fkW\"%(Pin)\n", + "print \"Core loss of each transformer = %fkW\"%(Pin/2)\n", + "print \"Full load copper loss of the two transformer = %fkW\"%(Pin2)\n", + "print \"Therefore, full load copper loss of each transformer = %fkW\"%(Pin2/2);\n", + "effi = (kVA*math.cos(math.radians(phi))*100)/((kVA*math.cos(math.radians(phi)))+(Pin/2)+(Pin2/2))\n", + "print \"Full load efficiency at 0.8 p.f. lagging = %fpercent\"%(effi);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Core loss of two transformer = 3.400000kW\n", + "Core loss of each transformer = 1.700000kW\n", + "Full load copper loss of the two transformer = 5.200000kW\n", + "Therefore, full load copper loss of each transformer = 2.600000kW\n", + "Full load efficiency at 0.8 p.f. lagging = 97.382836percent\n" + ] + } + ], + "prompt_number": 30 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.24 Page No : 233" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "kVA = 50.; #rating of the transformer\n", + "V1 = 6360.; #primary voltage rating\n", + "V2 = 240.; #secondary voltage rating\n", + "pf = 0.8\n", + "coreloss = 2; #core loss in kilo watt from open circuit test\n", + "Culoss = 2; #copper loss at secondary current of 175A\n", + "I = 175.; #current in amperes\n", + "\n", + "# Calculations and Results\n", + "I2 = (kVA*1000)/V2;\n", + "print \"Full load secondary current, I2 = %fA\"%(I2);\n", + "effi = (kVA*pf*100)/((kVA*pf)+coreloss+(Culoss*(I2/I)**2))\n", + "print \"Efficiency = %fpercent\"%(effi)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Full load secondary current, I2 = 208.333333A\n", + "Efficiency = 89.217075percent\n" + ] + } + ], + "prompt_number": 31 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.25 Page No : 234" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "kVA = 500.; #rating of the transformer\n", + "R1 = 0.4; #resistance in primary winding inohms\n", + "R2 = 0.001; #resistance in secondary winding in ohms\n", + "V1 = 6600.; #primary voltahe in volts\n", + "V2 = 400.; #secondary voltage in volts\n", + "ironloss = 3.; #iron loss in kilowatt\n", + "pf = 0.8; #power factor lagging\n", + "\n", + "# Calculations and Results\n", + "I1 = (kVA*1000)/V1; \n", + "print \"Primary winding current = %fA\"%(I1);\n", + "I2 = (I1*V1)/V2;\n", + "print \"Secondary winding current = %fA\"%(I2);\n", + "Culoss = ((I1**2*R1)+(I2**2*R2));\n", + "print \"Copper losses in the two winding = %fWatts\"%(Culoss);\n", + "effi = (kVA*pf*100)/((kVA*pf)+ironloss+(Culoss/1000));\n", + "print \"Efficiency at 0.8 p.f = %fpercent\"%(effi);\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Primary winding current = 75.757576A\n", + "Secondary winding current = 1250.000000A\n", + "Copper losses in the two winding = 3858.184114Watts\n", + "Efficiency at 0.8 p.f = 98.314355percent\n" + ] + } + ], + "prompt_number": 32 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.26 Page No : 234" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "kVA = 400.; #rating of the transformer\n", + "ironloss = 2.; #iron loss in kilowatt\n", + "pf = 0.8; #power factor\n", + "kW = 240.; #load in kilowatt\n", + "\n", + "# Calculations and Results\n", + "kVA1 = kW/pf;\n", + "print (\"Efficiency is maximium when,core-loss = copper-loss\")\n", + "coreloss = ironloss;\n", + "print (\"Maximium efficiency occurs at 240kw,0.8 power factor,i.e., at 300kVA load\")\n", + "Cl300 = coreloss;\n", + "Cl400 = (Cl300*(kVA/kVA1)**2);\n", + "pf1 = 0.71; #power factor for full load\n", + "effi = (kVA*pf1*100)/((kVA*pf1)+coreloss+Cl400);\n", + "print \"Efficiency at full-load and 071 power factor = %dpercent\"%(effi);\n", + "pf2 = 1 #maximium efficiency occurs at unity power factor\n", + "MAXeffi = (kVA1*pf2*100)/((kVA1*pf2)+coreloss+Cl300)\n", + "print \"Maximium efficiency at 300kVA and unity power factor = %fpercent\"%(MAXeffi);\n", + "\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Efficiency is maximium when,core-loss = copper-loss\n", + "Maximium efficiency occurs at 240kw,0.8 power factor,i.e., at 300kVA load\n", + "Efficiency at full-load and 071 power factor = 98percent\n", + "Maximium efficiency at 300kVA and unity power factor = 98.684211percent\n" + ] + } + ], + "prompt_number": 33 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.27 Page No : 235" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "kVA = 40.; #rating of the transformer\n", + "coreloss = 450.; #core-loss in watts\n", + "Culoss = 800.; #copper loss in watt\n", + "pf = 0.8; #power factor of the load\n", + "\n", + "# Calculations and Results\n", + "FLeffi = (kVA*pf*100)/((kVA*pf)+((coreloss+Culoss)/1000));\n", + "print \"Full-load efficiency = %fpercent\"%(FLeffi);\n", + "print (\"For maximium efficiency, Core loss = copper loss\")\n", + "Culoss2 = coreloss; #for maximium efficiency\n", + "n = math.sqrt(Culoss2/Culoss);\n", + "kVA2 = n*kVA; #load for maximium efficiency\n", + "MAXeffi = (kVA2*pf*100)/((kVA2*pf)+((coreloss+Culoss2)/1000));\n", + "print \"Value of maximium efficiency = %fpercent\"%(MAXeffi);\n", + "\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Full-load efficiency = 96.240602percent\n", + "For maximium efficiency, Core loss = copper loss\n", + "Value of maximium efficiency = 96.385542percent\n" + ] + } + ], + "prompt_number": 34 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.28 Page No : 236" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "kVA = 50.; #rating of the transformers\n", + "I1 = 250.; #primary current in amperes\n", + "Re = 0.006; #total resistance referred to the primary side\n", + "ironloss = 200.; #iron loss in watt\n", + "\n", + "# Calculations and Results\n", + "Culoss = (I1**2*Re); #copper loss in watt\n", + "pf = 0.8; #power factor lagging\n", + "print \"Full-load copper loss = %fW\"%(Culoss);\n", + "TL1 = ((Culoss+ironloss)/1000); \n", + "print \"Total loss on full load = %fkW\"%(TL1);\n", + "TL2 = ((((Culoss*(1/2)**2))+ironloss)/1000)\n", + "print \"Total loss on half load = %fkW\"%(TL2);\n", + "effi1 = (kVA*pf*100)/((kVA*pf)+TL1);\n", + "print \"Efficiency at full load, 0.8 power factor lagging = %f percent\"%(effi1)\n", + "effi2 = ((kVA/2)*pf*100)/(((kVA/2)*pf)+TL2);\n", + "print \"Efficiency at half load, 0.8 power factor lagging = %f percent\"%(effi2)\n", + "\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Full-load copper loss = 375.000000W\n", + "Total loss on full load = 0.575000kW\n", + "Total loss on half load = 0.200000kW\n", + "Efficiency at full load, 0.8 power factor lagging = 98.582871 percent\n", + "Efficiency at half load, 0.8 power factor lagging = 99.009901 percent\n" + ] + } + ], + "prompt_number": 35 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.29 Page No : 237" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Given Data\n", + "kVA = 10.; #rating of the transformers\n", + "V1 = 400.; #primary voltage in volts\n", + "V2 = 200.; #secondary voltage in volts\n", + "f = 50.; #frequency in hertz\n", + "\n", + "# Calculations and Results\n", + "MAXeffi = 0.96; #maximium efficiency\n", + "output1 = (kVA*0.75); #output at 75% of full load\n", + "input1 = (output1/MAXeffi);\n", + "print \"Input at 75percent of full load = %fkW\"%(input1);\n", + "TL = input1-output1;\n", + "print \"Total losses = %fkW\"%(TL);\n", + "Pi = TL/2;\n", + "Pc = TL/2;\n", + "print (\"Maximiunm efficiency occurs at 3/4th of full load\")\n", + "Pc = Pi/(3./4)**2;\n", + "print \"Thus, total losses on full load = %fW\"%((Pc+Pi)*1000);\n", + "pf = 0.8; #power factor lagging\n", + "effi = (kVA*pf*100)/((kVA*pf)+(Pc+Pi));\n", + "print \"Efficiency on full load. 0.8 power factor lagging = %fpercent\"%(effi)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Input at 75percent of full load = 7.812500kW\n", + "Total losses = 0.312500kW\n", + "Maximiunm efficiency occurs at 3/4th of full load\n", + "Thus, total losses on full load = 434.027778W\n", + "Efficiency on full load. 0.8 power factor lagging = 94.853849percent\n" + ] + } + ], + "prompt_number": 38 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.30 Page No : 237" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Given Data\n", + "kVA = 500.; #rating of the transformers\n", + "V1 = 3300.; #primary voltage in volts\n", + "V2 = 500.; #secondary voltage in volts\n", + "f = 50.; #frequency in hertz\n", + "MAXeffi = 0.97; \n", + "x = 0.75; #fraction of full load for maximium efficiency\n", + "pf1 = 1.;\n", + "\n", + "# Calculations and Results\n", + "output1 = (kVA*x*pf1*1000);\n", + "print \"Output at maximium efficiency = %dwatts\"%(output1);\n", + "losses = ((1/MAXeffi)-1)*output1;\n", + "print \"Thus, at maximium efficiency, lossses = %fW\"%(losses)\n", + "Culoss = losses/2;\n", + "print \"Copper losses at 75percent of full load = %dW\"%(Culoss);\n", + "CulossFL = Culoss/x**2;\n", + "print \"Copper losses at full load = %dW\"%(CulossFL);\n", + "Re = CulossFL/(kVA*1000);\n", + "Ze = 0.1; #equivalent impedence per unit\n", + "Xe = math.sqrt(Ze**2-Re**2);\n", + "phi = math.degrees(math.acos(0.8));\n", + "reg = ((Re*math.cos(math.radians(phi)))+(Xe*math.sin(math.radians(phi))))*100;\n", + "print \"percentage regulation = %f percent\"%(reg);\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Output at maximium efficiency = 375000watts\n", + "Thus, at maximium efficiency, lossses = 11597.938144W\n", + "Copper losses at 75percent of full load = 5798W\n", + "Copper losses at full load = 10309W\n", + "percentage regulation = 7.520562 percent\n" + ] + } + ], + "prompt_number": 39 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 3.32 Page No : 240" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "V1 = 230.; #primary voltage of auto-transformer\n", + "V2 = 75.; #secondary voltage of auto-transformer\n", + "\n", + "# Calculations\n", + "r = (V1/V2); #ratio of primary to secondary turns\n", + "I2 = 200.; #load current in amperes\n", + "I1 = I2/r;\n", + "\n", + "# Results\n", + "print \"Primary current, I1 = %fA\"%(I1);\n", + "print \"Load current, I1 = %fA\"%(I2);\n", + "print \"cirrent flowing through the common portion of winding = %fA\"%(I2-I1);\n", + "print \"Economy in saving in copper in percentage = %fpercent\"%(100/r);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Primary current, I1 = 65.217391A\n", + "Load current, I1 = 200.000000A\n", + "cirrent flowing through the common portion of winding = 134.782609A\n", + "Economy in saving in copper in percentage = 32.608696percent\n" + ] + } + ], + "prompt_number": 40 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Electrical_Machines_by_S._K._Bhattacharya/ch4.ipynb b/Electrical_Machines_by_S._K._Bhattacharya/ch4.ipynb new file mode 100644 index 00000000..930b14d4 --- /dev/null +++ b/Electrical_Machines_by_S._K._Bhattacharya/ch4.ipynb @@ -0,0 +1,1509 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:b6827bab8bcac6e2fc731c1e29fb824cdddabc14d1fbfce91735b0bd239d066e" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 4 : Three Phase Induction Machines" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.1 Page No : 288" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data;\n", + "f = 50.; #frequency\n", + "p = 6.; # number of poles\n", + "V = 400.; #voltage supply\n", + "S = 4.; #percentage slip\n", + "\n", + "# Calculations and Results\n", + "Ns = (120*f)/p; #synchronous speed\n", + "print \"Syhchronous speed, Ns = %d \"%(Ns);\n", + "Nr = (1-(S/100))*Ns;\n", + "print \"speed of rotor with slip 4 percent, Nr is %d rpm \"%(Nr);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Syhchronous speed, Ns = 1000 \n", + "speed of rotor with slip 4 percent, Nr is 960 rpm \n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.2 Page No : 288" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data;\n", + "f = 50.; #frequency\n", + "V = 400.; #voltage supply\n", + "\n", + "# Calculations and Results\n", + "p = 2.;\n", + "print \"when P = 2, Syhchronous speed, Ns = %d \"%((120*f)/p);\n", + "p = 4;\n", + "print \"when P = 2, Syhchronous speed,Ns = %d \"%(120*f/p);\n", + "p = 6;\n", + "print \"when P = 2, Syhchronous speed, Ns = %d \"%(120*f/p);\n", + "p = 8;\n", + "print \"when P = 2 Syhchronous speed, Ns = %d \"%(120*f/p);\n", + "print (\"for Nr to be 1440 , Ns will be 1500, thus p = 4\")\n", + "Ns = 1500;Nr1 = 1440;\n", + "S1 = ((Ns-Nr1)/Ns)*100;\n", + "print \"slip = %d\"%(S1);\n", + "print (\"for Nr to be 940 , Ns will be 1000, thus p = 6\")\n", + "Ns = 1000;Nr2 = 940;\n", + "S2 = ((Ns-Nr2)/Ns)*100;\n", + "print \"slip = %d\"%(S2);\n", + "if S1>S2:\n", + " print (\"motor running at 1440 rpm is running at higher slip\")\n", + "elif S2>S1:\n", + " print (\"motor running at 940 rpm is running at higher slip\")" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "when P = 2, Syhchronous speed, Ns = 3000 \n", + "when P = 2, Syhchronous speed,Ns = 1500 \n", + "when P = 2, Syhchronous speed, Ns = 1000 \n", + "when P = 2 Syhchronous speed, Ns = 750 \n", + "for Nr to be 1440 , Ns will be 1500, thus p = 4\n", + "slip = 0\n", + "for Nr to be 940 , Ns will be 1000, thus p = 6\n", + "slip = 0\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.3 Page No : 289" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data;\n", + "P = 10.; #poles of alternator\n", + "N = 600.; #speed of alternator\n", + "\n", + "# Calculations and Results\n", + "f = (P*N)/120 #frequency\n", + "print \"frequency = %d\"%(f);\n", + "print (\"when P = 2\");p = 2\n", + "Ns = (120*f)/p; #synchronous speed\n", + "print \"Syhchronous speed, Ns = %d \"%(Ns);\n", + "print (\"when P = 4\");p = 4;\n", + "Ns = (120*f)/p; #synchronous speed\n", + "print \"Syhchronous speed, Ns = %d \"%(Ns);\n", + "#speed of rotor(1440) is less than synchronous speed 1500, therefore P = 4\n", + "print (\"speed of rotor(1440) is less than synchronous speed 1500, therefore P = 4\")\n", + "Ns = 1500.;\n", + "Nr = 1440.;\n", + "S = ((Ns-Nr)/Ns)*100\n", + "print \"slip is %d percent and number of poles is 4\"%(S)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "frequency = 50\n", + "when P = 2\n", + "Syhchronous speed, Ns = 3000 \n", + "when P = 4\n", + "Syhchronous speed, Ns = 1500 \n", + "speed of rotor(1440) is less than synchronous speed 1500, therefore P = 4\n", + "slip is 4 percent and number of poles is 4\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.4 Page No : 293" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "Nr = 1440.; #rotor speed in rpm\n", + "f = 50.; #frequency in hertz\n", + "\n", + "# Calculations\n", + "#calculating Ns for values of P = 2,4,6,8 etc\n", + "#by checking P = 4\n", + "P = 4;\n", + "Ns = (120*f)/P; #Synchronous speed\n", + "S = (Ns-Nr)/Ns; #slip\n", + "Fr = S*f; #rotor frequency\n", + "\n", + "# Results\n", + "print \"Rotor frequency = %dHz\"%(Fr)\n", + "\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Rotor frequency = 2Hz\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.5 Page No : 294" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "f = 50.; #induction motor frequency in hertz\n", + "fr = 1.5; #rotor frequency in hertz\n", + "\n", + "# Calculations and Results\n", + "S = fr/f; #slip\n", + "P = 8; #pole\n", + "Ns = (120*f)/P;\n", + "print \"synchronous speed = %frpm\"%(Ns)\n", + "Nr = Ns-(S*Ns);\n", + "print \"motor running speed = %frpm\"%(Nr)\n", + "S1 = S*100;\n", + "print \"slip percent = %fpercent\"%(S1)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "synchronous speed = 750.000000rpm\n", + "motor running speed = 727.500000rpm\n", + "slip percent = 3.000000percent\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.7 Page No : 297" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math\n", + "# Given Data\n", + "E20 = 100.; #induced emf in volts\n", + "R2 = 0.05; #rotor resistance in ohms\n", + "X20 = 0.1; #rotor reactance in ohms\n", + "\n", + "# Calculations and Results\n", + "E20p = E20/math.sqrt(3);\n", + "print (\"When S = 0.04\")\n", + "S = 0.04;\n", + "I2 = (S*E20p)/math.sqrt(R2**2+(S*X20)**2)\n", + "print \"I2 = %dA\"%(I2);\n", + "phi2 = math.degrees(math.acos(R2/(math.sqrt(R2**2+(S*X20)**2))));\n", + "print \"Phase angle between rotor voltage and rotor current = %f degrees\"%(phi2);\n", + "print (\"When S = 1\")\n", + "S = 1;\n", + "I2 = (S*E20p)/math.sqrt(R2**2+(S*X20)**2)\n", + "print \"I2 = %dA\"%(I2);\n", + "phi2 = math.degrees(math.acos(R2/(math.sqrt(R2**2+(S*X20)**2))));\n", + "print \"Phase angle between rotor voltage and rotor current = %f degrees\"%(phi2);\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "When S = 0.04\n", + "I2 = 46A\n", + "Phase angle between rotor voltage and rotor current = 4.573921 degrees\n", + "When S = 1\n", + "I2 = 516A\n", + "Phase angle between rotor voltage and rotor current = 63.434949 degrees\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.8 Page No : 298" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "f = 50.; #frequency of induction motor\n", + "P = 4.; #pole\n", + "Ns = (120*f)/P;\n", + "S = 3.; #slip percent\n", + "\n", + "# Calculations\n", + "Nr = Ns-((Ns*S)/100)\n", + "fr = (S*f)/100;\n", + "\n", + "# Results\n", + "print \"synchronous speed = %frpm\"%(Ns)\n", + "print \"speed of running motor = %frpm\"%(Nr)\n", + "print \"rotor frequency = %fHz\"%(fr)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "synchronous speed = 1500.000000rpm\n", + "speed of running motor = 1455.000000rpm\n", + "rotor frequency = 1.500000Hz\n" + ] + } + ], + "prompt_number": 8 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.9 Page No : 299" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "fr = 2.; #frequency of motor induced emf in hertz\n", + "f = 50.; #frequency of induction motor in hertz\n", + "S = (fr/f)*100; #slip percent\n", + "P = 6.; #pole\n", + "# Calculations\n", + "Ns = (120*f)/P;\n", + "Nr = Ns-((Ns*S)/100);\n", + "\n", + "# Results\n", + "print \"percentage slip = %fpercent\"%(S)\n", + "print \"rotor speed = %frpm\"%(Nr)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "percentage slip = 4.000000percent\n", + "rotor speed = 960.000000rpm\n" + ] + } + ], + "prompt_number": 9 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.10 Page No : 299" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "P = 12.; #pole\n", + "f = 50.; #frequency of induction motor in hertz\n", + "Nr = 485.; #induction motor speed in rpm\n", + "\n", + "# Calculations\n", + "Ns = (120*f)/P;\n", + "S = (Ns-Nr)/Nr;\n", + "fr = S*f;\n", + "\n", + "# Results\n", + "print \"frequency of rotor current = %fHz\"%(fr)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "frequency of rotor current = 1.546392Hz\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.11 Page No : 299" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Given Data\n", + "E20 = 100.; #induced emf of induction motor at stanstill in volts\n", + "E20p = E20/math.sqrt(3); #induced emf per phase in volts\n", + "S = 0.40; #slip\n", + "\n", + "# Calculations and Results\n", + "E2 = S*E20p; #rotor induced emf at slip S in volts\n", + "print \"Rotor induced emf at a slip E2 = %fV\"%(E2);\n", + "R2 = 0.4; #resistance per phase in ohms\n", + "X20 = 2.25; #stanstill resistance per phase i ohms\n", + "Z2 = math.sqrt((R2)**2+(S*X20)**2); #rotor impedence at slip S in ohms\n", + "print \"Rotor impedence at a slip S, Z2 = %fohms\"%(Z2)\n", + "I = E2/Z2;\n", + "print \"rotor current = %fA\"%(I)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Rotor induced emf at a slip E2 = 23.094011V\n", + "Rotor impedence at a slip S, Z2 = 0.984886ohms\n", + "rotor current = 23.448415A\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.12 Page No : 308" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "S = 0.03; #slip\n", + "SI = 50.; #stator input in kilowatts\n", + "SL = 2.; #stator loss in kilowatts\n", + "\n", + "# Calculations and Results\n", + "RI = SI-SL; #rotor input in kilowatts\n", + "RIL = S*RI; #rotor I**2R loss\n", + "#rotor core loss can be neglected at 3percent slip\n", + "PDR = RI-RIL; #power developed by the rotor\n", + "print \"Power developed by the rotor = %fkW\"%(PDR);\n", + "FWL = 1; #friction and windage loss in kilowatt\n", + "OP = PDR-FWL; #output power\n", + "print \"Output power = %fkW\"%(OP);\n", + "effi = (OP*100)/SI;\n", + "print \"Efficiency of the motor = %f percent\"%(effi)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Power developed by the rotor = 46.560000kW\n", + "Output power = 45.560000kW\n", + "Efficiency of the motor = 91.120000 percent\n" + ] + } + ], + "prompt_number": 12 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.13 Page No : 309" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Given Data\n", + "f = 50.; #frequency of induction motor in hertz\n", + "hp = 20.; #horse power\n", + "ph = 3.; #Three phase supply\n", + "P = 4.; #number of poles\n", + "\n", + "# Calculations and Results\n", + "losses = 500; #friction and vintage losses\n", + "print \"Output of the motor = %fW\"%(hp*735.5)\n", + "Pd = (hp*735.5)+losses; #power developed in watt\n", + "print \"Power developed by the rotor = %dW\"%(Pd);\n", + "s = 0.04; #slip\n", + "rotorloss = (s*Pd)/(1-s);\n", + "print \"Rotor I**2R-loss = %fW\"%(rotorloss);\n", + "Ns = (120*f)/P;\n", + "print \"Ns = %drpm\"%(Ns);\n", + "Nr = Ns*(1-s);\n", + "print \"Nr = %drpm\"%(Nr);\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Output of the motor = 14710.000000W\n", + "Power developed by the rotor = 15210W\n", + "Rotor I**2R-loss = 633.750000W\n", + "Ns = 1500rpm\n", + "Nr = 1440rpm\n" + ] + } + ], + "prompt_number": 13 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.14 Page No : 310" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Given Data\n", + "f = 50.; #frequency of induction motor in hertz\n", + "P = 6.; #number of poles\n", + "ph = 3.; #Three phase supply\n", + "\n", + "# Calculations and Results\n", + "R2 = 0.1; #rotor resistance in ohms\n", + "Ns = (120*f)/P;\n", + "print \"Syncronous speed, Ns = %drpm\"%(Ns);\n", + "Nr = 940; #rotor speed in rpm\n", + "S = (Ns-Nr)/Ns;\n", + "print \"Slip, S = %f\"%(S);\n", + "print \"stanstill rotor reactance, X20 = %fohms\"%(R2/S);\n", + "\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Syncronous speed, Ns = 1000rpm\n", + "Slip, S = 0.060000\n", + "stanstill rotor reactance, X20 = 1.666667ohms\n" + ] + } + ], + "prompt_number": 16 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.15 Page No : 310" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "f = 50.; #frequency of induction motor in hertz\n", + "P = 4.; #number of poles\n", + "Nr = 1440.; #rotor speed in rpm\n", + "R2 = 0.1; #rotor resistance in ohms\n", + "X20 = 0.6; #rotor stanstill resistance in ohms\n", + "\n", + "# Calculations and Results\n", + "Ns = (120*f)/P;\n", + "print \"Synchronous speed = %drpm\"%(Ns);\n", + "S1 = (Ns-Nr)*(100/Ns);\n", + "print \"Full-load slip with rotor resistance, R2 i.e. S1 = %f\"%(S1);\n", + "print (\"on adding extra resistance o.1ohm\")\n", + "#on solving we get S2 = 0.08\n", + "S2 = 0.08;\n", + "Nr2 = Ns*(1-S2);\n", + "print \"New rotor speed = %drpm\"%(Nr2);\n", + "\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Synchronous speed = 1500rpm\n", + "Full-load slip with rotor resistance, R2 i.e. S1 = 4.000000\n", + "on adding extra resistance o.1ohm\n", + "New rotor speed = 1380rpm\n" + ] + } + ], + "prompt_number": 18 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.16 Page No : 311" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "f = 50.; #frequency in hertz\n", + "P = 4.; #number of poles\n", + "R2 = 0.04; #rotor resistance in ohms\n", + "\n", + "# Calculations and Results\n", + "Ns = (120*f)/P;\n", + "print \"Syncronous speed = %drpm\"%(Ns);\n", + "Nr = 1200; #rotor speed at maximium torque in rpm\n", + "S = (Ns-Nr)/Ns;\n", + "print \"Slip at maximium torque = %f\"%(S);\n", + "X20 = R2/S;\n", + "#starting torque is developed when S = 1\n", + "#r = (Tst/Tm)\n", + "r = (R2/(R2**2+X20**2))*(2*X20);\n", + "print \"Therefore, starting torque is %fpercent of the maximium torque\"%(r*100)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Syncronous speed = 1500rpm\n", + "Slip at maximium torque = 0.200000\n", + "Therefore, starting torque is 38.461538percent of the maximium torque\n" + ] + } + ], + "prompt_number": 19 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.18 Page No : 313" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "P = 4.; #number of poles\n", + "f = 50.; #frequency in hertz\n", + "ph = 3.; #three phase supply\n", + "R2 = 0.25; #rotor resistance in ohms\n", + "Nr = 1440.; #rotor speed in rpm\n", + "\n", + "# Calculations and Results\n", + "Ns = (120*f)/P;\n", + "S1 = (Ns-Nr)/Ns;\n", + "print \"S1 = %f\"%(S1);\n", + "Nr2 = 1200; #rotor speed when external is added\n", + "S2 = (Ns-Nr2)/Ns;\n", + "#torque remains consmath.tant,we get the relation R2' = R2*(S2/S1)\n", + "R2dash = R2*(S2/S1)\n", + "print \"Extra resistance to be connected in the motor circuit = %fohms\"%(R2dash-R2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "S1 = 0.040000\n", + "Extra resistance to be connected in the motor circuit = 1.000000ohms\n" + ] + } + ], + "prompt_number": 20 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.20 Page No : 311" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "hp = 20.; \n", + "P = 4.; #number of poles\n", + "f = 50.;\n", + "S = 0.03; #slip\n", + "\n", + "# Calculations and Results\n", + "MSO = hp*735.5; #motor shaft output\n", + "losses = 0.02*MSO #friction and windage loss in watts\n", + "Pd = MSO+losses; #power developed by the rotor in watts\n", + "RCL = (S*Pd)/(1-S); #rotor I**2*R loss\n", + "print \"rotor copper loss = %fW\"%(RCL);\n", + "Ri = Pd+RCL #rotor iron loss is neglected\n", + "print \"Rotor input = %fW\"%(Ri);\n", + "Ns = (120*f)/P;\n", + "Nr = Ns*(1-S)*(1./60); #rotor speed in rps\n", + "OT = MSO/(2*3.14*Nr); #outp[ut torque in Nm\n", + "print \"output torque = %fNm\"%(OT)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "rotor copper loss = 464.047423W\n", + "Rotor input = 15468.247423W\n", + "output torque = 96.592028Nm\n" + ] + } + ], + "prompt_number": 21 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.21 Page No : 316" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "f = 50.; #frequency of induction motor in hertz\n", + "P = 6.; #pole\n", + "Ns = (120.*f)/P;\n", + "Nr = 975.; #induction motor running speed in rpm\n", + "\n", + "# Calculations and Results\n", + "S = (Ns-Nr)/Ns;\n", + "print \"the slip = %f\"%(S)\n", + "Pin = 40.; #power input to stator in kW\n", + "Sl = 1.; #stator losses in kW\n", + "Rin = Pin-Sl; #output from stator in kW\n", + "Rc = S*Rin;\n", + "print \"rotor copper losses = %fkW\"%(Rc)\n", + "l = 2.; #total losses in kW\n", + "p = Rin-Rc-l; #output power in kw\n", + "HP = (p*1000)/735.5;\n", + "print \"output horse output = %fHP\"%(HP)\n", + "in1 = 40.; #input in kW\n", + "effi = (p/in1)*100;\n", + "print \"efficiency = %fpercent\"%(effi)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "the slip = 0.025000\n", + "rotor copper losses = 0.975000kW\n", + "output horse output = 48.980286HP\n", + "efficiency = 90.062500percent\n" + ] + } + ], + "prompt_number": 23 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.22 Page No : 316" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "f = 50.; #frequency of induction motor in hertz\n", + "P = 6.; #pole\n", + "\n", + "# Calculations and Results\n", + "Ns = (120.*f)/P;\n", + "print \"synchronous speed = %frpm\"%(Ns)\n", + "fr = 120./60; #rotor frequency\n", + "S = fr/f;\n", + "print \"the slip = %f\"%(S)\n", + "Nr = Ns-(Ns*S);\n", + "print \"rotor speed = %frpm\"%(Nr)\n", + "Rin = 80.; #rotor input in kW\n", + "Rc = S*Rin; #Rotor copper loss in kW\n", + "Ph = 3.; #number of phases\n", + "Rcp = (Rc/Ph)*1000; #loss per phase in watt\n", + "p = ((Rin-Rc)*1000)/735.5;\n", + "print \"mechanical power developed = %fhp\"%(p)\n", + "Ir = 60; #rotor current in amperes\n", + "R2 = Rcp/(Ir)**2;\n", + "print \"rotor resistance per phase at rotor current 60A = %fohms\"%(R2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "synchronous speed = 1000.000000rpm\n", + "the slip = 0.040000\n", + "rotor speed = 960.000000rpm\n", + "mechanical power developed = 104.418763hp\n", + "rotor resistance per phase at rotor current 60A = 0.296296ohms\n" + ] + } + ], + "prompt_number": 24 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.23 Page No : 320" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "# we know (Ts/Tm) = ((2*a)/(1+a**2))\n", + "#where a = (R2/X20)\n", + "#at starting contion math.since Tm = Ts\n", + "print (\"At starting contion math.since Tm = Ts\")\n", + "\n", + "# Calculations and Results\n", + "a = 1 #we obtain from the relations\n", + "R2 = 0.05; #circuit resistance in ohms\n", + "X2 = 0.4; #stanstill reactance in ohms\n", + "r = (a*X2)-R2; #r is the extra that is added to the rotor circuit\n", + "print \"extra resistance added ,r = %fohms\"%(r)\n", + "\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "At starting contion math.since Tm = Ts\n", + "extra resistance added ,r = 0.350000ohms\n" + ] + } + ], + "prompt_number": 25 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.24 Page No : 321" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "V = 400.; #supply voltage in volts\n", + "f = 50.; #frequency in hertz\n", + "P = 6.; #number of poles\n", + "ph = 3.; #three phase supply\n", + "R2 = 0.03; #rotor resistance in ohms\n", + "X20 = 0.4; #rptor reactance in ohms\n", + "Nr = 960.; #full load speed in rpm\n", + "\n", + "# Calculations and Results\n", + "Ns = (120*f)/P;\n", + "print \"synchronous speed = %drpm\"%(Ns)\n", + "S = (Ns-Nr)/Ns; #corresponding slip\n", + "#maximium torque Tm occurs at S = (R2/X20)\n", + "#we get Tm = k/(2*X20)\n", + "a = R2/X20;\n", + "#r = Tm/T\n", + "r = (a**2+S**2)/(2*a*S);\n", + "Sm = (R2/X20);\n", + "print \"Slip at maximium torque, Sm = %f\"%(Sm);\n", + "#corresponding speed\n", + "Nr2 = Ns*(1-Sm);\n", + "print \"Rotor speed at maximium torque = %drpm\"%(Nr2)\n", + "\n", + "\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "synchronous speed = 1000rpm\n", + "Slip at maximium torque, Sm = 0.075000\n", + "Rotor speed at maximium torque = 925rpm\n" + ] + } + ], + "prompt_number": 26 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.25 Page No : 321" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Given Data\n", + "V = 400.; #supply voltage in volts\n", + "f = 50.; #frequency in hertz\n", + "P = 4.; #number of poles\n", + "ph = 3.; #three phase supply\n", + "S = 0.04;\n", + "If = 30.; #Full load current in amperes\n", + "\n", + "# Calculations and Results\n", + "Isc = 6*If;\n", + "#let r be the ratio of starting torque nd full load torque, r = Ts/Tf\n", + "r = (Isc/If)**2*S;\n", + "#Tf = Tm is produced when voltage is Vm\n", + "Vm = math.sqrt(V**2/r);\n", + "print \"voltage at maximium torque = %fvolts\"%(Vm);\n", + "Is = 6*If*(Vm/V);\n", + "print \"Full-load current at 333.3 volts is = %fA\"%(Is)\n", + "\n", + "\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "voltage at maximium torque = 333.333333volts\n", + "Full-load current at 333.3 volts is = 150.000000A\n" + ] + } + ], + "prompt_number": 27 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.26 Page No : 330" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "V = 400.; #supply voltage in volts\n", + "f = 50.; #frequency in hertz\n", + "Id = 75.; #current taken when delta-connected in amperes\n", + "\n", + "# Calculations and Results\n", + "print \"current taken when delta-connected = %dA\"%(Id);\n", + "Is = Id/3; #current taken when star-connected in amperes\n", + "print \"current taken when star-connected = %dA\"%(Is);\n", + "#Tfl be the full load torque\n", + "#r = Ts/Tfl\n", + "r = 1.5;\n", + "#math.since voltage becomes (1/math.sqrt(3)) when star connected \n", + "#torque is directly proportional to square of voltage\n", + "print \"Starting torque with winding star connected = %f times of Tfl\"%(r/3);\n", + "\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "current taken when delta-connected = 75A\n", + "current taken when star-connected = 25A\n", + "Starting torque with winding star connected = 0.500000 times of Tfl\n" + ] + } + ], + "prompt_number": 29 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.28 Page No : 333" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Given Data\n", + "ph = 3;\n", + "#rotor copper loss = slip*rotor input\n", + "#Tst = starting torque\n", + "#Tfl = torque at full load\n", + "#Ist/Ifl = r\n", + "r = 6;\n", + "\n", + "# Calculations and Results\n", + "S = 0.04\n", + "print \" At slip = 0.04\"\n", + "print \"For direct-on-line starting ( Tst/Tfl) = %f\"%(r**2*S);\n", + "#phase current in start is (1/math.sqrt(3)) times the phase current in delta\n", + "\n", + "print \"For direct-on-line starting( Tst/Tfl) = %f\"%((r/math.sqrt(3))**2*S);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + " At slip = 0.04\n", + "For direct-on-line starting ( Tst/Tfl) = 1.440000\n", + "For direct-on-line starting( Tst/Tfl) = 0.480000\n" + ] + } + ], + "prompt_number": 31 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.29 Page No : 334" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "V = 400.; #voltage in volts\n", + "f = 50.; #frequency in hertz\n", + "P = 4.; #number of poles\n", + "#r1 = (Ts/Tfl)\n", + "r1 = 1.6;\n", + "#r2 = (Tm/Tfl)\n", + "r2 = 2.;\n", + "#r3 = (Ts/Tm) = (2*a)/(1+a**2)\n", + "r3 = 0.8;\n", + "#on solving , we get a = 0.04 ,\n", + "a = 0.04;\n", + "\n", + "# Calculations and Results\n", + "Sm = 0.04; #slip at maximium torque\n", + "print \"Slip at maximium torque, Sm = %f\"%(Sm)\n", + "Ns = (120*f)/P; #synchronous speed in rpm\n", + "Nr = Ns*(1-Sm) #rotor speed in rpm\n", + "#r2 = (a**2+Sfl**2)/(2*a*Sfl)\n", + "Sfl = 0.01;\n", + "Nr2 = Ns*(1-Sfl);\n", + "print \"full load speed, Nr = %drpm\"%(Nr2)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Slip at maximium torque, Sm = 0.040000\n", + "full load speed, Nr = 1485rpm\n" + ] + } + ], + "prompt_number": 32 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.30 Page No : 345" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Given Data\n", + "hp = 20.; #power in horsepower\n", + "f = 50.; #frequency in hertz\n", + "P = 4.; #number of poles\n", + "\n", + "# Calculations and Results\n", + "Ns = (120*f)/P; #synchronous speed\n", + "print \"Synchronous speed, Ns = %drpm\"%(Ns);\n", + "S = 0.04; #slip\n", + "Nr = Ns*(1-S);\n", + "OP = hp*735.5;\n", + "print \"Output power = %fW\"%(OP);\n", + "OT = OP/(2*3.14*(Nr/60));\n", + "print \"Output torque = %fNm\"%(OT);\n", + "FL = 0.02*OP; #Friction and windage loss\n", + "PD = OP+FL;\n", + "print \"Power developed by the rotor = %fW\"%(PD);\n", + "#from relation, (rotor I**2R-loss = S*Rotor input) we get following relation \n", + "RL = (S*PD)/(1-S); \n", + "print \"Rotor I**2R-loss = %fW\"%(RL);\n", + "RI = RL/S;\n", + "print \"Rotor input = %dW\"%(RI)\n", + "\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Synchronous speed, Ns = 1500rpm\n", + "Output power = 14710.000000W\n", + "Output torque = 97.598195Nm\n", + "Power developed by the rotor = 15004.200000W\n", + "Rotor I**2R-loss = 625.175000W\n", + "Rotor input = 15629W\n" + ] + } + ], + "prompt_number": 33 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.31 Page No : 347" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "P = 4.; #number of poles\n", + "f = 50.; #frequency in hertz\n", + "V = 230.; #voltage in volts\n", + "hp = 5.; #power in horsepower\n", + "Ib = 15.; #current in block rotor test in amperes\n", + "\n", + "# Calculations and Results\n", + "output = hp*735.5; #output in watts\n", + "#in block rotor test: power input = Full = load I**2R losses = 735W\n", + "FLl = 735; #Full-load I**2R losses\n", + "print \"Full-load I**2R losses = %fW\"%(FLl);\n", + "Re = FLl/(3*Ib**2);\n", + "Io = 6.3; #current in no load condition in amperes\n", + "lossNL = (3*(Io)**2*Re); #I**2R loss at no-load condition\n", + "print \"I**2R loss at no-load = %fW\"%(lossNL);\n", + "PiNL = 275; #power input at no-load\n", + "print \"Core loss plus friction and windage loss = %dW\"%(PiNL-lossNL);\n", + "TL = FLl+(PiNL-lossNL);\n", + "effi = (output*100)/(output+TL);\n", + "print \"Efficiency = %fpercent\"%(effi)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Full-load I**2R losses = 735.000000W\n", + "I**2R loss at no-load = 129.654000W\n", + "Core loss plus friction and windage loss = 145W\n", + "Efficiency = 80.685043percent\n" + ] + } + ], + "prompt_number": 34 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.32 Page No : 347" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Given Data\n", + "Vl = 415.; #voltage in volts\n", + "Il = 50.; #line current in amperes\n", + "R1 = 0.5; #resistrance of stator winding per phase in ohms\n", + "pf = 0.85; #power factor\n", + "S = 0.04;\n", + "\n", + "# Calculations and Results\n", + "IFL = (math.sqrt(3)*Vl*Il*pf) #input to the motor on full load\n", + "print \"Input to the motor on full load = %dW\"%(IFL);\n", + "I1 = Il/math.sqrt(3);\n", + "SLFL = (3*I1**2*R1) #Stator I**2R loss on full load\n", + "print \"Stator I**2R loss on full load = %dW\"%(SLFL);\n", + "#given ratio of stator core loss friction and windahe loss be r = (r1:r2)\n", + "r1 = 3.;\n", + "r2 = 2.;\n", + "TL = 1500.; #total loss\n", + "SCL = (r1*TL)/(r1+r2); #stator core loss\n", + "FWL = (r2*TL)/(r1+r2); #Friction and windage loss\n", + "SL = SLFL+SCL; #total stator loss\n", + "SI = IFL; #Stator input\n", + "Pa = SI-SL; #power transferred through the air-gap = input to the rotor\n", + "RI = Pa\n", + "RL = S*RI; #rotor losses\n", + "TRL = FWL+RL; #total rotor losses \n", + "OP = RI-TRL; #Output power at the shaft\n", + "effi = (OP*100)/SI;\n", + "print \"Efficiency = %f percent\"%(effi)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Input to the motor on full load = 30549W\n", + "Stator I**2R loss on full load = 1250W\n", + "Efficiency = 87.279597 percent\n" + ] + } + ], + "prompt_number": 35 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.33 Page No : 351" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "E20 = 100.; #induced emf between slip terminals in volts\n", + "\n", + "# Calculations and Results\n", + "E20p = E20/math.sqrt(3); #induced emf per phase in volts\n", + "print \"induced emf per phase = %fV\"%(E20p)\n", + "S = 3/100; #slip\n", + "R2 = 0.2; #resistance in ohms\n", + "X20 = 1; #stanstill resistance in ohms\n", + "I2 = (S*E20p)/math.sqrt((R2)**2+(S*X20)**2)\n", + "print \"rotor current at slip 0.03 = %fA per phase\"%(I2)\n", + "Sm = R2/X20;\n", + "I2m = (Sm*E20p)/math.sqrt((R2)**2+(Sm*X20)**2)\n", + "print \"rotor current when the rotor develops maximum torque = %fA per phase\"%(I2m)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "induced emf per phase = 57.735027V\n", + "rotor current at slip 0.03 = 0.000000A per phase\n", + "rotor current when the rotor develops maximum torque = 40.824829A per phase\n" + ] + } + ], + "prompt_number": 36 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.34 Page No : 352" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data\n", + "E20 = 120.; #induced emf of motor at stanstill in volts\n", + "E20p = 120./math.sqrt(3); #induced emf per phase\n", + "f = 50.; #frequency of the motor in hertz\n", + "R2 = 0.2; #Rotor resistance per phase\n", + "X20 = 1.; #stanstill resistance in ohms\n", + "P = 4.; #pole\n", + "I = 16.; #\n", + "\n", + "# Calculations and Results\n", + "S = (I*R2)/math.sqrt((E20)**2-(I*X20)**2);\n", + "Ns = (120*f)/P;\n", + "print \"Synchronous speed = %frpm\"%(Ns)\n", + "Nr = Ns-(Ns*S)\n", + "Sm = R2/X20;\n", + "Nr = Ns-(Ns*Sm)\n", + "I2 = (Sm*E20p)/math.sqrt((R2)**2+(Sm*X20)**2)\n", + "print \"rotor current at maximum torque = %fAper Phase\"%(I2)\n", + "Pi = (3*((I2)**2)*R2)/Sm;\n", + "print \"Rotor input for the three phase = %fW\"%(Pi)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Synchronous speed = 1500.000000rpm\n", + "rotor current at maximum torque = 48.989795Aper Phase\n", + "Rotor input for the three phase = 7200.000000W\n" + ] + } + ], + "prompt_number": 37 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 4.35 Page No : 356" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Given Data\n", + "R1dc = 0.01; #DC resistance in ohms\n", + "V = 400.; #voltage in volts\n", + "r = 1.5; #ratio of ac to dc resistance\n", + "R1 = r*R1dc; #AC resistance in ohms\n", + "#at no-load\n", + "Io = 20.; #no-load current in amperes\n", + "SL = (3*Io**2*R1); #I**2R loss in the stator phases in watts\n", + "FWL = 300.; #Friction and windage loss in watts\n", + "TL = 1200.; #total losses = no-load power input in watts\n", + "\n", + "# Calculations\n", + "CL = TL-(SL+FWL); #core loss in watt\n", + "CLp = CL/math.sqrt(3); #core loss per phase\n", + "Vp = V/math.sqrt(3); #voltage per phase\n", + "Rm = (Vp**3)/CL; #motor resistance\n", + "pf = CL/(Vp*Io);\n", + "phi0 = math.degrees(math.acos(pf));\n", + "Xm = Vp/(Io*math.sin(math.radians(phi0))); #motor reactance\n", + "#Under blocked rotor test\n", + "Vb = 100; #voltage in volts\n", + "Isc = 45; #current in amperes\n", + "Vbp = 100/math.sqrt(3); #voltage per phase in volts\n", + "P = 2750; #power supplied in watts\n", + "Ze = Vbp/Isc; #Motor impedance reffered to stator side in ohms\n", + "Re = P/(3*Isc**2);\n", + "R2 = Re-R1; #rotor resistance referred to stator side\n", + "Xe = math.sqrt(Ze**2-Re**2);\n", + "#assuming X1 = X2\n", + "X2 = Xe/2\n", + "X1 = X2;\n", + "\n", + "# Results\n", + "print \"Thus the elements of the equivalent circuit are:\";\n", + "print \"Rm = %fohms\"%(Rm);\n", + "print \"Xm = %fohms\"%(Xm);\n", + "print \"R1 = %fohms\"%(R1);\n", + "print \"rotor resistance referred to stator side, R2 = %fohms\"%(R2);\n", + "print \"equivalent resistance referred to stator side, Re = %fohms\"%(Re);\n", + "\n", + "print \"X1 = %fohms\"%(X1);\n", + "print \"rotor reactance referred to stator side, X2 = %fohms\"%(X2);\n", + "print \"equivalent reactance referred to stator side, Xe = %fohms\"%(Xe);\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Thus the elements of the equivalent circuit are:\n", + "Rm = 13964.632361ohms\n", + "Xm = 11.763476ohms\n", + "R1 = 0.015000ohms\n", + "rotor resistance referred to stator side, R2 = -0.015000ohms\n", + "equivalent resistance referred to stator side, Re = 0.000000ohms\n", + "X1 = 0.641500ohms\n", + "rotor reactance referred to stator side, X2 = 0.641500ohms\n", + "equivalent reactance referred to stator side, Xe = 1.283001ohms\n" + ] + } + ], + "prompt_number": 38 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Electrical_Machines_by_S._K._Bhattacharya/ch5.ipynb b/Electrical_Machines_by_S._K._Bhattacharya/ch5.ipynb new file mode 100644 index 00000000..60bed6fd --- /dev/null +++ b/Electrical_Machines_by_S._K._Bhattacharya/ch5.ipynb @@ -0,0 +1,989 @@ +{ + "metadata": { + "name": "", + "signature": "sha256:1c4ac592513e221d9ef582b6b080c90b8d233dba2c2d1c00437e9fe2319c3d83" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 5 : Three Phase Synchronous Machines" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.1 Page No : 424" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Given Data; \n", + "slots = 18.;\n", + "p = 2.; #nmber of poles\n", + "ph = 3.; #three phase winding\n", + "\n", + "# Calculations and Results\n", + "SA = (360/slots); #slot angle\n", + "m = slots/(p*ph); #m = nmber of slots per pole per phase\n", + "print \"number of slots per pole per phase, m = %d\"%(m);\n", + "print \"emfs of the oils of each phase will have a time-phase difference of %d degree mechanical \"%(SA);\n", + "k_d = math.sin(math.radians((m*SA)/2))/(m*math.sin(math.radians(SA/2)));\n", + "print \"distribution factor = %f\"%(k_d);\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "number of slots per pole per phase, m = 3\n", + "emfs of the oils of each phase will have a time-phase difference of 20 degree mechanical \n", + "distribution factor = 0.959795\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.2 Page No : 425" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "# Given Data\n", + "slots = 36.; #number of slots\n", + "poles = 4.; #number of poles\n", + "ph = 3.; #math.single layer three phase winding\n", + "\n", + "# Calculations and Results\n", + "SP = slots/ph; #number of slots per phase\n", + "print \"number of slots per phase = %d\"%(SP);\n", + "m = SP/poles; #munber of slots per pole per phase\n", + "print \"number of slots per pole per phase, m = %d\"%(m)\n", + "SA_m = 360/slots; #slot angle mechanical\n", + "SA_e = (poles/2)*SA_m #slot angle electrical \n", + "print \"slot angle = %d degree electrical\"%(SA_e)\n", + "k_d = math.sin(math.radians((m*SA_e)/2))/(m*math.sin(math.radians(SA_e/2)));\n", + "print \"distribution factor = %f\"%(k_d)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "number of slots per phase = 12\n", + "number of slots per pole per phase, m = 3\n", + "slot angle = 20 degree electrical\n", + "distribution factor = 0.959795\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.3 Page No : 426" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Given Data;\n", + "slots = 48.; #number of slots\n", + "poles = 4.; #4-pole machine\n", + "ph = 3.; #3-phase machine\n", + "\n", + "# Calculations and Results\n", + "SA = 360/slots; #slot angle\n", + "print \"total number of slots = %d\"%(slots);\n", + "print \"slot angle = %f degree mechanical\"%(SA);\n", + "#coil span is 11 slot pitches\n", + "#12 slots subtend 180degress, short pitched by 1 slot \n", + "Bta = 1*180./12;\n", + "k_p = math.cos(math.radians(Bta/2));\n", + "print \"pitch factor = %f\"%(k_p)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "total number of slots = 48\n", + "slot angle = 7.500000 degree mechanical\n", + "pitch factor = 0.991445\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.4 Page No : 426" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Given Data;\n", + "slots = 72.; #number of slots\n", + "P = 8.; #number of poles\n", + "ph = 3.; #3-phase machine\n", + "N = 750.; #speed of machine in rpm\n", + "\n", + "#winding is made with 36 coils having 10 turns\n", + "Fp = 0.15; #flux per pole\n", + "fre = (P*N)/120;\n", + "NCp = 36./ph; #nmber of coils per phase\n", + "T = NCp*10; #number of turns per phase\n", + "k_p = 1; #math.since full pitched pitch factor is 1\n", + "\n", + "# Calculations and Results\n", + "print \"flux per pole = %fWb\"%(Fp)\n", + "print \"number of turns per phase = %d\"%(T);\n", + "print \"pitch factor = %f\"%(k_p);\n", + "m = slots/(P*ph); #slots per pole per phase\n", + "SA_m = 360/slots; #slot angle mechanical\n", + "SA_e = (P/2)*SA_m;\n", + "k_d = math.sin(math.radians((m*SA_e)/2))/(m*math.sin(math.radians(SA_e/2)));\n", + "print \"distribution factor = %f\"%(k_d);\n", + "E = 4.44*Fp*fre*T*k_d*k_p;\n", + "print \"RMS vale of emf induced per phase = %fV\"%(E)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "flux per pole = 0.150000Wb\n", + "number of turns per phase = 120\n", + "pitch factor = 1.000000\n", + "distribution factor = 0.959795\n", + "RMS vale of emf induced per phase = 3835.341142V\n" + ] + } + ], + "prompt_number": 4 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.5 Page No : 427" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "# Given Data;\n", + "print (\"E(line to line) = 440V\");\n", + "E_l = 440.; #line-to-line voltage\n", + "E_p = E_l/(math.sqrt(3));\n", + "N = 750.; #speed in rpm\n", + "fre = 50.; #frequency\n", + "\n", + "# Calculations and Results\n", + "P = (120*fre)/N;\n", + "print \"P = %d\"%(P);\n", + "print \"Eper phase) = %dV\"%(E_p);\n", + "ph = 3; #3-phase machine\n", + "m = 2; #number of slots per pole per phase\n", + "slots = m*P*ph; #total number of stator slots\n", + "SA_m = 360/slots; #slot angle mechanical\n", + "SA_e = (P/2)*SA_m; #slot angle electrical\n", + "k_p = 1; #assuming full pitch\n", + "print \"slot angle = %d degree electrical\"%(SA_e);\n", + "print \"pitch factor = %f\"%(k_p);\n", + "k_d = math.sin(math.radians((m*SA_e)/2))/(m*math.sin(math.radians(SA_e/2)));\n", + "print \"distribution factor = %f\"%(k_d);\n", + "#2 slots per pole per phase\n", + "NSp = 2*P; #number of slots per phase\n", + "NTc = 4; #number of turns per coil\n", + "T = 8*NTc; #number of turns per phase\n", + "Fp = E_p/(4.44*fre*T*k_d*k_p);\n", + "print \"flux per pole = %fWb\"%(Fp);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "E(line to line) = 440V\n", + "P = 8\n", + "Eper phase) = 254V\n", + "slot angle = 30 degree electrical\n", + "pitch factor = 1.000000\n", + "distribution factor = 0.965926\n", + "flux per pole = 0.037021Wb\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.6 Page No : 428" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#chapter 5\n", + "#example 5.6\n", + "#page 428\n", + "\n", + "# Given Data;\n", + "slots = 144.; #number of slots\n", + "ph = 3.; #3-phase machine\n", + "P = 16.; #number of poles\n", + "Cp = 10.; #number of conducters per slot\n", + "Fp = 0.03; #flux per pole\n", + "Ns = 375.; #synchronous speed\n", + "\n", + "# Calculations and Results\n", + "fre = (Ns*P)/120; #frequency\n", + "print \"frequency = %d\"%(fre);\n", + "m = slots/(P*ph); #number of slots per pole per phase\n", + "print \"number of slots per pole per phase, m = %d\"%(m);\n", + "SA_m = 360/slots; #slot angle mechanical\n", + "SA_e = (P/2)*SA_m; #slot angle electrical\n", + "k_p = 1 #no short pitching\n", + "print \"short pitch = %d\"%(k_p);\n", + "k_d = math.sin(math.radians((m*SA_e)/2))/(m*math.sin(math.radians(SA_e/2)));\n", + "print \"distribution factor = %f\"%(k_d);\n", + "T = (slots*10)/(2*ph);\n", + "print \"number of turns per phase, T = %d\"%(T);\n", + "E = 4.44*Fp*fre*T*k_d*k_p;\n", + "print \"RMS value of induced emf per phase, E = %fV\"%(E);\n", + "print \"induced emf across the linesis %fV \"%(math.sqrt(3)*E);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "frequency = 50\n", + "number of slots per pole per phase, m = 3\n", + "short pitch = 1\n", + "distribution factor = 0.959795\n", + "number of turns per phase, T = 240\n", + "RMS value of induced emf per phase, E = 1534.136457V\n", + "induced emf across the linesis 2657.202289V \n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.7 Page No : 428" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Given Data;\n", + "slots = 90.; #number of slots\n", + "P = 10.; #number of poles\n", + "ph = 3.; #3-phase machine\n", + "fre = 50.; #frequency\n", + "Fp = 0.16; #flux per pole\n", + "E_l = 11000.; #line voltage\n", + "SA_m = 360/slots; #machanical slot angle\n", + "\n", + "# Calculations and Results\n", + "SA_e = (P/2)*SA_m; #electrical slot angle\n", + "m = slots/(ph*P);\n", + "print \"slot angle = %d degree elecrical\"%(SA_e)\n", + "print \"number of slots per pole per phase, m = %d\"%(m);\n", + "k_p = 1; #assuming full pitch\n", + "print \"pitch factor = %d\"%(k_p);\n", + "k_d = math.sin(math.radians((m*SA_e)/2))/(m*math.sin(math.radians(SA_e/2)));\n", + "print \"distribution factor = %f\"%(k_d);\n", + "E_p = E_l/math.sqrt(3);\n", + "T = E_p/(4.44*Fp*fre*k_p*k_d); \n", + "print \"total number of armature conductors, Z = %d\"%(2*T);\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "slot angle = 20 degree elecrical\n", + "number of slots per pole per phase, m = 3\n", + "pitch factor = 1\n", + "distribution factor = 0.959795\n", + "total number of armature conductors, Z = 372\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.8 Page No : 429" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Given Data;\n", + "print (\"P = 6 , f = 50\");\n", + "P = 6.;\n", + "f = 50.;\n", + "Sp = 12.; #slots per pole\n", + "Cs = 4.; #conductors per slot\n", + "Fp = 1.5; \n", + "\n", + "# Calculations and Results\n", + "TS = Sp*P \n", + "print \"total number of slots = %d\"%(TS);\n", + "print \"total number of slots per phase = %d\"%( TS/3);\n", + "print \"total number of conductors per phase = %d\"%(( TS*Cs)/3);\n", + "T = ((TS*Cs)/3)/2;\n", + "print \"total number of turns per phase = %d\"%(T)\n", + "m = (TS/(P*3));\n", + "print \"number of slots per pole per phase, m = %d\"%(m);\n", + "SA_m = 360/TS; #slot angle mechanical\n", + "SA_e = (P/2)*SA_m;\n", + "k_d = math.sin(math.radians((m*SA_e)/2))/(m*math.sin(math.radians(SA_e/2)));\n", + "print \"distribution factor = %f\"%(k_d);\n", + "print (\"coil pitch is 5/6 of full-pitch\");\n", + "bheta = 180-(5./6)*180; #short pitch angle\n", + "print \"short pitch angle = %d degrees\"%(bheta)\n", + "k_p = math.cos(math.radians(bheta/2));\n", + "print \"pitch factor = %f \"%(k_p);\n", + "E = 4.44*Fp*f*T*k_d*k_p;\n", + "print \"induced per phase = %fV\"%(E)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "P = 6 , f = 50\n", + "total number of slots = 72\n", + "total number of slots per phase = 24\n", + "total number of conductors per phase = 96\n", + "total number of turns per phase = 48\n", + "number of slots per pole per phase, m = 4\n", + "distribution factor = 0.957662\n", + "coil pitch is 5/6 of full-pitch\n", + "short pitch angle = 30 degrees\n", + "pitch factor = 0.965926 \n", + "induced per phase = 14785.689892V\n" + ] + } + ], + "prompt_number": 14 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.9 Page No : 439" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Given Data;\n", + "OP = 500000.; #output power\n", + "V_l = 3300.; #line voltage\n", + "\n", + "# Calculations and Results\n", + "I_l = OP/(math.sqrt(3)*V_l); #line current\n", + "print \"line current = %fA\"%(I_l);\n", + "#for star connected alternater, line current is equal to phase current\n", + "I_a = I_l;\n", + "pf = 0.8; #power factor\n", + "phi = math.degrees(math.acos(pf));\n", + "R_a = 0.3; #synchronous resistance\n", + "X_s = 4; #synchronous reactance\n", + "V_p = V_l/math.sqrt(3);\n", + "print \"phase voltage = %fV\"%(V_p)\n", + "E = math.sqrt((V_p*math.cos(math.radians(phi))+I_a*R_a)**2+(V_p*math.sin(math.radians(phi))+I_a*X_s)**2);\n", + "print \"induced emf = %f V/Phase\"%(E )\n", + "PR = ((E-V_p)*100)/V_p;\n", + "print \"percentage regulation = %f percent\"%(PR);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "line current = 87.477314A\n", + "phase voltage = 1905.255888V\n", + "induced emf = 2152.469556 V/Phase\n", + "percentage regulation = 12.975353 percent\n" + ] + } + ], + "prompt_number": 15 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.10 Page No : 440" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Given Data\n", + "V = 2000.;\n", + "V_oc = 500.; #open circuit voltage\n", + "I_sc = 100.; #short circuit current\n", + "I_a = 100.; \n", + "R_s = 0.8; #armature resistance\n", + "\n", + "# Calculations and Results\n", + "Z_s = V_oc/I_sc; #synchronous impedence\n", + "print \"Z_s = %d ohm\"%(Z_s);\n", + "X_s = math.sqrt(Z_s**2-R_s**2);\n", + "print \"X_s = %f ohm\"%(X_s);\n", + "pf = 1;\n", + "phi = math.degrees(math.acos(pf));\n", + "print (\"At unity power factor\");\n", + "print \"\";\n", + "E = math.sqrt((V*math.cos(math.radians(phi))+I_a*R_s)**2+(V*math.sin(math.radians(phi))+I_a*X_s)**2);\n", + "print \"induced emf = %fV\"%(E);\n", + "R = ((E-V)*100)/V;\n", + "print \"regulation = %f percent\"%(R);\n", + "pf = 0.71;\n", + "phi = math.degrees(math.acos(pf));\n", + "print (\"At 0.71 lagging power factor\");\n", + "print \"\";\n", + "E = math.sqrt((V*math.cos(math.radians(phi))+I_a*R_s)**2+(V*math.sin(math.radians(phi))+I_a*X_s)**2);\n", + "print \"induced emf = %fV\"%(E);\n", + "R = ((E-V)*100)/V;\n", + "print \"regulation = %fpercent\"%(R);\n", + "pf = 0.8;\n", + "phi = math.degrees(math.acos(pf));\n", + "print (\"At 0.8 leading power factor\");\n", + "print \"\";\n", + "E = math.sqrt((V*math.cos(math.radians(phi))+I_a*R_s)**2+(V*math.sin(math.radians(phi))-I_a*X_s)**2);\n", + "print \"induced emf = %fV\"%(E);\n", + "R = ((E-V)*100)/V;\n", + "print \"regulation = %fpercent\"%(R);\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Z_s = 5 ohm\n", + "X_s = 4.935585 ohm\n", + "At unity power factor\n", + "\n", + "induced emf = 2137.755833V\n", + "regulation = 6.887792 percent\n", + "At 0.71 lagging power factor\n", + "\n", + "induced emf = 2422.283821V\n", + "regulation = 21.114191percent\n", + "At 0.8 leading power factor\n", + "\n", + "induced emf = 1822.487197V\n", + "regulation = -8.875640percent\n" + ] + } + ], + "prompt_number": 18 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.11 Page No : 441" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "\n", + "# Given Data;\n", + "print (\"field exitation current = 10A\");\n", + "V_oc = 900.; #induced emf on open circuit\n", + "I_sc = 150.; #short circuit current\n", + "\n", + "# Calculations and Results\n", + "Z_s = V_oc/I_sc; #synchronous impedence\n", + "print \"synchronous impedence, Z_s = %d ohm\"%(Z_s);\n", + "I_a = 60;\n", + "print \"internal voltage drop when the load current is 60amp = %d V\"%(I_a*Z_s);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "field exitation current = 10A\n", + "synchronous impedence, Z_s = 6 ohm\n", + "internal voltage drop when the load current is 60amp = 360 V\n" + ] + } + ], + "prompt_number": 19 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.12 Page No : 441" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Given Data;\n", + "KVA = 2000.;\n", + "V = 6600.; #rating\n", + "V_p = 6600./math.sqrt(3);\n", + "I_a = (KVA*1000)/(math.sqrt(3)*V);\n", + "R_a = 0.4; #armature resistance\n", + "X_s = 4.5 #synchronous reactance\n", + "pf = 0.8;\n", + "\n", + "# Calculations and Results\n", + "phi = math.degrees(math.acos(pf));\n", + "print \"V/phase = %dV \"%(V_p)\n", + "E = math.sqrt((V_p*math.cos(math.radians(phi))+I_a*R_a)**2+(V_p*math.sin(math.radians(phi))+I_a*X_s)**2)\n", + "print \"E = %f V per phase\"%(E);\n", + "R = ((E-V_p)*100)/V_p;\n", + "print \"percentage change in terminal voltage = %f percent\"%(R);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "V/phase = 3810V \n", + "E = 4378.515597 V per phase\n", + "percentage change in terminal voltage = 14.906234 percent\n" + ] + } + ], + "prompt_number": 20 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.13 Page No : 442" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Given Data;\n", + "KVA = 1200.; #output power\n", + "print \"output power = %d\"%(KVA)\n", + "V_l = 3300.; #line voltage\n", + "R_a = 0.25; #armature resistance\n", + "\n", + "# Calculations and Results\n", + "I_l = (KVA*1000)/(math.sqrt(3)*V_l); #line current\n", + "#for star connected I_l = I_a\n", + "I_a = I_l;\n", + "V_p = V_l/math.sqrt(3);\n", + "print \"V per phase = %dV\"%(V_p)\n", + "#field current of 40A produces short circuit current of 200A and open circuit emf 1100\n", + "v_l = 1100;\n", + "i_s = 200;\n", + "Z_s = v_l/(math.sqrt(3)*i_s); #synchronous impedence\n", + "print \"Synchronous impedance, Zs = %f ohm\"%(Z_s)\n", + "X_s = math.sqrt(Z_s**2-R_a**2); #synchronous reactance\n", + "print (\"(a)for 0.8 lagging power facor\");\n", + "pf = 0.8;\n", + "phi = math.degrees(math.acos(pf));\n", + "E = math.sqrt((V_p*math.cos(math.radians(phi))+I_a*R_a)**2+(V_p*math.sin(math.radians(phi))+I_a*X_s)**2)\n", + "print \"induced emf, E = %f V\"%(E);\n", + "R = ((E-V_p)*100)/V_p;\n", + "print \"regulation = %f percent\"%(R);\n", + "pf = 0.8;\n", + "phi = math.degrees(math.acos(pf));\n", + "print (\"(b)For leading power factor load\")\n", + "E = math.sqrt((V_p*math.cos(math.radians(phi))+I_a*R_a)**2+(V_p*math.sin(math.radians(phi))-I_a*X_s)**2)\n", + "print \"induced emf, E = %f V\"%(E);\n", + "R = ((E-V_p)*100)/V_p;\n", + "print \"regulation = %f percent\"%(R);" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "output power = 1200\n", + "V per phase = 1905V\n", + "Synchronous impedance, Zs = 3.175426 ohm\n", + "(a)for 0.8 lagging power facor\n", + "induced emf, E = 2398.732590 V\n", + "regulation = 25.900810 percent\n", + "(b)For leading power factor load\n", + "induced emf, E = 1647.716860 V\n", + "regulation = -13.517293 percent\n" + ] + } + ], + "prompt_number": 21 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.14 Page No : 443" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Given Data;\n", + "print (\"star connected alternator\")\n", + "KVA = 1500.; #rating\n", + "ph = 3.; #3-phase\n", + "V_l = 6600.; #voltage\n", + "Ra = 0.4 #armature resistance\n", + "Xs = 6.; #reactance\n", + "\n", + "# Calculations and Results\n", + "Ia = (KVA*1000)/(math.sqrt(3)*V_l);\n", + "print \"Full-load current = %d A\"%(Ia);\n", + "V = V_l/math.sqrt(3);\n", + "print \"Voltage per phase = %d V\"%(V);\n", + "print (\"for 0.8 lagging power facor\");\n", + "pf = 0.8; #power factor\n", + "phi = math.degrees(math.acos(pf));\n", + "E = math.sqrt((V*math.cos(math.radians(phi))+Ia*Ra)**2+(V*math.sin(math.radians(phi))+Ia*Xs)**2)\n", + "print \"induced emf = %f V\"%(E);\n", + "print (\"then at 0.8 leading power factor\");\n", + "Vt = 4743; #solved manually \n", + "print \"termial Voltage, line-to-line = %d V\"%(math.sqrt(3)*Vt)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "star connected alternator\n", + "Full-load current = 131 A\n", + "Voltage per phase = 3810 V\n", + "for 0.8 lagging power facor\n", + "induced emf = 4366.072552 V\n", + "then at 0.8 leading power factor\n", + "termial Voltage, line-to-line = 8215 V\n" + ] + } + ], + "prompt_number": 23 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.15 Page No : 450" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "#chapter 5\n", + "#example 5.15\n", + "#page 450\n", + "\n", + "# Given Data;\n", + "L = 8000.; #load\n", + "La = 5000.;\n", + "pf = 0.8;\n", + "\n", + "# Calculations and Results\n", + "phi = math.degrees(math.acos(pf));\n", + "print \"math.tan phi = %f\"%(math.degrees(math.atan(phi)));\n", + "print (\"FOR ALTERNATOR A\");\n", + "pf_a = 0.9;\n", + "phi_a = math.degrees(math.acos(pf_a));\n", + "print \"math.tan phi_a = %f\"%(math.degrees(math.atan(phi_a)));\n", + "print (\"reactive load = active load*math.tan phi\");\n", + "print (\"Active load = 8000kW\");\n", + "print \"reactive load = %d KVAr\"%(8000*math.degrees(math.atan(phi_a)));\n", + "print (\"Active Load A = 5000kW\");\n", + "print \"Reactive load A = %dkVAr\"%(5000*math.degrees(math.atan(phi_a)));\n", + "print \"Active load of B = %dkW\"%(L-La);\n", + "a = ((8000*math.degrees(math.atan(phi)))-(5000*math.degrees(math.atan(phi_a))))\n", + "print \"Reactive load of B = %dkVAr\"%(a);\n", + "B = a/(L-La);\n", + "phi_b = math.degrees(math.atan(B));\n", + "print \"phi_b = %f\"%(phi_b)\n", + "print \"Power Factor of B = %f\"%(math.cos(math.radians(phi_b)));" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "math.tan phi = 88.446382\n", + "FOR ALTERNATOR A\n", + "math.tan phi_a = 87.783943\n", + "reactive load = active load*math.tan phi\n", + "Active load = 8000kW\n", + "reactive load = 702271 KVAr\n", + "Active Load A = 5000kW\n", + "Reactive load A = 438919kVAr\n", + "Active load of B = 3000kW\n", + "Reactive load of B = 268651kVAr\n", + "phi_b = 89.360211\n", + "Power Factor of B = 0.011166\n" + ] + } + ], + "prompt_number": 27 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.16 Page No : 451" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "\n", + "# Given Data\n", + "V = 6600.;\n", + "ph = 3.; #3-phase alternators \n", + "power = 10000.; #total load\n", + "\n", + "# Calculations and Results\n", + "print (\"Two alternators in parallel connection\");\n", + "pf = 0.8;\n", + "Ia = 438; #armature current\n", + "Il = (power*1000)/(math.sqrt(3)*V*pf); #load current\n", + "print \"load current = %fA\"%(Il);\n", + "phi = math.degrees(math.acos(pf));\n", + "Ac = (Il*math.cos(math.radians(phi)));\n", + "Rc = (Il*math.sin(math.radians(phi)));\n", + "print \"Active component of current = %fA\"%(Ac);\n", + "print \"Reactive component of current = %fA\"%(Rc);\n", + "print \"Current supplied by each alternator = %fA\"%(Il/2);\n", + "print \"Active component of current supplied by each alternator = %fA\"%(Ac/2);\n", + "print \"Reactive component of current supplied by each alternator = %fA\"%(Rc/2);\n", + "print (\"Since steam supply is same,the active component remain the same \");\n", + "RIl = math.sqrt(Ia**2-(Ac/2)**2);\n", + "print \"Reactive component of Il = %dA\"%(RIl);\n", + "RI2 = (Rc-RIl);\n", + "print \"reactive component of I2 = %fA\"%(RI2);\n", + "I2 = math.sqrt((Ac/2)**2+(RI2)**2);\n", + "print \" I2 = %fA\"%(I2);\n", + "phi_2 = math.degrees(math.atan(RI2/(Ac/2)));\n", + "print \"phi 2 = %f degrees\"%(phi_2);\n", + "print \"math.cos phi 2 = %f\"%(math.cos(math.radians(phi_2)));\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Two alternators in parallel connection\n", + "load current = 1093.466419A\n", + "Active component of current = 874.773135A\n", + "Reactive component of current = 656.079851A\n", + "Current supplied by each alternator = 546.733209A\n", + "Active component of current supplied by each alternator = 437.386568A\n", + "Reactive component of current supplied by each alternator = 328.039926A\n", + "Since steam supply is same,the active component remain the same \n", + "Reactive component of Il = 23A\n", + "reactive component of I2 = 632.906796A\n", + " I2 = 769.336091A\n", + "phi 2 = 55.352588 degrees\n", + "math.cos phi 2 = 0.568525\n" + ] + } + ], + "prompt_number": 28 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "Example 5.17 Page No : 455" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "import math \n", + "# Given Data;\n", + "print (\"power factor of existing load is 0.8 lagging\");\n", + "pf = 0.8; #power factor\n", + "\n", + "# Calculations and Results\n", + "phi = math.degrees(math.acos(pf));\n", + "print \"phi = %d degree\"%(phi);\n", + "L = 800.; #load\n", + "kVAr1 = (L*math.degrees(math.atan(phi)));\n", + "print \"kVAr1 = %d \"%(kVAr1);\n", + "print (\"output for the synchronous motor is 200kW\");\n", + "output = 200.;\n", + "efficiency = 0.9;\n", + "kW = (output/efficiency);\n", + "print \"Input to the synchronous motor = %fkW\"%(kW);\n", + "TL = (L+kW); # total load\n", + "print \"Total load on the system = %fkW\"%(TL);\n", + "print (\"overall power factor of the load is to be raised to 0.92 lagging\");\n", + "pf = 0.92;\n", + "phi = math.degrees(math.acos(pf));\n", + "kVAr2 = (TL*math.degrees(math.atan(phi)))\n", + "print \"kVAr2 = %f\"%(kVAr2);\n", + "kVAr = kVAr1-kVAr2;\n", + "print \"lagging kVAr of synchronous codenser = %f\"%(kVAr);\n", + "print \"leading kVAr supplied by the motor = %f\"%(kVAr);\n", + "phi = math.degrees(math.atan(kVAr/kW));\n", + "print \"phi = %d degree\"%(phi);\n", + "print \"Power factor of the synchronos motor = %f leading \"%(math.cos(math.radians(phi)));\n", + "print \"KVA rating of the synchronous motor = %f\"%(kW/math.cos(math.radians(phi)));\n", + "\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "power factor of existing load is 0.8 lagging\n", + "phi = 36 degree\n", + "kVAr1 = 70757 \n", + "output for the synchronous motor is 200kW\n", + "Input to the synchronous motor = 222.222222kW\n", + "Total load on the system = 1022.222222kW\n", + "overall power factor of the load is to be raised to 0.92 lagging\n", + "kVAr2 = 89463.266068\n", + "lagging kVAr of synchronous codenser = -18706.160461\n", + "leading kVAr supplied by the motor = -18706.160461\n", + "phi = -89 degree\n", + "Power factor of the synchronos motor = 0.011879 leading \n", + "KVA rating of the synchronous motor = 18707.480373\n" + ] + } + ], + "prompt_number": 29 + } + ], + "metadata": {} + } + ] +}
\ No newline at end of file diff --git a/Electrical_Machines_by_S._K._Bhattacharya/screenshots/2.png b/Electrical_Machines_by_S._K._Bhattacharya/screenshots/2.png Binary files differnew file mode 100644 index 00000000..13bfad16 --- /dev/null +++ b/Electrical_Machines_by_S._K._Bhattacharya/screenshots/2.png diff --git a/Electrical_Machines_by_S._K._Bhattacharya/screenshots/4.png b/Electrical_Machines_by_S._K._Bhattacharya/screenshots/4.png Binary files differnew file mode 100644 index 00000000..3fee428b --- /dev/null +++ b/Electrical_Machines_by_S._K._Bhattacharya/screenshots/4.png diff --git a/Electrical_Machines_by_S._K._Bhattacharya/screenshots/5.png b/Electrical_Machines_by_S._K._Bhattacharya/screenshots/5.png Binary files differnew file mode 100644 index 00000000..6184a800 --- /dev/null +++ b/Electrical_Machines_by_S._K._Bhattacharya/screenshots/5.png |
