path: root/Electric_Machinery_and_Transformers/CHAP_2.ipynb

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