diff options
Diffstat (limited to 'Electric_Machinery_and_Transformers/CHAP_2.ipynb')
| -rwxr-xr-x | Electric_Machinery_and_Transformers/CHAP_2.ipynb | 432 |
1 files changed, 432 insertions, 0 deletions
diff --git a/Electric_Machinery_and_Transformers/CHAP_2.ipynb b/Electric_Machinery_and_Transformers/CHAP_2.ipynb new file mode 100755 index 00000000..1e18289c --- /dev/null +++ b/Electric_Machinery_and_Transformers/CHAP_2.ipynb @@ -0,0 +1,432 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "CHAPTER 2: DYNAMO CONSTRUCTION AND WINDINGS"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 2.1, Page number 48"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "m = 3.0 #Multipicity of the armature\n",
+ "P = 14.0 #Number of poles\n",
+ "\n",
+ "#Calculation\n",
+ "a_lap = m*P #Number of paths in the armature for lap winding\n",
+ "a_wave = 2*m #Number of paths in the armature for wave winding\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Number of paths in the armature for lap winding , a = %.f paths' %a_lap)\n",
+ "print('Case(b): Number of paths in the armature for wave winding , a = %.f paths' %a_wave)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Number of paths in the armature for lap winding , a = 42 paths\n",
+ "Case(b): Number of paths in the armature for wave winding , a = 6 paths\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 2.2, Page number 48"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P = 14.0 #Number of poles\n",
+ "phi = 4.2*10**6 #Flux per pole(lines)\n",
+ "S = 60.0 #Generator speed(rpm)\n",
+ "coils = 420.0 #Number of coils\n",
+ "turns_per_coil = 20.0 #Turns per coil\n",
+ "conductors_per_turn = 2.0 #Conductors per turn \n",
+ "a_lap = 42.0 #Number of parallel paths in the armature for a lap winding\n",
+ "a_wave = 6.0 #Number of parallel paths in the armature for a wave winding\n",
+ "\n",
+ "#Calculation\n",
+ "Z = coils*turns_per_coil*conductors_per_turn #Number of conductors\n",
+ "E_g_lap = phi*Z*S*P/(60*a_lap)*10**-8 #Generated EMF for lap winding(V)\n",
+ "E_g_wave = phi*Z*S*P/(60*a_wave)*10**-8 #Generated EMF for wave winding(V)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Generated EMF for lap winding , E_g = %.1f V' %E_g_lap)\n",
+ "print('Case(b): Generated EMF for wave winding , E_g = %.1f V' %E_g_wave)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Generated EMF for lap winding , E_g = 235.2 V\n",
+ "Case(b): Generated EMF for wave winding , E_g = 1646.4 V\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 2.3, Page number 53"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Variable declaration\n",
+ "slots = 72.0 #Number of slots\n",
+ "P = 4.0 #Number of poles\n",
+ "coils_spanned = 14.0 #14 slots are spanned while winding the coils\n",
+ "\n",
+ "#Calculation\n",
+ "coil_span = slots/P #Full-pitch coil span(slots/pole)\n",
+ "p_degree = coils_spanned/coil_span*180 #Span of the coil in electrical degrees\n",
+ "beta = (180-p_degree) #Beta(degree)\n",
+ "k_p1 = math.cos(beta/2*(math.pi/180)) #Pitch factor using eq(2-7)\n",
+ "k_p2 = math.sin(p_degree/2*(math.pi/180)) #Pitch factor using eq(2-8)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Full-pitch coil span = %.f slots/pole' %coil_span)\n",
+ "print('Case(b): Span of the coil in electrical degrees , p\u00b0 = %.f\u00b0' %p_degree)\n",
+ "print('Case(c): Pitch factor , k_p = %.2f ' %k_p1)\n",
+ "print('Case(d): Pitch factor , k_p = %.2f ' %k_p2)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Full-pitch coil span = 18 slots/pole\n",
+ "Case(b): Span of the coil in electrical degrees , p\u00b0 = 140\u00b0\n",
+ "Case(c): Pitch factor , k_p = 0.94 \n",
+ "Case(d): Pitch factor , k_p = 0.94 \n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 2.4, Page number 54"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Variable declaration\n",
+ "fractional_pitch = 13.0/16 #Coils having fractional pitch\n",
+ "slot =96.0 #Number of slots\n",
+ "P = 6.0 #Number of poles\n",
+ "\n",
+ "#Calculation\n",
+ "p_degree = fractional_pitch*180 #Span of the coil in electrical degrees\n",
+ "k_p = math.sin(p_degree/2*(math.pi/180)) #Pitch factor\n",
+ "\n",
+ "#Result\n",
+ "print('Pitch factor , k_p = %.4f ' %k_p)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Pitch factor , k_p = 0.9569 \n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 2.5, Page number 54"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P = 12.0 #Number of poles\n",
+ "theta = 360.0 #Number of mechanical degrees of rotation\n",
+ "alpha_b = 180.0 #Number of electrical degrees in case(b)\n",
+ "\n",
+ "#Calculation\n",
+ "alpha = (P*theta)/2 #Number of electrical degrees in one revolution(degree)\n",
+ "n = alpha/360 #Number of ac cycles\n",
+ "theta_b = (2*alpha_b)/P #Number of mechanical degrees of rotation\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Number of electrical degrees in one revolution , \u03b1 = %.f\u00b0 ' %alpha)\n",
+ "print(' Number of ac cycles , n = %.f cycles' %n)\n",
+ "print('Case(b): Mechanical angle , \u03b8 = %.f mechanical degrees' %theta_b)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Number of electrical degrees in one revolution , \u03b1 = 2160\u00b0 \n",
+ " Number of ac cycles , n = 6 cycles\n",
+ "Case(b): Mechanical angle , \u03b8 = 30 mechanical degrees\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 2.6, Page number 56"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Variable declaration\n",
+ "P = 4.0 #Number of poles\n",
+ "phi = 3.0 #Number of phases\n",
+ "slot_1 = 12.0 #Number of slots for case 1\n",
+ "slot_2 = 24.0 #Number of slots for case 2\n",
+ "slot_3 = 48.0 #Number of slots for case 3\n",
+ "slot_4 = 84.0 #Number of slots for case 4\n",
+ "\n",
+ "#Calculation\n",
+ "electrical_degrees = 180.0*P #Electrical degrees\n",
+ "#Case(a)\n",
+ "alpha_1 = electrical_degrees/slot_1 #Number of electrical degrees(\u00b0/slot)\n",
+ "n_1 = slot_1/(P*phi) #Number of slots per pole per phase(slot/pole-phase)\n",
+ "k_d1 = math.sin(n_1*alpha_1/2*(math.pi/180))/(n_1*math.sin(alpha_1/2*(math.pi/180)))#Distribution factor\n",
+ "#Case(b)\n",
+ "alpha_2 = electrical_degrees/slot_2 #Number of electrical degrees(\u00b0/slot)\n",
+ "n_2 = slot_2/(P*phi) #Number of slots per pole per phase(slot/pole-phase)\n",
+ "k_d2 = math.sin(n_2*alpha_2/2*(math.pi/180))/(n_2*math.sin(alpha_2/2*(math.pi/180)))#Distribution factor\n",
+ "#Case(c)\n",
+ "alpha_3 = electrical_degrees/slot_3 #Number of electrical degrees(\u00b0/slot)\n",
+ "n_3 = slot_3/(P*phi) #Number of slots per pole per phase(slot/pole-phase)\n",
+ "k_d3 = math.sin(n_3*alpha_3/2*(math.pi/180))/(n_3*math.sin(alpha_3/2*(math.pi/180)))#Distribution factor\n",
+ "#Case(d)\n",
+ "alpha_4 = electrical_degrees/slot_4 #Number of electrical degrees(\u00b0/slot)\n",
+ "n_4 = slot_4/(P*phi) #Number of slots per pole per phase(slot/pole-phase)\n",
+ "k_d4 = math.sin(n_4*alpha_4/2*(math.pi/180))/(n_4*math.sin(alpha_4/2*(math.pi/180)))#Distribution factor\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Distribution factor , k_d')\n",
+ "print(' 1: k_d = %.1f ' %k_d1)\n",
+ "print(' 2: k_d = %.3f ' %k_d2)\n",
+ "print(' 3: k_d = %.3f ' %k_d3)\n",
+ "print(' 4: k_d = %.3f ' %k_d4)\n",
+ "print('\\nCase(b): Tabular column')\n",
+ "print(' ________________________')\n",
+ "print(' n \\t \u03b1 \\t k_d')\n",
+ "print(' ________________________')\n",
+ "print(' %d \\t %d\u00b0 \\t %.1f' %(n_1,alpha_1,k_d1))\n",
+ "print(' %d \\t %d\u00b0 \\t %.3f' %(n_2,alpha_2,k_d2))\n",
+ "print(' %d \\t %d\u00b0 \\t %.3f' %(n_3,alpha_3,k_d3))\n",
+ "print(' %d \\t %.2f\u00b0 \\t %.3f' %(n_4,alpha_4,k_d4))\n",
+ "print(' ________________________')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Distribution factor , k_d\n",
+ " 1: k_d = 1.0 \n",
+ " 2: k_d = 0.966 \n",
+ " 3: k_d = 0.958 \n",
+ " 4: k_d = 0.956 \n",
+ "\n",
+ "Case(b): Tabular column\n",
+ " ________________________\n",
+ " n \t \u03b1 \t k_d\n",
+ " ________________________\n",
+ " 1 \t 60\u00b0 \t 1.0\n",
+ " 2 \t 30\u00b0 \t 0.966\n",
+ " 4 \t 15\u00b0 \t 0.958\n",
+ " 7 \t 8.57\u00b0 \t 0.956\n",
+ " ________________________\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 2.7, Page number 56"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Variable declaration\n",
+ "slots = 72.0 #Number of slots\n",
+ "P = 6.0 #Number of poles\n",
+ "phase = 3.0 #Three phase stator armature\n",
+ "N_c = 20.0 #Number of turns per coil\n",
+ "pitch = 5.0/6 #Pitch\n",
+ "phi = 4.8*10**6 #Flux per pole(lines)\n",
+ "S = 1200.0 #Rotor speed(rpm)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "f = (P*S)/120 #Frequency of rotor(Hz)\n",
+ "E_g_percoil = 4.44*phi*N_c*f*10**-8 #Generated effective voltage per coil of a full pitch coil(V/coil)\n",
+ "#Case(b)\n",
+ "N_p = (slots/phase)*N_c #Total number of turns per phase(turns/phase)\n",
+ "#Case(c)\n",
+ "n = slots/(phase*P) #Number of slots per pole per phase(slots/pole-phase)\n",
+ "alpha = (P*180)/slots #Number of electrical degrees between adjacent slots(degree)\n",
+ "k_d = math.sin(n*alpha/2*(math.pi/180))/(n*math.sin(alpha/2*(math.pi/180))) #Distribution factor\n",
+ "#Case(d)\n",
+ "span = pitch*180 #Span of the coil in electrical degrees\n",
+ "k_p = math.sin(span/2*(math.pi/180)) #Pitch factor\n",
+ "#Case(e)\n",
+ "E_gp = 4.44*phi*N_p*f*k_p*k_d*10**-8 #Total generated voltage(V/phase)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Generated effective voltage per coil of a full-pitch coil , E_g/coil = %.f V/coil' %E_g_percoil)\n",
+ "print('Case(b): Total number of turns per phase , N_p = %.f turns/phase' %N_p)\n",
+ "print('Case(c): Distribution factor , k_d = %.3f ' %k_d)\n",
+ "print('Case(d): Pitch factor , k_p = %.3f ' %k_p)\n",
+ "print('Case(e): Total generated voltage per phase , E_gp = %.f V/phase' %E_gp)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Generated effective voltage per coil of a full-pitch coil , E_g/coil = 256 V/coil\n",
+ "Case(b): Total number of turns per phase , N_p = 480 turns/phase\n",
+ "Case(c): Distribution factor , k_d = 0.958 \n",
+ "Case(d): Pitch factor , k_p = 0.966 \n",
+ "Case(e): Total generated voltage per phase , E_gp = 5678 V/phase\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 2.8, Page number 62"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Variable declaration\n",
+ "P = 8.0 #Number of poles\n",
+ "S = 900.0 #Speed(rev/min)\n",
+ "f_1 = 50.0 #Frequency(Hz)\n",
+ "f_2 = 25.0 #Frequency(Hz)\n",
+ "\n",
+ "#Calculation\n",
+ "f = (P*S)/120 #Frequency of the generated voltage(Hz)\n",
+ "S_1 = (120*f_1)/P #Speed of prime mover to generate 50 Hz(rpm)\n",
+ "S_2 = (120*f_2)/P #Speed of prime mover to generate 25 Hz(rpm)\n",
+ "omega_1 = (4*math.pi*f_1)/P #Speed of prime mover to generate 50 Hz(rad/s)\n",
+ "omega_2 = (4*math.pi*f_2)/P #Speed of prime mover to generate 25 Hz(rad/s)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Frequency of the generated voltage , f = %.f Hz' %f)\n",
+ "print('Case(b): Prime mover speed required to generate 50 Hz , S = %.f rpm' %S_1)\n",
+ "print(' Prime mover speed required to generate 25 Hz , S = %.f rpm' %S_2)\n",
+ "print('Case(c): Prime mover speed required to generate 50 Hz , S = %.f\u03c0 rad/s' %(omega_1/math.pi))\n",
+ "print(' Prime mover speed required to generate 25 Hz , S = %.1f\u03c0 rad/s' %(omega_2/math.pi))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Frequency of the generated voltage , f = 60 Hz\n",
+ "Case(b): Prime mover speed required to generate 50 Hz , S = 750 rpm\n",
+ " Prime mover speed required to generate 25 Hz , S = 375 rpm\n",
+ "Case(c): Prime mover speed required to generate 50 Hz , S = 25\u03c0 rad/s\n",
+ " Prime mover speed required to generate 25 Hz , S = 12.5\u03c0 rad/s\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file |