{
 "metadata": {
  "name": ""
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Chapter 07 : Armature Windings"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.1, Page No 148"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "# to calculate no of parrallel path\n",
      "\n",
      "S=12.0         #no of commutator segments\n",
      "P=4 \n",
      "\n",
      "#Calculations\n",
      "Y_cs=S/P         #slots\n",
      "Y_b=2*Y_cs+1 \n",
      "y_f=Y_b-2 \n",
      "\n",
      "#Results\n",
      "print(y_f,'no of parralel path') "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(5.0, 'no of parralel path')\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.2, Page No 149"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "# to find spacing b/w brushes\n",
      "\n",
      "S=22.0 \n",
      "P=4 \n",
      "\n",
      "#Calculations\n",
      "Y_cs=math.floor(S/P) \n",
      "U=6         #coil sides/slot\n",
      "Y_b=Y_cs*U+1 \n",
      "y_f=Y_b-2 \n",
      "n=(1.0/2)*U*S         #no of commutator segments\n",
      "A=4         #no of brushes\n",
      "sp=n/A \n",
      "\n",
      "#Results\n",
      "print(sp,'spacing b/w adjacent brushes') "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(16.5, 'spacing b/w adjacent brushes')\n"
       ]
      }
     ],
     "prompt_number": 2
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.3, Page No 149"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to calculate relevant pitches for wave windings\n",
      "\n",
      "S=16 \n",
      "P=6 \n",
      "\n",
      "#Calculations\n",
      "Y_cs=math.floor(S/P) \n",
      "U=2 \n",
      "Y_b=Y_cs*U+1 \n",
      "C=16 \n",
      "y_c=U*(C-1)/P \n",
      "y_f=2*y_c-Y_b \n",
      "\n",
      "#Results\n",
      "print(y_f,'no of pitches') "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(5.0, 'no of pitches')\n"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.4 Page No 150"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "# to find distance b/w brushes\n",
      "\n",
      "S=28.0\n",
      "P=4.0 \n",
      "U=8.0 \n",
      "\n",
      "#Calculations\n",
      "c=U*S/2 \n",
      "y_c=2*(c-1)/P \n",
      "Y_c=55.0 \n",
      "C=(P/2)*Y_c+1 \n",
      "Y_cs=math.floor(S/P) \n",
      "Y_b=Y_cs*U+1 \n",
      "y_f=2*Y_c-Y_b \n",
      "d=C/P\n",
      "\n",
      "#Results\n",
      "print(d,'dis b/w brushes') "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(27.75, 'dis b/w brushes')\n"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.5, Page No 151"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "# to find the torque and gross mech power developed \n",
      "\n",
      "  \n",
      "D=.3 \n",
      "l=.2 \n",
      "p=4 \n",
      "fd=.4         #flux density\n",
      "\n",
      "#Calculations\n",
      "phi=math.pi*(D/p)*l*fd         #flux/pole\n",
      "n=1500 \n",
      "Z=400 \n",
      "A=4 \n",
      "E_a=phi*n*Z*(p/A)/60 \n",
      "I_a=25 \n",
      "mp=E_a*I_a \n",
      "\n",
      "#Results\n",
      "print(mp,'gross mech power developed(W)') \n",
      "T=mp/(2*math.pi*n/60) \n",
      "print(T,'torque developed(Nm)') "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(4712.388980384691, 'gross mech power developed(W)')\n",
        "(30.00000000000001, 'torque developed(Nm)')\n"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.6, Page No 152"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "# to calculate ratio of generator speed to motor speed\n",
      "\n",
      "V=220.0 \n",
      "P=4000.0 \n",
      "I_a=P/V \n",
      "r_a=.4         #armature resistance\n",
      "\n",
      "#Calculations\n",
      "E_ag=V+I_a*r_a \n",
      "E_am=V-I_a*r_a \n",
      "a=1.1         #phi_m/phi_g\n",
      "n=(E_ag/E_am)*a \n",
      "\n",
      "#Results\n",
      "print(n,'n_g/n_m') "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(1.1752136752136753, 'n_g/n_m')\n"
       ]
      }
     ],
     "prompt_number": 6
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.7 Page No 163"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "# to calculate speed of motor\n",
      "\n",
      "V=230.0 \n",
      "R_f=115.0         #field resistance\n",
      "I_f=V/R_f \n",
      "P_g=100000.0         #electric power (m/c running as generator)\n",
      "\n",
      "#Calculations\n",
      "I_L=P_g/V \n",
      "I_a=I_f+I_L \n",
      "R_a=.08         #armature resitance\n",
      "E_ag=V+I_a*R_a \n",
      "n_g=750         #speed\n",
      "\n",
      "P_m=9000         #m/c running as motor\n",
      "I_l=P_m/V \n",
      "I_A=I_l-I_f \n",
      "E_am=V-I_A*R_a \n",
      "n_m=(E_am/E_ag)*n_g \n",
      "\n",
      "#Results\n",
      "print(n_m,'motor speed(rpm)') "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(642.6756902233134, 'motor speed(rpm)')\n"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.8, Page No 164"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to calculate electomagnetic power and torque\n",
      "\n",
      "  \n",
      "E_a=250 \n",
      "R_a=.05 \n",
      "n=3000 \n",
      "w_m=(n*2*math.pi)/60 \n",
      "\n",
      "#Calculations\n",
      "print('when terminal voltage is 255V') \n",
      "V_t=255 \n",
      "I_a=(V_t-E_a)/R_a \n",
      "P_in=E_a*I_a \n",
      "print(P_in,'electromagnetic power(W)') \n",
      "T=P_in/w_m \n",
      "print(T,'torque(Nm)') \n",
      "\n",
      "print('when terminal voltage is 248V') \n",
      "V_t=248 \n",
      "I_a=(E_a-V_t)/R_a \n",
      "P_in=E_a*I_a \n",
      "\n",
      "#Results\n",
      "print(P_in,'electromagnetic power(W)') \n",
      "T=P_in/w_m \n",
      "print(T,'torque(Nm)') \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "when terminal voltage is 255V\n",
        "(25000.0, 'electromagnetic power(W)')\n",
        "(79.57747154594767, 'torque(Nm)')\n",
        "when terminal voltage is 248V\n",
        "(10000.0, 'electromagnetic power(W)')\n",
        "(31.830988618379067, 'torque(Nm)')\n"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.9 Page No 165"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to calculate electomagnetic power\n",
      "\n",
      "  \n",
      "n_f=3000.0         #field speed\n",
      "n_a=2950.0         #armature speed\n",
      "E=250.0\n",
      "\n",
      "#Calculations\n",
      "E_a=E*(n_a/n_f) \n",
      "V_t=250 \n",
      "R_a=0.05 \n",
      "I_a=(V_t-E_a)/R_a \n",
      "P_in=V_t*I_a \n",
      "\n",
      "#Results\n",
      "print(P_in,'power(W)') \n",
      "P=E_a*I_a \n",
      "print(P,'electromagnetic power(W)')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(20833.333333333427, 'power(W)')\n",
        "(20486.111111111204, 'electromagnetic power(W)')\n"
       ]
      }
     ],
     "prompt_number": 9
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.10 Page No 165"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "# to calculate cross and demagnetising turns/pole\n",
      "\n",
      "  \n",
      "P=250000.0 \n",
      "V=400.0\n",
      "I_a=P/V         #armature current\n",
      "n=6         #no of parallel path\n",
      "\n",
      "#Calculations\n",
      "I_c=I_a/n     #conductor current\n",
      "Z=720         #lap wound conductors\n",
      "AT_a=(1/2)*Z*I_c/n \n",
      "\n",
      "B=2.5*n/2         #brush leadof 2.5 angular degrees(mech) from geo neutral\n",
      "AT_c=AT_a*(1-(2*B)/180) \n",
      "\n",
      "#Results\n",
      "print(AT_c,'cross magnetising ampere turns(AT/pole)') \n",
      "AT_d=AT_a*((2*B)/180) \n",
      "print(AT_d,'demagnetising ampere turns(AT/pole)') "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(0.0, 'cross magnetising ampere turns(AT/pole)')\n",
        "(0.0, 'demagnetising ampere turns(AT/pole)')\n"
       ]
      }
     ],
     "prompt_number": 10
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.11 Page No 172"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "\n",
      "#initialisation of variables\n",
      "#to calculate no of conductors on each pole piece\n",
      "\n",
      "Z=256 \n",
      "A=6 \n",
      "P=6 \n",
      "\n",
      "#Calculations\n",
      "r=.71         #ratio of pole arc to pole pitch\n",
      "N_cw=(Z/(2*A*P))*r    \n",
      "N_cc=math.ceil(2*N_cw) \n",
      "\n",
      "#Results\n",
      "print(N_cc,'compensating conductors/pole') "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(5.0, 'compensating conductors/pole')\n"
       ]
      }
     ],
     "prompt_number": 11
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.12, Page No 176"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "\n",
      "#initialisation of variables\n",
      "#to calculate no of turns reqd on each interpole\n",
      "\n",
      "  \n",
      "P=25000 \n",
      "V=440 \n",
      "I_a=P/V \n",
      "Z=846 \n",
      "A=2 \n",
      "P=4 \n",
      "B_i=.5 \n",
      "\n",
      "#Calculations\n",
      "u_o=4*math.pi*10**-7 \n",
      "l_gi=.003 \n",
      "AT_i=((I_a*Z)/(2*A*P))+(B_i*l_gi)/u_o \n",
      "N_i=math.ceil(AT_i/I_a) \n",
      "\n",
      "#Results\n",
      "print(N_i,'no of turns') "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(75.0, 'no of turns')\n"
       ]
      }
     ],
     "prompt_number": 12
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.16, Page No 197"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to calculate terminal voltage and rated output current and calculate no of series turns/pole\n",
      "\n",
      "  \n",
      "P=100000.0 \n",
      "V=200.0 \n",
      "I_L=P/V \n",
      "I_f=5 \n",
      "I_a=I_L+I_f \n",
      "I_se=I_a \n",
      "N_se=5 \n",
      "N_f=1200\n",
      "\n",
      "#Calculations\n",
      "I_feq=I_f+(N_se/N_f)*I_se \n",
      "n=1000 \n",
      "E_a=225 \n",
      "nn=950 \n",
      "E_aa=E_a*(nn/n) \n",
      "R_a=0.03 \n",
      "R_se=0.004 \n",
      "V_t=E_aa-I_a*(R_a+R_se) \n",
      "print(V_t,'terminal voltage(V)') \n",
      "I_fd=0.001875*I_a \n",
      "V_t=200 \n",
      "E_a=V_t+I_a*(R_a+R_se) \n",
      "E_aa=E_a*(n/nn) \n",
      "I_fnet=7.5 \n",
      "N_f=1000 \n",
      "N_se=math.ceil((I_fnet+I_fd-I_f)*(N_f/I_a)) \n",
      "\n",
      "#Results\n",
      "print(N_se,'no of series turns/pole') \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(-17.17, 'terminal voltage(V)')\n",
        "(7.0, 'no of series turns/pole')\n"
       ]
      }
     ],
     "prompt_number": 13
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.22, Page No 198"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "# to compute terminal voltage at rated voltage current\n",
      "\n",
      "  \n",
      "R_a=0.05 \n",
      "R_se=.01 \n",
      "N_f=1000 \n",
      "N_se=3 \n",
      "I_sf=5.6         #shunt field current\n",
      "I_L=200 \n",
      "\n",
      "#Calculations\n",
      "I_a=I_L+I_sf \n",
      "N=N_f*I_sf+I_a*N_se         #excitation ampere turns\n",
      "I_freq=N/N_f \n",
      "\n",
      "E_a=282 \n",
      "n=1200 \n",
      "nn=1150 \n",
      "Ea=E_a*(nn/n) \n",
      "V_t=Ea-I_a*(R_a+R_se) \n",
      "\n",
      "#Results\n",
      "print(V_t,'terminal voltage(V)') \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(-12.336, 'terminal voltage(V)')\n"
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.24, Page No 223"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to find generator output\n",
      "\n",
      "P=20000.0 \n",
      "V=250.0 \n",
      "I_a=P/V \n",
      "R_a=.16 \n",
      "vd=I_a*R_a\n",
      "\n",
      "#Calculations\n",
      "def output(E_a):\n",
      "    V_t=E_a-vd \n",
      "    P_o=I_a*V_t \n",
      "    print(P_o,'generator output(W)') \n",
      "    return P_o\n",
      "\t\n",
      "print('at I_f=1A') \n",
      "E_a=150.0\n",
      "P_o=output(E_a) \n",
      "print('at I_f=2A') \n",
      "E_a=257.5 \n",
      "P_o=output(E_a) \n",
      "print('at I_f=2.5A') \n",
      "E_a=297.5 \n",
      "P_o=output(E_a) \n",
      "\n",
      "print('at speed 1200rpm') \n",
      "\n",
      "def ratio(E_a):\n",
      "    Ea=.8*E_a\n",
      "    return Ea\n",
      "\t\n",
      "print('at I_f=1A') \n",
      "E_a=150 \n",
      "Ea=ratio(E_a) \n",
      "P_o=output(Ea) \n",
      "print('at I_f=2A') \n",
      "E_a=257.5 \n",
      "Ea=ratio(E_a) \n",
      "P_o=output(Ea) \n",
      "\n",
      "#Results\n",
      "print('at I_f=2.5A') \n",
      "E_a=297.5 \n",
      "Ea=ratio(E_a) \n",
      "P_o=output(Ea) "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "at I_f=1A\n",
        "(10976.0, 'generator output(W)')\n",
        "at I_f=2A\n",
        "(19576.0, 'generator output(W)')\n",
        "at I_f=2.5A\n",
        "(22776.0, 'generator output(W)')\n",
        "at speed 1200rpm\n",
        "at I_f=1A\n",
        "(8576.0, 'generator output(W)')\n",
        "at I_f=2A\n",
        "(15456.0, 'generator output(W)')\n",
        "at I_f=2.5A\n",
        "(18016.0, 'generator output(W)')\n"
       ]
      }
     ],
     "prompt_number": 15
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.25, Page No 223"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to find power to the load\n",
      "\n",
      "  \n",
      "R_L=3 \n",
      "R_a=.16 \n",
      "\n",
      "#Calculations\n",
      "def output(E_a):\n",
      "    I_a=E_a/(R_a+R_L)  \n",
      "    P_o=I_a**2*R_L \n",
      "    print(P_o,'power fed to the load(W)') \n",
      "    return P_o\n",
      "\n",
      "print('at I_f=1A') \n",
      "E_a=150 \n",
      "P_o=output(E_a) \n",
      "print('at I_f=2A') \n",
      "E_a=257.5 \n",
      "P_o=output(E_a) \n",
      "\n",
      "#Results\n",
      "print('at I_f=2.5A') \n",
      "E_a=297.5 \n",
      "P_o=output(E_a) \n",
      "\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "at I_f=1A\n",
        "(6759.734016984458, 'power fed to the load(W)')\n",
        "at I_f=2A\n",
        "(19920.56060727447, 'power fed to the load(W)')\n",
        "at I_f=2.5A\n",
        "(26590.1648373658, 'power fed to the load(W)')\n"
       ]
      }
     ],
     "prompt_number": 16
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.28, Page No 231"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to compute the generator induced emf when fully loaded in long shunt compound and short shunt compound\n",
      "\n",
      "  \n",
      "P=75000.0 \n",
      "V_t=250.0 \n",
      "I_L=P/V_t \n",
      "R_a=.04 \n",
      "R_se=.004 \n",
      "R_f=100 \n",
      "\n",
      "#Calculations\n",
      "print('case of long shunt') \n",
      "I_f=V_t/R_f \n",
      "I_a=I_L+I_f \n",
      "V_b=2 \n",
      "E_aLS=V_t+I_a*(R_a+R_se)+V_b \n",
      "print(E_aLS,'generator induced emf(V)') \n",
      "\n",
      "print('case of short shunt') \n",
      "V_b=V_t+I_L*R_se \n",
      "I_f=V_b/R_f \n",
      "I_a=I_L+I_f \n",
      "E_aSS=V_t+(I_a*R_a)+2 \n",
      "\n",
      "#Results\n",
      "print(E_aSS,'generator induced emf(V)') \n",
      "\n",
      "d=(E_aLS-E_aSS)*100/V_t \n",
      "print(d,'percent diff') "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "case of long shunt\n",
        "(265.31, 'generator induced emf(V)')\n",
        "case of short shunt\n",
        "(264.10048, 'generator induced emf(V)')\n",
        "(0.48380799999999907, 'percent diff')\n"
       ]
      }
     ],
     "prompt_number": 17
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.29, Page No 231"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "# to find field current and field resistance at rated terminal voltage, em power and     torque\n",
      "\n",
      "  \n",
      "V_o=250         #no load voltage\n",
      "I_f=1.5 \n",
      "R_f=V_o/I_f     \n",
      "print(R_f,'field resistance(ohm)') \n",
      "P=25000 \n",
      "V_t=220 \n",
      "I_L=P/V_t \n",
      "I_a=I_L         \n",
      "\n",
      "#Calculations\n",
      "print(I_a,'field current(A)') \n",
      "R_a=.1 \n",
      "E_a=V_t+I_a*R_a \n",
      "I_f=1.1 \n",
      "R_f=V_t/I_f         \n",
      "print(R_f,'field resistance(ohm)') \n",
      "I_a=I_L-I_f \n",
      "emp=E_a*I_a \n",
      "print(emp,'em power(W)') \n",
      "n=1600 \n",
      "emt=emp/(n*2*math.pi/60) \n",
      "print(emt,'torque(Nm)') \n",
      "I_fa=1.25         #actual I_f\n",
      "I_c=I_fa-I_f \n",
      "\n",
      "#Results\n",
      "print(I_c,'I_f needed to counter effect armature current') "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(166.66666666666666, 'field resistance(ohm)')\n",
        "(113, 'field current(A)')\n",
        "(199.99999999999997, 'field resistance(ohm)')\n",
        "(25882.47, 'em power(W)')\n",
        "(154.47461399728832, 'torque(Nm)')\n",
        "(0.1499999999999999, 'I_f needed to counter effect armature current')\n"
       ]
      }
     ],
     "prompt_number": 18
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.32, Page No 231"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to determine the reduction of flux/pole due to armature rxn\n",
      "\n",
      "  \n",
      "V=250 \n",
      "R_a=.7 \n",
      "def arxn(I_a,n):\n",
      "    phi=(V-I_a*R_a)/n \n",
      "    return phi\n",
      "\n",
      "#Calculations\n",
      "phinl=arxn(1.6,1250) \n",
      "print(phinl,'flux/pole no load') \n",
      "\n",
      "phil=arxn(40,1150) \n",
      "print(phil,'flux/pole load') \n",
      "\n",
      "d=(phinl-phil)*100/phinl \n",
      "\n",
      "#Results\n",
      "print(d,'reduction in phi due to armature rxn(%)') \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(0.199104, 'flux/pole no load')\n",
        "(0.19304347826086957, 'flux/pole load')\n",
        "(3.0438975305018667, 'reduction in phi due to armature rxn(%)')\n"
       ]
      }
     ],
     "prompt_number": 19
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.33, Page No 231"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to determine internal em torque developed\n",
      "\n",
      "V=250.0 \n",
      "I_a=85.0\n",
      "R_a=.18 \n",
      "E_a=V-I_a*R_a \n",
      "n=1100 \n",
      "T=E_a*I_a/(n*2*math.pi/60) \n",
      "\n",
      "#Calculations\n",
      "print(T,'torque(Nm)') \n",
      "T_1=.8*T     \n",
      "print(T_1,'new torque(Nm)') \n",
      "#T=K_a'*K_f*I_f*I_a=K_a'*K_f*.8*I_f*I_a1    so\n",
      "I_a1=I_a/.8 \n",
      "E_a1=V-I_a1*R_a \n",
      "#E_a=K_a'*K_f*I_f*n\n",
      "#E_a1=K_a'*K_f*.8*I_f*n1    so\n",
      "n1=(E_a1/E_a)*n/.8\n",
      "\n",
      "#Results\n",
      "print(n1,'speed is(rpm)') \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(173.18517475700543, 'torque(Nm)')\n",
        "(138.54813980560434, 'new torque(Nm)')\n",
        "(1352.5910737111205, 'speed is(rpm)')\n"
       ]
      }
     ],
     "prompt_number": 20
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.34, Page No 231"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to determine speed, calculate internal torque developed on load and no load\n",
      "\n",
      "V=220.0\n",
      "R_f=110.0 \n",
      "I_f=V/R_f \n",
      "I_L=5 \n",
      "I_a0=I_L-I_f \n",
      "R_a=.25 \n",
      "E_a0=V-I_a0*R_a \n",
      "n=1200 \n",
      "\n",
      "#Calculations\n",
      "T_0=(E_a0*I_a0)/(2*math.pi*n/60) \n",
      "print(T_0,'torque at no load(Nm)') \n",
      "\n",
      "I_L=62 \n",
      "I_a1=I_L-I_f \n",
      "E_a1=V-I_a1*R_a \n",
      "n1=(E_a1/E_a0)*n/.95     \n",
      "print(n1,'speed(rpm)') \n",
      "T_1=(E_a1*I_a1)/(2*math.pi*n1/60) \n",
      "\n",
      "#Results\n",
      "print(T_1-T_0,'torque at on load(Nm)') "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(5.234208190934708, 'torque at no load(Nm)')\n",
        "(1181.0598331632962, 'speed(rpm)')\n",
        "(94.21574743682471, 'torque at on load(Nm)')\n"
       ]
      }
     ],
     "prompt_number": 21
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.36, Page No 231"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to sketch speed the speed-torque characteristicsof the series motor connectedto mains by calculating speed and torque values at diff values of armature current\n",
      "\n",
      "  \n",
      "Ise=[75,100,200,300,400] \n",
      "V=250 \n",
      "Ra=.08 \n",
      "\n",
      "#Calculations\n",
      "def Eaa(Ise):\n",
      "\tEa=V-Ra*Ise\n",
      "\treturn Ea\n",
      "\n",
      "def speed(Ea,Eav):\n",
      "\tnn=n*Ea/Eav\n",
      "\treturn nn\n",
      "Eav=[121.5,155,250,283,292] \n",
      "n=1200.0 \n",
      "\n",
      "def torque(nn,Ea,Ise):\n",
      "\tT=(60*Ea*Ise/(2*math.pi*nn)) \n",
      "\treturn T\n",
      "\t\n",
      "Ise=75 \n",
      "Ea=Eaa(Ise) \n",
      "Eav=121.5 \n",
      "nn1=speed(Ea,Eav) \n",
      "T1=torque(nn1,Ea,Ise) \n",
      "\n",
      "Ise=100 \n",
      "Ea=Eaa(Ise) \n",
      "Eav=155 \n",
      "nn2=speed(Ea,Eav) \n",
      "T2=torque(nn2,Ea,Ise) \n",
      "\n",
      "Ise=200 \n",
      "Ea=Eaa(Ise) \n",
      "Eav=250 \n",
      "nn3=speed(Ea,Eav) \n",
      "T3=torque(nn3,Ea,Ise) \n",
      "\n",
      "Ise=300 \n",
      "Ea=Eaa(Ise) \n",
      "Eav=283 \n",
      "nn4=speed(Ea,Eav) \n",
      "T4=torque(nn4,Ea,Ise) \n",
      "\n",
      "Ise=400 \n",
      "Ea=Eaa(Ise) \n",
      "Eav=292 \n",
      "nn5=speed(Ea,Eav) \n",
      "T5=torque(nn5,Ea,Ise) \n",
      "\n",
      "nn=[nn1,nn2,nn3,nn4,nn5] \n",
      "\n",
      "#Results\n",
      "print(nn,'speed(rpm)') \n",
      "T=[T1,T2,T3,T4,T5] \n",
      "print(T,'torque(Nm)') "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "([2409.8765432098767, 1873.5483870967741, 1123.2, 958.303886925795, 895.8904109589041], 'speed(rpm)')\n",
        "([72.51497094624482, 123.34508089621889, 397.88735772973837, 675.6127334250957, 929.4648676566688], 'torque(Nm)')\n"
       ]
      }
     ],
     "prompt_number": 22
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.37, Page No 231"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to determine the power delivered to the fan,torque developed by the motor and calculate external resistance to be added to armature ckt\n",
      "\n",
      "  \n",
      "V=220 \n",
      "Ra=.6 \n",
      "Rse=.4 \n",
      "Ia=30 \n",
      "Ea=V-(Ra+Rse)*Ia \n",
      "P=Ea*Ia     \n",
      "print(P,'Power(W)') \n",
      "n=400 \n",
      "w=2*math.pi*n/60 \n",
      "T=P/w     \n",
      "\n",
      "#Calculations\n",
      "print(T,'torque(Nm)') \n",
      "\n",
      "nn=200 \n",
      "T1=T*(nn/n)**2 \n",
      "Iaa=Ia*nn/n \n",
      "w1=2*math.pi*nn/60 \n",
      "P1=T1*w1 \n",
      "print(P1,'power developed when n=200 rpm((W))') \n",
      "Ea1=P1/Iaa \n",
      "Rext=(V-Ea1)/Iaa-(Ra+Rse) \n",
      "\n",
      "#Results\n",
      "print(Rext,'external resistance(ohm)') "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(5700.0, 'Power(W)')\n",
        "(136.0774763435705, 'torque(Nm)')\n",
        "(0.0, 'power developed when n=200 rpm((W))')\n",
        "(13.666666666666666, 'external resistance(ohm)')\n"
       ]
      }
     ],
     "prompt_number": 23
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.38, Page No 231"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "# to determine the starting torque developed\n",
      "  \n",
      "P=180000.0 \n",
      "V=600.0 \n",
      "Ia=P/V \n",
      "Ra=.105 \n",
      "Ea=V-Ia*Ra \n",
      "n=600.0 \n",
      "nn=500.0 \n",
      "\n",
      "#Calculations\n",
      "Eaa=Ea*nn/n \n",
      "Iaa=282     #from magnetising curve\n",
      "Iad=Ia-Iaa \n",
      "Ias=500     #at start\n",
      "k=Iad/Ia**2 \n",
      "Iae=Ias-Iad*k \n",
      "Eas=590     #from magnetising curve\n",
      "Ts=Eas*Ias/(2*math.pi*nn/60) \n",
      "\n",
      "#Results\n",
      "print(Ts,'T_start(Nm)') \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(5634.084985453095, 'T_start(Nm)')\n"
       ]
      }
     ],
     "prompt_number": 24
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.39, Page No 231"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#initialisation of variables\n",
      "#to determine speed and mech power\n",
      "\n",
      "  \n",
      "k=.2*10**-3 \n",
      "Ia=250 \n",
      "Iad=k*Ia**2 \n",
      "Ianet=Ia-Iad \n",
      "Ea=428     #from magnetising curve\n",
      "V=600 \n",
      "Ra=.105\n",
      "\n",
      "#Calculations\n",
      "Eaact=V-Ia*Ra \n",
      "n=500 \n",
      "nn=n*Eaact/Ea \n",
      "print(nn,'speed(rpm)') \n",
      "Pmech=Eaact*Ia \n",
      "print(Pmech,'mech power debeloped(W)') \n",
      "T=Pmech/(2*math.pi*nn/60) \n",
      "\n",
      "#Results\n",
      "print(T,'torque(Nm)') \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(670.268691588785, 'speed(rpm)')\n",
        "(143437.5, 'mech power debeloped(W)')\n",
        "(2043.5494692999362, 'torque(Nm)')\n"
       ]
      }
     ],
     "prompt_number": 25
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.40, Page No 231"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to calculate the mmf per pole on no load and speed developed\n",
      "\n",
      "  \n",
      "ATsefl=2400.0 \n",
      "ATsenl=(3.0/25)*ATsefl \n",
      "ATsh=ATsefl \n",
      "\n",
      "#Calculations\n",
      "ATnet=ATsenl+ATsh \n",
      "print(ATnet,'mmf/pole(AT)') \n",
      "Ea=148     #from magnetising curve\n",
      "V=240 \n",
      "vd=3 \n",
      "Eanl=V-vd \n",
      "n=850 \n",
      "nnl=n*Eanl/Ea \n",
      "\n",
      "#Results\n",
      "print(nnl,'speed(rpm)') "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(2688.0, 'mmf/pole(AT)')\n",
        "(1361, 'speed(rpm)')\n"
       ]
      }
     ],
     "prompt_number": 26
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.41, Page No 231"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to calculate demagnetisising ampeare turns, em torque,starting torque and no of turns of the series field\n",
      "\n",
      "  \n",
      "P=10000.0 \n",
      "Vt=240.0 \n",
      "Ia=P/Vt \n",
      "If=.6 \n",
      "Ra=.18 \n",
      "Ri=0.025 \n",
      "Ea=Vt-Ia*(Ra+Ri) \n",
      "n=1218 \n",
      "Eaa=Ea*Vt/Ea \n",
      "\n",
      "#Calculations\n",
      "Iff=.548     #from n-If characteristics\n",
      "Ifd=If-Iff \n",
      "N_s=2000     #shunt field turns\n",
      "ATd=N_s*Ifd     \n",
      "print(ATd,'demagnetising ampere turns') \n",
      "T=Ea*Ia/(2*math.pi*n/60) \n",
      "print(T,'torque(Nm)') \n",
      "Rf=320 \n",
      "If=Vt/Rf \n",
      "ATd=165     #given\n",
      "Ifd=ATd/N_s \n",
      "Ifnet=If-Ifd \n",
      "n=1150     #from n-If characteristics\n",
      "#Ea=Ka*phi*w     Ka*phi=k\n",
      "k=Vt/(2*math.pi*n/60) \n",
      "Iastart=75 \n",
      "Tstart=Iastart*k \n",
      "\n",
      "#Results\n",
      "print(Tstart,'starting torque(Nm)') \n",
      "n_0=1250 \n",
      "Ea=240 \n",
      "If=.56     #from n-If characteristics\n",
      "n=1200 \n",
      "Rse=.04 \n",
      "R=Rse+Ra+Ri \n",
      "Eaa=Ea-Ia*R \n",
      "nn=n*Ea/Eaa \n",
      "Ifnet=.684     #from n-If characteristics\n",
      "Ifd=Ifnet-If \n",
      "Nse=N_s*Ifd/Ia     \n",
      "print(math.ceil(Nse),'no of turns of the series field') \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(103.99999999999987, 'demagnetising ampere turns')\n",
        "(75.61112042243762, 'torque(Nm)')\n",
        "(149.467250903693, 'starting torque(Nm)')\n",
        "(6.0, 'no of turns of the series field')\n"
       ]
      }
     ],
     "prompt_number": 27
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.43, Page No 231"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to find the no of starter sections reqd,and resistance of each section\n",
      "\n",
      "I1=55.0 \n",
      "I2=35.0 \n",
      "g=I1/I2 \n",
      "V1=220.0 \n",
      "R1=V1/I1 \n",
      "Ra=.4 \n",
      "\n",
      "#Calculations\n",
      "n=math.log((R1/Ra)-g)+1 \n",
      "print((n),'no of starter sections reqd') \n",
      "\n",
      "def res(re):\n",
      "\tR=(1.0/g)*re \n",
      "\treturn R\n",
      "\n",
      "R_1=R1-res(R1)\n",
      "\n",
      "#Results\n",
      "print(R_1,'R1(ohm)') \n",
      "R_2=res(R_1) \n",
      "print(R_2,'R2(ohm)') \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(3.1316272948504063, 'no of starter sections reqd')\n",
        "(1.4545454545454546, 'R1(ohm)')\n",
        "(0.9256198347107438, 'R2(ohm)')\n"
       ]
      }
     ],
     "prompt_number": 28
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.44, Page No 231"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to find the lower current limit, motor speed at each stud\n",
      "\n",
      "  \n",
      "Pop=25.0*1000 \n",
      "Vt=230.0\n",
      "Ra=.12 \n",
      "rf=120.0 \n",
      "Nfl=2000.0 \n",
      "\n",
      "#Calculations\n",
      "Iafl=Pop/Vt \n",
      "Iamax=1.5*Iafl \n",
      "k=5 \n",
      "I1=Iamax \n",
      "R1=Vt/I1 \n",
      "r=(R1/Ra)**(1.0/(k-1)) \n",
      "I2=I1/r \n",
      "def res(re):\n",
      "\tR=(1.0/r)*re\n",
      "\treturn R\n",
      "R_1=R1-res(R1)\n",
      "\n",
      "#Results\n",
      "print(R_1,'R1(ohm)') \n",
      "R_2=res(R_1) \n",
      "print(R_2,'R2(ohm)') \n",
      "R_3=res(R_2) \n",
      "print(R_3,'R3(ohm)') \n",
      "R_4=res(R_3) \n",
      "print(R_4,'R4(ohm)') \n",
      "\n",
      "Iaf1=103.7 \n",
      "Ea=Vt-Iaf1*Ra \n",
      "Ka=Ea/Nfl \n",
      "def speed(r):\n",
      "    Ea=Vt-I2*r \n",
      "    n=Ea/Ka\n",
      "    return n\n",
      "r1=R1 \n",
      "n1=speed(r1) \n",
      "print(n1,'n1(rpm)') \n",
      "r2=r1-R_1 \n",
      "n2=speed(r2) \n",
      "print(n2,'n2(rpm)') \n",
      "r3=r2-R_2 \n",
      "n3=speed(r3) \n",
      "print(n3,'n3(rpm)') \n",
      "r4=r3-R_3 \n",
      "n4=speed(r4) \n",
      "print(n4,'n4(rpm)') \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(0.6488269413387042, 'R1(ohm)')\n",
        "(0.3504032174680013, 'R2(ohm)')\n",
        "(0.189237540843471, 'R3(ohm)')\n",
        "(0.10219896701649034, 'R4(ohm)')\n",
        "(972.5036432479316, 'n1(rpm)')\n",
        "(1497.7105726801958, 'n2(rpm)')\n",
        "(1781.351997202184, 'n3(rpm)')\n",
        "(1934.534396741029, 'n4(rpm)')\n"
       ]
      }
     ],
     "prompt_number": 29
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.45, Page No 231"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to calculate the ratio of full load speed to no load speed\n",
      "\n",
      "  \n",
      "V=400.0 \n",
      "Rf=200.0 \n",
      "If=V/Rf \n",
      "Inl=5.6 \n",
      "\n",
      "#Calculations\n",
      "I_a0=Inl-If \n",
      "vd=2     #voltage drop\n",
      "Ra=.18 \n",
      "E_a0=V-Ra*I_a0-vd \n",
      "Ifl=68.3 \n",
      "Iafl=Ifl-If \n",
      "E_afl=V-Ra*Iafl-vd \n",
      "e=.03     #armature rxn weakens the field by 3%\n",
      "k=(E_afl/E_a0)*(1/(1-e)) \n",
      "\n",
      "#Results\n",
      "print(k,'n_fl/n_nl') \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(1.0016463628395236, 'n_fl/n_nl')\n"
       ]
      }
     ],
     "prompt_number": 30
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.46, Page No 231"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to calculate load torque, motor speed and line current\n",
      "\n",
      "  \n",
      "V=250.0 \n",
      "Rf=41.67 \n",
      "If1=V/Rf \n",
      "Ia=126.0 \n",
      "Ia1=Ia-If1 \n",
      "Ra=.03 \n",
      "\n",
      "#Calculations\n",
      "Ea1=V-Ra*Ia1 \n",
      "n1=1105     #rpm\n",
      "w1=2*math.pi*n1/60 \n",
      "Ka=Ea1/(If1*w1) \n",
      "T=Ka*If1*Ia1 \n",
      "print(T,'torque(Nm)') \n",
      "\n",
      "If2=5 \n",
      "Ia2=Ia1*(If1/If2) \n",
      "I_L2=Ia2+2 \n",
      "print(I_L2,'motor current(A) initial') \n",
      "Ea2=V-Ra*Ia2 \n",
      "w2=Ea2/(Ka*If2) \n",
      "\n",
      "If1=6 \n",
      "Voc1=267 \n",
      "n=1200 \n",
      "k1=Voc1/(2*math.pi*n/60)     #k=Ka*phi\n",
      "If1=5 \n",
      "Voc2=250 \n",
      "n=1200 \n",
      "k2=Voc2/(2*math.pi*n/60)     #k=Ka*phi\n",
      "Ia2=Ia1*(k1/k2) \n",
      "I_L2=Ia2+2 \n",
      "print(I_L2,'motor current(A) final') \n",
      "Ea2=V-Ra*Ia2 \n",
      "w2=Ea2/k2 \n",
      "\n",
      "#Results\n",
      "print(w2,'motor speed(rad/s)') \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(255.52462829375477, 'torque(Nm)')\n",
        "(145.98905682937735, 'motor current(A) initial')\n",
        "(130.16051259899209, 'motor current(A) final')\n",
        "(123.73109114425752, 'motor speed(rad/s)')\n"
       ]
      }
     ],
     "prompt_number": 31
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.47, Page No 231"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to calculate armature current,speed and value of external resistance in field ckt\n",
      "\n",
      "  \n",
      "V=250.0\n",
      "Ia=5.0 \n",
      "Ra=.6 \n",
      "n=1000.0 \n",
      "\n",
      "#Calculations\n",
      "k=(V-Ia*Ra)/(2*math.pi*n/60) \n",
      "T=100.0 \n",
      "Ia=T/k \n",
      "print(Ia,'armature current(A)') \n",
      "w_m=(V-Ia*Ra)/k \n",
      "n=(60*w_m)/(2*math.pi) \n",
      "print(n,'speed(rpm)') \n",
      "\n",
      "Rf=150 \n",
      "If=V/Rf \n",
      "kk=k/If \n",
      "Iaa=44.8 \n",
      "nn=1200 \n",
      "Iff=(V-Iaa*Ra)/(kk*2*math.pi*nn/60) \n",
      "Rftot=V/Iff \n",
      "Rfext=Rftot-Rf \n",
      "\n",
      "#Results\n",
      "print(Rfext,'external resistance(ohm)') "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(42.396661991765086, 'armature current(A)')\n",
        "(909.1579060928783, 'speed(rpm)')\n",
        "(49.26496952312658, 'external resistance(ohm)')\n"
       ]
      }
     ],
     "prompt_number": 32
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.48, Page No 231"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to determine speed and torque of the motor\n",
      "\n",
      "  \n",
      "Ra=0.035 \n",
      "Rf=0.015 \n",
      "V=220 \n",
      "I=200 \n",
      "\n",
      "#Calculations\n",
      "Ea=V-I*(Ra+Rf) \n",
      "print('full field winding') \n",
      "n=900 \n",
      "nn=n*Ea/V \n",
      "print(nn,'speed(rpm)') \n",
      "T=(Ea*I/2)/(2*math.pi*nn/60) \n",
      "print(T,'torque(Nm)') \n",
      "print('field winding reduced to half') \n",
      "Rse=Rf/2 \n",
      "Rtot=Rse+Ra \n",
      "Ea=V-I*(Rtot) \n",
      "Iff=I/2 \n",
      "V=150     #from magnetisation characteristic\n",
      "nn=n*Ea/V \n",
      "print(nn,'speed(rpm)') \n",
      "T=(Ea*I)/(2*math.pi*nn/60) \n",
      "print(T,'torque(Nm)') \n",
      "\n",
      "print('divertor across series field') \n",
      "Ra=0.03 \n",
      "Rse=.015 \n",
      "Kd=1/((Rse/Ra)+1) \n",
      "Ise=Kd*I \n",
      "V1=192 \n",
      "I1=150 \n",
      "V2=150 \n",
      "I2=100 \n",
      "v=V2+((V1-V2)/(I1-I2))*(Ise-I2) \n",
      "R=(2/3)*Rse \n",
      "Ea=V-I*(Ra+R) \n",
      "nn=n*Ea/v \n",
      "\n",
      "#Results\n",
      "print(nn,'speed(rpm)') \n",
      "T=(Ea*I)/(2*math.pi*nn/60) \n",
      "print(T,'torque(Nm)') "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "full field winding\n",
        "(859.0909090909091, 'speed(rpm)')\n",
        "(233.42724986811317, 'torque(Nm)')\n",
        "field winding reduced to half\n",
        "(1269.0, 'speed(rpm)')\n",
        "(318.3098861837907, 'torque(Nm)')\n",
        "divertor across series field\n",
        "(864.0, 'speed(rpm)')\n",
        "(318.3098861837907, 'torque(Nm)')\n"
       ]
      }
     ],
     "prompt_number": 33
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.50, Page No 231"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to determine speed regulation, load speed and power regulation and compare power wasted in both cases\n",
      "\n",
      "  \n",
      "V=230.0 \n",
      "Ra=2.0 \n",
      "Ia=5.0 \n",
      "Ea=V-Ia*Ra \n",
      "n=1250.0 \n",
      "w=2*math.pi*n/60 \n",
      "k=Ea/w     #k=Ka*phi\n",
      "Re=15 \n",
      "Ia0=1 \n",
      "\n",
      "#Calculations\n",
      "Ea=V-Ia0*(Ra+Re) \n",
      "w0=Ea/k \n",
      "Ia=5 \n",
      "Ea=V-Ia*(Ra+Re) \n",
      "w=Ea/k \n",
      "wr=(w0-w)*100/w \n",
      "print(wr,'(i)speed regulation(%)') \n",
      "\n",
      "R1=10 \n",
      "R2=15 \n",
      "B=R2/(R1+R2) \n",
      "V_TH=V*B \n",
      "R_TH=R1*B \n",
      "Ea=V_TH-Ia0*(R_TH+Ra) \n",
      "w0=Ea/k \n",
      "Ia=5 \n",
      "Ea=V_TH-Ia*(R_TH+Ra) \n",
      "w=Ea/k  \n",
      "wr=(w0-w)*100/w \n",
      "print(wr,'(ii)speed regulation(%)') \n",
      "\n",
      "Pe=Ia**2*Re \n",
      "\n",
      "#Results\n",
      "print(Pe,'power loss by rheostat control(W)') \n",
      "Ra=2 \n",
      "Ea=98 \n",
      "Va=Ea+Ra*Ia \n",
      "P2=Va**2/R2 \n",
      "I2=Va/R2 \n",
      "I1=I2+Ia \n",
      "P1=I1**2*R1 \n",
      "Pe=P1+P2 \n",
      "print(Pe,'power loss by shunted armature control(W)') \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(46.896551724137936, '(i)speed regulation(%)')\n",
        "(-80.0, '(ii)speed regulation(%)')\n",
        "(375, 'power loss by rheostat control(W)')\n",
        "(2217, 'power loss by shunted armature control(W)')\n"
       ]
      }
     ],
     "prompt_number": 34
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.52, Page No 231"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to determine armature current\n",
      "\n",
      "  \n",
      "n1=1600.0 \n",
      "Ia1=120.0 \n",
      "n2=400.0 \n",
      "\n",
      "#Calculations\n",
      "Ia2=(n1*Ia1)/n2     #P=K*Ia*n\n",
      "\n",
      "#Results\n",
      "print(Ia2,'Ia(A)') \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(480.0, 'Ia(A)')\n"
       ]
      }
     ],
     "prompt_number": 35
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.54, Page No 231"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#to find speed and ratio of mech o/p\n",
      "\n",
      "  \n",
      "V=400.0 \n",
      "Ra=.25 \n",
      "Ia1=25.0 \n",
      "Ea1=V-Ra*Ia1 \n",
      "n1=1200 \n",
      "Rr=2.75 \n",
      "Ia2=15 \n",
      "\n",
      "#Calculations\n",
      "Ea2=V-(Ra+Rr)*Ia2 \n",
      "phi=.7     #phi=(phi(15)/phi(25))\n",
      "n2=(Ea2/Ea1)*n1/phi \n",
      "print(n2,'speed(rpm)') \n",
      "\n",
      "Po2=Ea2*I2 \n",
      "Po1=Ea1*I1 \n",
      "\n",
      "#Results\n",
      "print(Po2/Po1,'ratio of mech o/p') \n",
      "Ia=120     #Ia is constant indep of speed\n",
      "print(Ia,'Ia(A)') \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(1545.578231292517, 'speed(rpm)')\n",
        "(0.5259259259259259, 'ratio of mech o/p')\n",
        "(120, 'Ia(A)')\n"
       ]
      }
     ],
     "prompt_number": 36
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.55, Page No 231"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to calculate the armature voltage reqd\n",
      "\n",
      "  \n",
      "V=500.0 \n",
      "Ra=.28 \n",
      "Ia1=128.0 \n",
      "\n",
      "#Calculations\n",
      "Ea1=V-Ia1*Ra \n",
      "#(Vt2-.28*Ia2)-->n1/math.sqrt(2)    (i)\n",
      "#Ea1-->n1    (ii)\n",
      "Vt2=(Ea1/math.sqrt(2))+(Ia1*Ra) \n",
      "\n",
      "#Results\n",
      "print(Vt2,'armature voltage(V)') "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(364.05068355554783, 'armature voltage(V)')\n"
       ]
      }
     ],
     "prompt_number": 37
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.57, Page No 231"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to calculate m/c eff as a generator and max eff when generating and motoring.\n",
      "\n",
      "  \n",
      "Pop=10*1000.0 \n",
      "Vt=250.0 \n",
      "Ra=.8 \n",
      "Rf=275.0 \n",
      "Ia=3.91 \n",
      "Psh=Vt**2/Rf \n",
      "Prot=Vt*Ia-Ia**2*Ra \n",
      "print(Prot,'rotational loss(W)') \n",
      "\n",
      "I1=Pop/Vt \n",
      "If=Vt/Rf \n",
      "Ia=I1+If \n",
      "Ploss=Prot+Psh+Ia**2*Ra \n",
      "Eff_gen=(1-Ploss/(Ploss+Pop))*100 \n",
      "print(Eff_gen,'generator eff(%)') \n",
      "\n",
      "\n",
      "#Calculations\n",
      "Ia=I1-If \n",
      "Ploss=Prot+Psh+Ia**2*Ra \n",
      "Eff_motor=(1-Ploss/(Pop))*100 \n",
      "print(Eff_motor,'motor eff(%)') \n",
      "\n",
      "Ia=math.sqrt((Prot+Psh)/Ra) \n",
      "Ploss_tot=2*(Prot+Psh) \n",
      "print(Ploss_tot,'total loss(W)') \n",
      "\n",
      "I1=Ia-If \n",
      "Pout=Vt*I1 \n",
      "Eff_gen_max=((1-Ploss_tot/(Ploss_tot+Pout)))*100 \n",
      "print(Eff_gen_max,'max generator eff(%)') \n",
      "\n",
      "I1=Ia+If \n",
      "Pin=Vt*I1 \n",
      "Eff_motor_max=((1-Ploss_tot/(Pin)))*100 \n",
      "\n",
      "#Results\n",
      "print(Eff_motor_max,'max motor eff(%)') \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(965.2695199999999, 'rotational loss(W)')\n",
        "(79.799637649488, 'generator eff(%)')\n",
        "(75.84978413884296, 'motor eff(%)')\n",
        "(2385.0844945454546, 'total loss(W)')\n",
        "(79.80476689843074, 'max generator eff(%)')\n",
        "(75.85848385798421, 'max motor eff(%)')\n"
       ]
      }
     ],
     "prompt_number": 38
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.59, Page No 231"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to determine rotational loss, no load armature current and speed and also find speed regulation and to calculate armature current for given em torque\n",
      "\n",
      "  \n",
      "Pout=60.0*1000 \n",
      "eff=.85 \n",
      "P_L=((1.0/eff)-1)*Pout \n",
      "Pin=Pout+P_L \n",
      "V=600.0\n",
      "I_L=Pin/V \n",
      "Rf=100 \n",
      "If=V/Rf \n",
      "Ia=I_L-If \n",
      "Ra=.16 \n",
      "Ea=V-Ia*Ra \n",
      "n=900 \n",
      "\n",
      "#Calculations\n",
      "Prot=P_L-Ia**2*Ra-V*If \n",
      "print(Prot,'rotational loss(W)') \n",
      "\n",
      "Iao=Prot/V \n",
      "print(Iao,'no load armature current(A)') \n",
      "Eao=V \n",
      "n0=n*Eao/Ea \n",
      "print(n0,'no load speed(rpm)') \n",
      "reg=(n0-n)*100.0/n \n",
      "print(reg,'speed regulation(%)') \n",
      "\n",
      "K=Ea/(2*math.pi*n/60)     #K=Ka*phi\n",
      "T=600 \n",
      "Ia=T/K \n",
      "\n",
      "#Results\n",
      "print(Ia,'reqd armature current(A)') "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(4993.824775086507, 'rotational loss(W)')\n",
        "(8.323041291810844, 'no load armature current(A)')\n",
        "(927.617538640626, 'no load speed(rpm)')\n",
        "(3.0686154045139977, 'speed regulation(%)')\n",
        "(97.13988149114788, 'reqd armature current(A)')\n"
       ]
      }
     ],
     "prompt_number": 39
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.60, Page No 231"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to determine load torque and motor eff,armature current for max motor eff and ots value\n",
      "\n",
      "  \n",
      "V=250.0 \n",
      "Ia=35.0 \n",
      "Ra=.5 \n",
      "Ea=V-Ia*Ra \n",
      "Poutg=Ea*Ia \n",
      "Prot=500 \n",
      "Pout_net=Poutg-Prot \n",
      "n=1250 \n",
      "w=2*math.pi*n/60 \n",
      "T_L=Pout_net/w \n",
      "print(T_L,'load torque(Nm)') \n",
      "\n",
      "Rf=250.0 \n",
      "If=V/Rf \n",
      "I_L=If+Ia \n",
      "Pin=I_L*V \n",
      "eff=Pout_net*100/Pin \n",
      "print(eff,'efficiency(%)') \n",
      "\n",
      "\n",
      "#Calculations\n",
      "Pk=Prot+V*If \n",
      "Ia=math.sqrt(Pk/Ra) \n",
      "print(Ia,'armature current(A)') \n",
      "Tloss=2*Pk \n",
      "I_L=If+Ia \n",
      "Pin=I_L*V \n",
      "eff_max=1-(Tloss/Pin) \n",
      "print(eff_max*100,'max efficiency(%)') \n",
      "\n",
      "Ea1=V-Ia*Ra \n",
      "n1=n*Ea1/Ea \n",
      "print(n1,'speed(rpm)') \n",
      "w=2*math.pi*n1/60 \n",
      "Poutg=Ea1*Ia \n",
      "Pout_net=Poutg-Prot \n",
      "T_L=Pout_net/w \n",
      "\n",
      "#Results\n",
      "print(T_L,'load torque(Nm)') \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(58.34620213748883, 'load torque(Nm)')\n",
        "(84.86111111111111, 'efficiency(%)')\n",
        "(38.72983346207417, 'armature current(A)')\n",
        "(84.89799861424649, 'max efficiency(%)')\n",
        "(1239.973565962166, 'speed(rpm)')\n",
        "(64.94013105420487, 'load torque(Nm)')\n"
       ]
      }
     ],
     "prompt_number": 40
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.61, Page No 231"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to calculate rotational loss ,armature resistance,eff,line current and speed\n",
      "  \n",
      "Pshaft=20000.0 \n",
      "eff=.89 \n",
      "P_L=((1.0/eff)-1)*Pshaft \n",
      "Pin=Pshaft+P_L \n",
      "V=250 \n",
      "I_L=Pin/V \n",
      "print(I_L,'line current(A)') \n",
      "Rf=125 \n",
      "If=V/Rf \n",
      "Ia=I_L-If \n",
      "\n",
      "#Calculations\n",
      "Ploss=P_L/2 \n",
      "Ra=Ploss/Ia**2 \n",
      "print(Ra,'armature resistance(ohm)') \n",
      "Psh=V*If \n",
      "Prot=Ploss-Psh \n",
      "print(Prot,'rotational loss(W)') \n",
      "Ea=V-I_L*Ra \n",
      "n=850 \n",
      "Ia=100 \n",
      "\n",
      "Pc=Ia**2*Ra \n",
      "P_L=Pc+Ploss \n",
      "Pin=V*I_L \n",
      "eff=(1-P_L/Pin)*100 \n",
      "Ea1=V-Ia*Ra \n",
      "n1=n*Ea1/Ea \n",
      "\n",
      "#Results\n",
      "print(n1,'speed(rpm)') "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(89.88764044943821, 'line current(A)')\n",
        "(0.16000997913103768, 'armature resistance(ohm)')\n",
        "(735.955056179776, 'rotational loss(W)')\n",
        "(844.1627038605443, 'speed(rpm)')\n"
       ]
      }
     ],
     "prompt_number": 41
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.62, Page No 231"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to calculate eff of motor and generator\n",
      " \n",
      "Iag=60.0 \n",
      "Ia=15.0 \n",
      "Iam=Iag+Ia \n",
      "Vt=250.0 \n",
      "Ram=.2 \n",
      "Rag=.2 \n",
      "\n",
      "#Calculations\n",
      "Pstray=.5*(Vt*Ia-Iam**2*Ram-Iag**2*Rag) \n",
      "Ifm=2 \n",
      "Pinm=Vt*(Iam+Ifm) \n",
      "P_Lm=(Pstray+Vt*Ifm)+Iam**2*Ram \n",
      "eff_M=1-(P_Lm/Pinm) \n",
      "print(eff_M*100,'efficiency of motor(%)') \n",
      "\n",
      "Iag=60 \n",
      "Ifg=2.5 \n",
      "P_Lg=(Pstray+Vt*Ifg)+Iag**2*Rag \n",
      "Poutg=Vt*Iag \n",
      "eff_G=1-(P_Lg/(Poutg+P_Lg)) \n",
      "\n",
      "#Results\n",
      "print(eff_G*100,'efficiency of generator(%)') \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(86.6103896103896, 'efficiency of motor(%)')\n",
        "(86.71773377655731, 'efficiency of generator(%)')\n"
       ]
      }
     ],
     "prompt_number": 42
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 7.63, Page No 231"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to calculaate torque constt,value of rotational loss,stalled torque and stalled current of motor, armature current anad eff, motor o/p and eff\n",
      "\n",
      "  \n",
      "Vt=6.0\n",
      "Iao=.0145 \n",
      "n=12125 \n",
      "w=2*math.pi*n/60 \n",
      "Ra=4.2 \n",
      "Ea=Vt-Iao*Ra \n",
      "Km=Ea/w \n",
      "\n",
      "#Calculations\n",
      "print(Km,'torque constt') \n",
      "\n",
      "Prot=Ea*Iao \n",
      "print(Prot,'rotational loss(W)') \n",
      "\n",
      "Ia_stall=Vt/Ra \n",
      "print(Ia_stall,'stalled current(A)') \n",
      "Tstall=Km*Ia_stall \n",
      "print(Tstall,'stalled torque(Nm)') \n",
      "\n",
      "Poutg=1.6 \n",
      "def quad(a,b,c):\n",
      "    d=math.sqrt(b**2-4*a*c) \n",
      "    x1=(-b+d)/(2*a) \n",
      "    x2=(-b-d)/(2*a)\n",
      "    if x1>x2 :\n",
      "        x=x2\n",
      "    else :\n",
      "        x=x1 \n",
      "    return x\n",
      " \n",
      "#Ea*Ia=1.6 \n",
      "#(Vt-Ra*Ia)*Ia=Poutg \n",
      "Ia=quad(Ra,-Vt,Poutg) \n",
      "Ea=Vt-Ia*Ra \n",
      "wo=Ea/Km \n",
      "Proto=Prot*(w/wo)**2 \n",
      "Pout_net=Poutg-Prot \n",
      "Pi=Vt*Ia \n",
      "eff=Pout_net/Pi \n",
      "print(eff*100,'efficiency(%)') \n",
      "\n",
      "n1=10250 \n",
      "w1=2*math.pi*n1/60 \n",
      "Km=.004513 \n",
      "Ea1=Km*w1 \n",
      "Ia=(Vt-Ea1)/Ra \n",
      "Pout_gross=Ea1*Ia \n",
      "Prot1=Prot*(n1/n) \n",
      "Pout_net=Pout_gross-Prot1 \n",
      "print(Pout_net,'o/p power(W)') \n",
      "Pin=Vt*Ia \n",
      "eff=Pout_net/Pin \n",
      "\n",
      "#Results\n",
      "print(eff*100,'efficiency(%)') \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(0.004677462049569034, 'torque constt')\n",
        "(0.08611695, 'rotational loss(W)')\n",
        "(1.4285714285714286, 'stalled current(A)')\n",
        "(0.006682088642241477, 'stalled torque(Nm)')\n",
        "(71.12044194138065, 'efficiency(%)')\n",
        "(1.3331193196856814, 'o/p power(W)')\n",
        "(80.73587687106667, 'efficiency(%)')\n"
       ]
      }
     ],
     "prompt_number": 43
    }
   ],
   "metadata": {}
  }
 ]
}