path: root/Electric_Machinery_and_Transformers/CHAP_1.ipynb

{
 "metadata": {
  "name": ""
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "CHAPTER 1: ELECTROMECHANICAL FUNDAMENTALS"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 1.1, Page number 5"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Variable declaration\n",
      "t = 50.0*10**-3  #Time(second)\n",
      "phi = 8.0*10**6  #Uniform magnetic field(maxwells)\n",
      "\n",
      "#Calculation\n",
      "E_av = (phi/t)*10**-8   #Average voltage generated in the conductor(V) \n",
      "\n",
      "#Result\n",
      "print('Average voltage generated in the conductor , E_av = %.1f V' %E_av)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Average voltage generated in the conductor , E_av = 1.6 V\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 1.2, Page number 6"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Variable declaration\n",
      "l = 18.0      #Length of the conductor(inches)\n",
      "B = 50000.0   #Uniform magnetic field(lines/sq.inches)\n",
      "d = 720.0     #Distance travelled by conductor(inches)\n",
      "t = 1.0       #Time taken for the conductor to move(second)\n",
      "\n",
      "#Calculation\n",
      "#Case(a)\n",
      "v = d/t             #Velocity with which the conductor moves(inches/second)\n",
      "e = B*l*v*10**-8    #Instantaneous induced EMF(V)\n",
      "#Case(b)\n",
      "A = d*l             #Area swept by the conductor while moving(sq.inches)\n",
      "phi = B*A           #Uniform magnetic field(lines) \n",
      "E = (phi/t)*10**-8  #Average induced EMF(V)\n",
      "\n",
      "#Result\n",
      "print('Case(a): Instantaneous induced EMF , e = %.2f V' %e)\n",
      "print('Case(b): Average induced EMF , E = %.2f V' %E)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Case(a): Instantaneous induced EMF , e = 6.48 V\n",
        "Case(b): Average induced EMF , E = 6.48 V\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 1.3, Page number 8"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "\n",
      "#Variable declaration\n",
      "l = 18.0      #Length of the conductor(inches)\n",
      "B = 50000.0   #Uniform magnetic field(lines/sq.inches)\n",
      "d = 720.0     #Distance travelled by conductor(inches)\n",
      "t = 1.0       #Time taken for the conductor to move(second)\n",
      "theta = 75.0  #Angle between the motion of the conductor and field(degree)\n",
      "\n",
      "#Calculation\n",
      "v = d/t                                         #Velocity with which the conductor moves(inches/second)\n",
      "E = B*l*v*math.sin(theta*math.pi/180)*10**-8    #Instantaneous induced voltage(V)\n",
      "\n",
      "#Result\n",
      "print('Average induced voltage , E = %.2f V' %E)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Average induced voltage , E = 6.26 V\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 1.4, Page number 9"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "\n",
      "#Variable declaration\n",
      "v = 1.5          #Velocity of moving conductor(m/s)\n",
      "l = 0.4          #Length of the conductor(m)\n",
      "B = 1            #Uniform field(tesla)\n",
      "theta_a = 90.0   #Angle between the motion of the conductor and field(Degree)\n",
      "theta_b = 35.0   #Angle between the motion of the conductor and field(Degree)\n",
      "theta_c = 120.0  #Angle between the motion of the conductor and field(Degree)\n",
      "\n",
      "#Calculation\n",
      "E_a = B*l*v*math.sin(theta_a*math.pi/180)  #Voltage induced in the conductor(V)\n",
      "E_b = B*l*v*math.sin(theta_b*math.pi/180)  #Voltage induced in the conductor(V)\n",
      "E_c = B*l*v*math.sin(theta_c*math.pi/180)  #Voltage induced in the conductor(V)\n",
      "\n",
      "#Result\n",
      "print('Case(a): Voltage induced in the conductor , E = %.1f V' %E_a)\n",
      "print('Case(b): Voltage induced in the conductor , E = %.3f V' %E_b)\n",
      "print('Case(c): Voltage induced in the conductor , E = %.2f V' %E_c)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Case(a): Voltage induced in the conductor , E = 0.6 V\n",
        "Case(b): Voltage induced in the conductor , E = 0.344 V\n",
        "Case(c): Voltage induced in the conductor , E = 0.52 V\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 1.5, Page number 19"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Variable declaration\n",
      "no_of_conductors = 40.0     #Number of conductors\n",
      "A = 2.0                     #Number of parallel paths\n",
      "path = A\n",
      "flux_per_pole = 6.48*10**8  #Flux per pole(lines) \n",
      "N = 30.0                    #Speed of the prime mover(rpm)\n",
      "R_per_path = 0.01           #Resistance per path\n",
      "I = 10.0                    #Current carrying capacity of each conductor(A)\n",
      "P = 2.0                     #Number of poles\n",
      "\n",
      "#Calculation\n",
      "phi_T = P*flux_per_pole     #Total flux linked in one revolution(lines)\n",
      "t = (1/N)*(60)              #Time for one revolution(s/rev)\n",
      "#Case(a)\n",
      "e_av_per_conductor = (phi_T/t)*10**-8                     #Average voltage generated(V/conductor)\n",
      "E_per_path = (e_av_per_conductor)*(no_of_conductors/path) #Average voltage generated(V/path)\n",
      "#Case(b)\n",
      "E_g = E_per_path                                          #Generated armature voltage(V)\n",
      "#Case(c)\n",
      "I_a = (I/path)*(2*path)                                   #Armature current delivered to an external load(A)\n",
      "#Case(d)\n",
      "R_a = (R_per_path)/path*(no_of_conductors/P)              #Armature resistance(ohm)\n",
      "#Case(e)\n",
      "V_t = E_g-(I_a*R_a)                                       #Terminal voltage of the generator(V)\n",
      "#Case(f)\n",
      "P = V_t*I_a                                               #Generator power rating(W)\n",
      "\n",
      "#Result\n",
      "print('Case(a): Average voltage generated per path , E/path = %.1f V/path' %E_per_path)\n",
      "print('Case(b): Generated armature voltage , E_g = %.1f V' %E_g)\n",
      "print('Case(c): Armature current delivered to an external load , I_a = %.f A' %I_a)\n",
      "print('Case(d): Armature resistance , R_a = %.1f \u03a9' %R_a)\n",
      "print('Case(e): Terminal voltage of the generator , V_t = %.1f V' %V_t)\n",
      "print('Case(f): Generator power rating , P = %.f W' %P)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Case(a): Average voltage generated per path , E/path = 129.6 V/path\n",
        "Case(b): Generated armature voltage , E_g = 129.6 V\n",
        "Case(c): Armature current delivered to an external load , I_a = 20 A\n",
        "Case(d): Armature resistance , R_a = 0.1 \u03a9\n",
        "Case(e): Terminal voltage of the generator , V_t = 127.6 V\n",
        "Case(f): Generator power rating , P = 2552 W\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 1.6, Page number 20"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Variable declaration\n",
      "no_of_conductors = 40.0     #Number of conductors\n",
      "path = 4.0                  #Number of parallel paths\n",
      "flux_per_pole = 6.48*10**8  #Flux per pole(lines) \n",
      "N = 30.0                    #Speed of the prime mover(rpm)\n",
      "R_per_path = 0.01           #Resistance per path\n",
      "I = 10.0                    #Current carrying capacity of each conductor(A)\n",
      "P = 4.0                     #Number of poles\n",
      "\n",
      "#Calculation\n",
      "phi_T = 2*flux_per_pole     #Total flux linked in one revolution(lines). From Example 1.5\n",
      "t = (1/N)*(60)              #Time for one revolution(s/rev)\n",
      "#Case(a)\n",
      "e_av_per_conductor = (phi_T/t)*10**-8                     #Average voltage generated(V/conductor)\n",
      "E_per_path = (e_av_per_conductor)*(no_of_conductors/path) #Average voltage generated(V/path)\n",
      "#Case(b)\n",
      "E_g = E_per_path                                          #Generated armature voltage(V)\n",
      "#Case(c)\n",
      "I_a = (I/path)*(4*path)                                   #Armature current delivered to an external load(A)\n",
      "#Case(d)\n",
      "R_a = (R_per_path)/path*(no_of_conductors/P)              #Armature resistance(ohm)\n",
      "#Case(e)\n",
      "V_t = E_g-(I_a*R_a)                                       #Terminal voltage of the generator(V)\n",
      "#Case(f)\n",
      "P = V_t*I_a                                               #Generator power rating(W)\n",
      "\n",
      "#Result\n",
      "print('Case(a): Average voltage generated per path , E/path = %.1f V/path' %E_per_path)\n",
      "print('Case(b): Generated armature voltage , E_g = %.1f V' %E_g)\n",
      "print('Case(c): Armature current delivered to an external load , I_a = %.f A' %I_a)\n",
      "print('Case(d): Armature resistance , R_a = %.3f \u03a9' %R_a)\n",
      "print('Case(e): Terminal voltage of the generator , V_t = %.1f V' %V_t)\n",
      "print('Case(f): Generator power rating , P = %.f W' %P)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Case(a): Average voltage generated per path , E/path = 64.8 V/path\n",
        "Case(b): Generated armature voltage , E_g = 64.8 V\n",
        "Case(c): Armature current delivered to an external load , I_a = 40 A\n",
        "Case(d): Armature resistance , R_a = 0.025 \u03a9\n",
        "Case(e): Terminal voltage of the generator , V_t = 63.8 V\n",
        "Case(f): Generator power rating , P = 2552 W\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 1.7, Page number 23"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Variable declaration\n",
      "N = 1.0             #Number of turns\n",
      "phi = 6.48*10**8    #Magnetic flux(lines)\n",
      "rpm = 30.0          #Number of revolution\n",
      "s = rpm/60          #Number of revolution of the coil per second(rev/s)\n",
      "\n",
      "#Calculation\n",
      "E_av_per_coil = 4*phi*N*s*10**-8             #Average voltage per coil(V/coil)\n",
      "E_av_per_coil_side = E_av_per_coil*(1.0/2)   #Average voltage per conductor(V/conductor)\n",
      "\n",
      "#Result\n",
      "print('Case(a): Average voltage per coil , E_av/coil = %.2f V/coil' %E_av_per_coil)\n",
      "print('Case(b): Average voltage per conductor , E_av/coil side = %.2f V/conductor' %E_av_per_coil_side)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Case(a): Average voltage per coil , E_av/coil = 12.96 V/coil\n",
        "Case(b): Average voltage per conductor , E_av/coil side = 6.48 V/conductor\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 1.8, Page number 23"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "\n",
      "#Variable declaration\n",
      "N = 1.0                       #Number of turns\n",
      "phi_lines = 6.48*10**8        #Magnetic flux(lines/pole)\n",
      "rpm = 30.0                    #Number of revolution per second\n",
      "s = rpm/60                    #Number of revolution of the coil per second(rev/s)\n",
      "\n",
      "#Calculation\n",
      "phi = phi_lines*10**-8                #Magnetic flux(Wb)\n",
      "omega = rpm*2*math.pi*(1.0/60)        #Angular velocity(rad/s)\n",
      "E_av_per_coil = 0.63662*omega*phi*N   #Average voltage per coil(V/coil)\n",
      "\n",
      "#Result\n",
      "print('Average voltage per coil , E_av/coil  = %.2f V/coil' %E_av_per_coil)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Average voltage per coil , E_av/coil  = 12.96 V/coil\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 1.9, Page number 24"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Variable declaration\n",
      "P = 2.0            #Number of poles\n",
      "Z = 40.0           #Number of conductors\n",
      "a = 2.0            #Parallel paths\n",
      "phi = 6.48*10**8   #Magnetic flux(lines/pole)\n",
      "S = 30.0           #Speed of the prime mover\n",
      "\n",
      "#Calculation\n",
      "E_g = (phi*Z*S*P)/(60*a)*10**-8   #Average voltage between the brushes(V)\n",
      "\n",
      "#Result\n",
      "print('Average voltage between the brushes , E_g = %.1f V' %E_g)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Average voltage between the brushes , E_g = 129.6 V\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 1.10, Page number 24"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "\n",
      "#Variable declaration\n",
      "no_of_coils = 40.0      #Number of coils\n",
      "N = 20.0                #Number of turns in each coil\n",
      "omega = 200.0           #Angular velocity of armature(rad/s)\n",
      "phi = 5.0*10**-3        #Flux(Wb/pole)\n",
      "a = 4.0                 #Number of parallel paths\n",
      "P = 4.0                 #Number of poles\n",
      "\n",
      "#Calculation\n",
      "Z = no_of_coils*2.0*N                #Number of conductors\n",
      "E_g = (phi*Z*omega*P)/(2*math.pi*a)  #Voltage generated by the armature between brushes(V)\n",
      "\n",
      "#Result\n",
      "print('Case(a): Number of conductors , Z = %.f conductors' %Z)\n",
      "print('Case(b): Voltage between brushes generated by the armature , E_g = %.1f V' %E_g)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Case(a): Number of conductors , Z = 1600 conductors\n",
        "Case(b): Voltage between brushes generated by the armature , E_g = 254.6 V\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 1.11, Page number 26"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Variable declaration\n",
      "l = 0.5            #Length of the conductor(m)\n",
      "A = 0.1*0.2        #Area of the pole face(sq.meter)\n",
      "phi = 0.5*10**-3   #Magnetic flux(Wb)\n",
      "I = 10.0           #Current in the conductor(A)\n",
      "\n",
      "#Calculation\n",
      "B = phi/A          #Flux density(Wb/m^2)\n",
      "F = B*I*l*1000     #Magnitude of force(mN)\n",
      "\n",
      "#Result\n",
      "print('Case(a): Magnitude of the force , F = %.f mN' %F)\n",
      "print('Case(b): The direction of the force on the conductor is %.f mN in an upward direction' %F)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Case(a): Magnitude of the force , F = 125 mN\n",
        "Case(b): The direction of the force on the conductor is 125 mN in an upward direction\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 1.12, Page number 26"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "\n",
      "#Variable declaration\n",
      "l = 0.5            #Length of the conductor(m)\n",
      "A = 0.1*0.2        #Area of the pole face(sq.meter)\n",
      "phi = 0.5*10**-3   #Magnetic flux(Wb)\n",
      "I = 10.0           #Current in the conductor(A)\n",
      "theta = 75.0       #Angle between the conductor and the flux density(degree)\n",
      "\n",
      "#Calculation\n",
      "B = phi/A                                      #Flux density(Wb/m^2)\n",
      "F = B*I*l*math.sin(theta*math.pi/180)*1000     #Magnitude of force(mN)\n",
      "\n",
      "#Result\n",
      "print('Magnitude of the force , F = %.2f mN in an vertically upward direction' %F)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Magnitude of the force , F = 120.74 mN in an vertically upward direction\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 1.13, Page number 29"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Variable declaration\n",
      "R_a = 0.25   #Armature resistance(ohm)\n",
      "V_a = 125.0  #DC bus voltage(V)\n",
      "I_a = 60.0   #Armature current(A)\n",
      "\n",
      "#Calculation\n",
      "E_c = V_a-(I_a*R_a)  #Counter EMF generated in the armature conductors of motor(V)\n",
      "\n",
      "#Result\n",
      "print('Counter EMF generated in the armature conductors of motor , E_c = %.f V' %E_c)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Counter EMF generated in the armature conductors of motor , E_c = 110 V\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 1.14, Page number 29"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Variable declaration\n",
      "V_a = 110.0  #Voltage across armature(V)\n",
      "I_a = 60.0   #Armature current(A)\n",
      "R_a = 0.25   #Armature resistance(ohm)\n",
      "P = 6.0      #Number of poles\n",
      "a = 12.0     #Number of paths\n",
      "Z = 720.0    #No. of armature conductors\n",
      "S = 1800.0   #Speed(rpm)\n",
      "\n",
      "#Calculation\n",
      "E_g = V_a+(I_a*R_a)                   #Generated EMF in the armature(V)\n",
      "phi_lines = E_g*60*a/(Z*S*P*10**-8)   #Flux per pole in lines(lines/pole)\n",
      "phi_mWb = phi_lines*10**-8*1000       #Flux per pole milliwebers(mWb)\n",
      "\n",
      "#Result\n",
      "print('Case(a): Generated EMF in the armature , E_g = %.f V' %E_g)\n",
      "print('Case(b): Flux per pole in lines , \u03a6 = %.2e lines/pole' %phi_lines)\n",
      "print('Case(c): Flux per pole milliwebers , \u03a6 = %.1f mWb' %phi_mWb)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Case(a): Generated EMF in the armature , E_g = 125 V\n",
        "Case(b): Flux per pole in lines , \u03a6 = 1.16e+06 lines/pole\n",
        "Case(c): Flux per pole milliwebers , \u03a6 = 11.6 mWb\n"
       ]
      }
     ],
     "prompt_number": 1
    }
   ],
   "metadata": {}
  }
 ]
}