{
 "metadata": {
  "name": "",
  "signature": "sha256:b6827bab8bcac6e2fc731c1e29fb824cdddabc14d1fbfce91735b0bd239d066e"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Chapter 4 : Three Phase Induction Machines"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.1  Page No : 288"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "# Given Data;\n",
      "f = 50.;   #frequency\n",
      "p = 6.; # number of poles\n",
      "V = 400.; #voltage supply\n",
      "S = 4.;   #percentage slip\n",
      "\n",
      "# Calculations and Results\n",
      "Ns = (120*f)/p;  #synchronous speed\n",
      "print \"Syhchronous speed, Ns = %d \"%(Ns);\n",
      "Nr = (1-(S/100))*Ns;\n",
      "print \"speed of rotor with slip 4 percent, Nr is %d rpm \"%(Nr);"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Syhchronous speed, Ns = 1000 \n",
        "speed of rotor with slip 4 percent, Nr is 960 rpm \n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.2  Page No : 288"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "# Given Data;\n",
      "f = 50.;   #frequency\n",
      "V = 400.; #voltage supply\n",
      "\n",
      "# Calculations and Results\n",
      "p = 2.;\n",
      "print \"when P = 2, Syhchronous speed, Ns = %d \"%((120*f)/p);\n",
      "p = 4;\n",
      "print \"when P = 2, Syhchronous speed,Ns = %d \"%(120*f/p);\n",
      "p = 6;\n",
      "print \"when P = 2, Syhchronous speed, Ns = %d \"%(120*f/p);\n",
      "p = 8;\n",
      "print \"when P = 2 Syhchronous speed, Ns = %d \"%(120*f/p);\n",
      "print (\"for Nr to be 1440 , Ns will be 1500, thus p = 4\")\n",
      "Ns = 1500;Nr1 = 1440;\n",
      "S1 = ((Ns-Nr1)/Ns)*100;\n",
      "print \"slip = %d\"%(S1);\n",
      "print (\"for Nr to be 940 , Ns will be 1000, thus p = 6\")\n",
      "Ns = 1000;Nr2 = 940;\n",
      "S2 = ((Ns-Nr2)/Ns)*100;\n",
      "print \"slip = %d\"%(S2);\n",
      "if S1>S2:\n",
      "    print (\"motor running at 1440 rpm is running at higher slip\")\n",
      "elif S2>S1:\n",
      "    print (\"motor running at 940 rpm is running at higher slip\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "when P = 2, Syhchronous speed, Ns = 3000 \n",
        "when P = 2, Syhchronous speed,Ns = 1500 \n",
        "when P = 2, Syhchronous speed, Ns = 1000 \n",
        "when P = 2 Syhchronous speed, Ns = 750 \n",
        "for Nr to be 1440 , Ns will be 1500, thus p = 4\n",
        "slip = 0\n",
        "for Nr to be 940 , Ns will be 1000, thus p = 6\n",
        "slip = 0\n"
       ]
      }
     ],
     "prompt_number": 2
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.3  Page No : 289"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "# Given Data;\n",
      "P = 10.;   #poles of alternator\n",
      "N = 600.;   #speed of alternator\n",
      "\n",
      "# Calculations and Results\n",
      "f = (P*N)/120   #frequency\n",
      "print \"frequency = %d\"%(f);\n",
      "print (\"when P = 2\");p = 2\n",
      "Ns = (120*f)/p;  #synchronous speed\n",
      "print \"Syhchronous speed, Ns = %d \"%(Ns);\n",
      "print (\"when P = 4\");p = 4;\n",
      "Ns = (120*f)/p;  #synchronous speed\n",
      "print \"Syhchronous speed, Ns = %d \"%(Ns);\n",
      "#speed of rotor(1440) is less than synchronous speed 1500, therefore P = 4\n",
      "print (\"speed of rotor(1440) is less than synchronous speed 1500, therefore P = 4\")\n",
      "Ns = 1500.;\n",
      "Nr = 1440.;\n",
      "S = ((Ns-Nr)/Ns)*100\n",
      "print \"slip is %d percent and number of poles is 4\"%(S)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "frequency = 50\n",
        "when P = 2\n",
        "Syhchronous speed, Ns = 3000 \n",
        "when P = 4\n",
        "Syhchronous speed, Ns = 1500 \n",
        "speed of rotor(1440) is less than synchronous speed 1500, therefore P = 4\n",
        "slip is 4 percent and number of poles is 4\n"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.4  Page No : 293"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "# Given Data\n",
      "Nr = 1440.;                #rotor speed in rpm\n",
      "f = 50.;                    #frequency in hertz\n",
      "\n",
      "# Calculations\n",
      "#calculating Ns for values of P = 2,4,6,8 etc\n",
      "#by checking P = 4\n",
      "P = 4;\n",
      "Ns = (120*f)/P;                 #Synchronous speed\n",
      "S = (Ns-Nr)/Ns;                #slip\n",
      "Fr = S*f;                       #rotor frequency\n",
      "\n",
      "# Results\n",
      "print \"Rotor frequency = %dHz\"%(Fr)\n",
      "\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Rotor frequency = 2Hz\n"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.5  Page No : 294"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "# Given Data\n",
      "f = 50.;                   #induction motor frequency in hertz\n",
      "fr = 1.5;                 #rotor frequency in hertz\n",
      "\n",
      "# Calculations and Results\n",
      "S = fr/f;                #slip\n",
      "P = 8;                   #pole\n",
      "Ns = (120*f)/P;\n",
      "print \"synchronous speed = %frpm\"%(Ns)\n",
      "Nr = Ns-(S*Ns);\n",
      "print \"motor running speed = %frpm\"%(Nr)\n",
      "S1 = S*100;\n",
      "print \"slip percent = %fpercent\"%(S1)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "synchronous speed = 750.000000rpm\n",
        "motor running speed = 727.500000rpm\n",
        "slip percent = 3.000000percent\n"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.7  Page No : 297"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "# Given Data\n",
      "E20 = 100.;            #induced emf in volts\n",
      "R2 = 0.05;            #rotor resistance in ohms\n",
      "X20 = 0.1;            #rotor reactance in ohms\n",
      "\n",
      "# Calculations and Results\n",
      "E20p = E20/math.sqrt(3);\n",
      "print (\"When S = 0.04\")\n",
      "S = 0.04;\n",
      "I2 = (S*E20p)/math.sqrt(R2**2+(S*X20)**2)\n",
      "print \"I2 = %dA\"%(I2);\n",
      "phi2 = math.degrees(math.acos(R2/(math.sqrt(R2**2+(S*X20)**2))));\n",
      "print \"Phase angle between rotor voltage and rotor current = %f degrees\"%(phi2);\n",
      "print (\"When S = 1\")\n",
      "S = 1;\n",
      "I2 = (S*E20p)/math.sqrt(R2**2+(S*X20)**2)\n",
      "print \"I2 = %dA\"%(I2);\n",
      "phi2 = math.degrees(math.acos(R2/(math.sqrt(R2**2+(S*X20)**2))));\n",
      "print \"Phase angle between rotor voltage and rotor current = %f degrees\"%(phi2);\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "When S = 0.04\n",
        "I2 = 46A\n",
        "Phase angle between rotor voltage and rotor current = 4.573921 degrees\n",
        "When S = 1\n",
        "I2 = 516A\n",
        "Phase angle between rotor voltage and rotor current = 63.434949 degrees\n"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.8  Page No : 298"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "# Given Data\n",
      "f = 50.;                 #frequency of induction motor\n",
      "P = 4.;                 #pole\n",
      "Ns = (120*f)/P;\n",
      "S = 3.;                  #slip percent\n",
      "\n",
      "# Calculations\n",
      "Nr = Ns-((Ns*S)/100)\n",
      "fr = (S*f)/100;\n",
      "\n",
      "# Results\n",
      "print \"synchronous speed = %frpm\"%(Ns)\n",
      "print \"speed of running motor = %frpm\"%(Nr)\n",
      "print \"rotor frequency = %fHz\"%(fr)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "synchronous speed = 1500.000000rpm\n",
        "speed of running motor = 1455.000000rpm\n",
        "rotor frequency = 1.500000Hz\n"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.9  Page No : 299"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "# Given Data\n",
      "fr = 2.;                             #frequency of motor induced emf in hertz\n",
      "f = 50.;                             #frequency of induction motor in hertz\n",
      "S = (fr/f)*100;                #slip percent\n",
      "P = 6.;                              #pole\n",
      "# Calculations\n",
      "Ns = (120*f)/P;\n",
      "Nr = Ns-((Ns*S)/100);\n",
      "\n",
      "# Results\n",
      "print \"percentage slip = %fpercent\"%(S)\n",
      "print \"rotor speed = %frpm\"%(Nr)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "percentage slip = 4.000000percent\n",
        "rotor speed = 960.000000rpm\n"
       ]
      }
     ],
     "prompt_number": 9
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.10  Page No : 299"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "# Given Data\n",
      "P = 12.;                       #pole\n",
      "f = 50.;                       #frequency of induction motor in hertz\n",
      "Nr = 485.;                        #induction motor speed in rpm\n",
      "\n",
      "# Calculations\n",
      "Ns = (120*f)/P;\n",
      "S = (Ns-Nr)/Nr;\n",
      "fr = S*f;\n",
      "\n",
      "# Results\n",
      "print \"frequency of rotor current = %fHz\"%(fr)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "frequency of rotor current = 1.546392Hz\n"
       ]
      }
     ],
     "prompt_number": 10
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.11  Page No : 299"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Given Data\n",
      "E20 = 100.;                                #induced emf of induction motor at stanstill in volts\n",
      "E20p = E20/math.sqrt(3);                        #induced emf per phase in volts\n",
      "S = 0.40;                                #slip\n",
      "\n",
      "# Calculations and Results\n",
      "E2 = S*E20p;                                 #rotor induced emf at slip S in volts\n",
      "print \"Rotor induced emf at a slip E2 = %fV\"%(E2);\n",
      "R2 = 0.4;                                 #resistance per phase in ohms\n",
      "X20 = 2.25;                            #stanstill resistance per phase i ohms\n",
      "Z2 = math.sqrt((R2)**2+(S*X20)**2);                    #rotor impedence at slip S in ohms\n",
      "print \"Rotor impedence at a slip S, Z2 = %fohms\"%(Z2)\n",
      "I = E2/Z2;\n",
      "print \"rotor current = %fA\"%(I)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Rotor induced emf at a slip E2 = 23.094011V\n",
        "Rotor impedence at a slip S, Z2 = 0.984886ohms\n",
        "rotor current = 23.448415A\n"
       ]
      }
     ],
     "prompt_number": 11
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.12  Page No : 308"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "# Given Data\n",
      "S = 0.03;                #slip\n",
      "SI = 50.;                #stator input in kilowatts\n",
      "SL = 2.;                #stator loss in kilowatts\n",
      "\n",
      "# Calculations and Results\n",
      "RI = SI-SL;            #rotor input in kilowatts\n",
      "RIL = S*RI;              #rotor I**2R loss\n",
      "#rotor core loss can be neglected at 3percent slip\n",
      "PDR = RI-RIL;            #power developed by the rotor\n",
      "print \"Power developed by the rotor = %fkW\"%(PDR);\n",
      "FWL = 1;                #friction and windage loss in kilowatt\n",
      "OP = PDR-FWL;            #output power\n",
      "print \"Output power = %fkW\"%(OP);\n",
      "effi = (OP*100)/SI;\n",
      "print \"Efficiency of the motor = %f percent\"%(effi)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Power developed by the rotor = 46.560000kW\n",
        "Output power = 45.560000kW\n",
        "Efficiency of the motor = 91.120000 percent\n"
       ]
      }
     ],
     "prompt_number": 12
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.13  Page No : 309"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Given Data\n",
      "f = 50.;                     #frequency of induction motor in hertz\n",
      "hp = 20.;                    #horse power\n",
      "ph = 3.;                     #Three phase supply\n",
      "P = 4.;                    #number of poles\n",
      "\n",
      "# Calculations and Results\n",
      "losses = 500;                #friction and vintage losses\n",
      "print \"Output of the motor = %fW\"%(hp*735.5)\n",
      "Pd = (hp*735.5)+losses;            #power developed in watt\n",
      "print \"Power developed by the rotor = %dW\"%(Pd);\n",
      "s = 0.04;                    #slip\n",
      "rotorloss = (s*Pd)/(1-s);\n",
      "print \"Rotor I**2R-loss = %fW\"%(rotorloss);\n",
      "Ns = (120*f)/P;\n",
      "print \"Ns = %drpm\"%(Ns);\n",
      "Nr = Ns*(1-s);\n",
      "print \"Nr = %drpm\"%(Nr);\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Output of the motor = 14710.000000W\n",
        "Power developed by the rotor = 15210W\n",
        "Rotor I**2R-loss = 633.750000W\n",
        "Ns = 1500rpm\n",
        "Nr = 1440rpm\n"
       ]
      }
     ],
     "prompt_number": 13
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.14  Page No : 310"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Given Data\n",
      "f = 50.;                     #frequency of induction motor in hertz\n",
      "P = 6.;                        #number of poles\n",
      "ph = 3.;                    #Three phase supply\n",
      "\n",
      "# Calculations and Results\n",
      "R2 = 0.1;                    #rotor resistance in ohms\n",
      "Ns = (120*f)/P;\n",
      "print \"Syncronous speed, Ns = %drpm\"%(Ns);\n",
      "Nr = 940;                    #rotor speed in rpm\n",
      "S = (Ns-Nr)/Ns;\n",
      "print \"Slip, S = %f\"%(S);\n",
      "print \"stanstill rotor reactance, X20 = %fohms\"%(R2/S);\n",
      "\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Syncronous speed, Ns = 1000rpm\n",
        "Slip, S = 0.060000\n",
        "stanstill rotor reactance, X20 = 1.666667ohms\n"
       ]
      }
     ],
     "prompt_number": 16
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.15  Page No : 310"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "# Given Data\n",
      "f = 50.;                     #frequency of induction motor in hertz\n",
      "P = 4.;                        #number of poles\n",
      "Nr = 1440.;                    #rotor speed in rpm\n",
      "R2 = 0.1;                    #rotor resistance in ohms\n",
      "X20 = 0.6;                    #rotor stanstill resistance in ohms\n",
      "\n",
      "# Calculations and Results\n",
      "Ns = (120*f)/P;\n",
      "print \"Synchronous speed = %drpm\"%(Ns);\n",
      "S1 = (Ns-Nr)*(100/Ns);\n",
      "print \"Full-load slip with rotor resistance, R2 i.e. S1 = %f\"%(S1);\n",
      "print (\"on adding extra resistance o.1ohm\")\n",
      "#on solving we get S2 = 0.08\n",
      "S2 = 0.08;\n",
      "Nr2 = Ns*(1-S2);\n",
      "print \"New rotor speed = %drpm\"%(Nr2);\n",
      "\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Synchronous speed = 1500rpm\n",
        "Full-load slip with rotor resistance, R2 i.e. S1 = 4.000000\n",
        "on adding extra resistance o.1ohm\n",
        "New rotor speed = 1380rpm\n"
       ]
      }
     ],
     "prompt_number": 18
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.16  Page No : 311"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "# Given Data\n",
      "f = 50.;                    #frequency in hertz\n",
      "P = 4.;                    #number of poles\n",
      "R2 = 0.04;                    #rotor resistance in ohms\n",
      "\n",
      "# Calculations and Results\n",
      "Ns = (120*f)/P;\n",
      "print \"Syncronous speed = %drpm\"%(Ns);\n",
      "Nr = 1200;                #rotor speed at maximium torque in rpm\n",
      "S = (Ns-Nr)/Ns;\n",
      "print \"Slip at maximium torque = %f\"%(S);\n",
      "X20 = R2/S;\n",
      "#starting torque is developed when S = 1\n",
      "#r = (Tst/Tm)\n",
      "r = (R2/(R2**2+X20**2))*(2*X20);\n",
      "print \"Therefore, starting torque is %fpercent of the maximium torque\"%(r*100)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Syncronous speed = 1500rpm\n",
        "Slip at maximium torque = 0.200000\n",
        "Therefore, starting torque is 38.461538percent of the maximium torque\n"
       ]
      }
     ],
     "prompt_number": 19
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.18  Page No : 313"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "# Given Data\n",
      "P = 4.;                     #number of poles\n",
      "f = 50.;                    #frequency in hertz\n",
      "ph = 3.;                     #three phase supply\n",
      "R2 = 0.25;                   #rotor resistance in ohms\n",
      "Nr = 1440.;                     #rotor speed in rpm\n",
      "\n",
      "# Calculations and Results\n",
      "Ns = (120*f)/P;\n",
      "S1 = (Ns-Nr)/Ns;\n",
      "print \"S1 = %f\"%(S1);\n",
      "Nr2 = 1200;    #rotor speed when external is added\n",
      "S2 = (Ns-Nr2)/Ns;\n",
      "#torque remains consmath.tant,we get the relation R2' = R2*(S2/S1)\n",
      "R2dash = R2*(S2/S1)\n",
      "print \"Extra resistance to be connected in the  motor circuit = %fohms\"%(R2dash-R2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "S1 = 0.040000\n",
        "Extra resistance to be connected in the  motor circuit = 1.000000ohms\n"
       ]
      }
     ],
     "prompt_number": 20
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.20  Page No : 311"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "# Given Data\n",
      "hp = 20.;                        \n",
      "P = 4.;                        #number of poles\n",
      "f = 50.;\n",
      "S = 0.03;                      #slip\n",
      "\n",
      "# Calculations and Results\n",
      "MSO = hp*735.5;                #motor shaft output\n",
      "losses = 0.02*MSO               #friction and windage loss in watts\n",
      "Pd = MSO+losses;                    #power developed by the rotor in watts\n",
      "RCL = (S*Pd)/(1-S);           #rotor I**2*R loss\n",
      "print \"rotor copper loss = %fW\"%(RCL);\n",
      "Ri = Pd+RCL                              #rotor iron loss is neglected\n",
      "print \"Rotor input = %fW\"%(Ri);\n",
      "Ns = (120*f)/P;\n",
      "Nr = Ns*(1-S)*(1./60);                  #rotor speed in rps\n",
      "OT = MSO/(2*3.14*Nr);                    #outp[ut torque in Nm\n",
      "print \"output torque = %fNm\"%(OT)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "rotor copper loss = 464.047423W\n",
        "Rotor input = 15468.247423W\n",
        "output torque = 96.592028Nm\n"
       ]
      }
     ],
     "prompt_number": 21
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.21  Page No : 316"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "# Given Data\n",
      "f = 50.;                   #frequency of induction motor in hertz\n",
      "P = 6.;                    #pole\n",
      "Ns = (120.*f)/P;\n",
      "Nr = 975.;                         #induction motor running speed in rpm\n",
      "\n",
      "# Calculations and Results\n",
      "S = (Ns-Nr)/Ns;\n",
      "print \"the slip = %f\"%(S)\n",
      "Pin = 40.;                    #power input to stator in kW\n",
      "Sl = 1.;                     #stator losses in kW\n",
      "Rin = Pin-Sl;                 #output from stator in kW\n",
      "Rc = S*Rin;\n",
      "print \"rotor copper losses = %fkW\"%(Rc)\n",
      "l = 2.;                     #total losses in kW\n",
      "p = Rin-Rc-l;                  #output power in kw\n",
      "HP = (p*1000)/735.5;\n",
      "print \"output horse output = %fHP\"%(HP)\n",
      "in1 = 40.;                           #input in kW\n",
      "effi = (p/in1)*100;\n",
      "print \"efficiency = %fpercent\"%(effi)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "the slip = 0.025000\n",
        "rotor copper losses = 0.975000kW\n",
        "output horse output = 48.980286HP\n",
        "efficiency = 90.062500percent\n"
       ]
      }
     ],
     "prompt_number": 23
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.22  Page No : 316"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "# Given Data\n",
      "f = 50.;                           #frequency of induction motor in hertz\n",
      "P = 6.;                            #pole\n",
      "\n",
      "# Calculations and Results\n",
      "Ns = (120.*f)/P;\n",
      "print \"synchronous speed = %frpm\"%(Ns)\n",
      "fr = 120./60;                           #rotor frequency\n",
      "S = fr/f;\n",
      "print \"the slip = %f\"%(S)\n",
      "Nr = Ns-(Ns*S);\n",
      "print \"rotor speed = %frpm\"%(Nr)\n",
      "Rin = 80.;                       #rotor input in kW\n",
      "Rc = S*Rin;                     #Rotor copper loss in kW\n",
      "Ph = 3.;                               #number of phases\n",
      "Rcp = (Rc/Ph)*1000;                         #loss per phase in watt\n",
      "p = ((Rin-Rc)*1000)/735.5;\n",
      "print \"mechanical power developed = %fhp\"%(p)\n",
      "Ir = 60;                         #rotor current in amperes\n",
      "R2 = Rcp/(Ir)**2;\n",
      "print \"rotor resistance per phase at rotor current 60A = %fohms\"%(R2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "synchronous speed = 1000.000000rpm\n",
        "the slip = 0.040000\n",
        "rotor speed = 960.000000rpm\n",
        "mechanical power developed = 104.418763hp\n",
        "rotor resistance per phase at rotor current 60A = 0.296296ohms\n"
       ]
      }
     ],
     "prompt_number": 24
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.23  Page No : 320"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "# Given Data\n",
      "# we know (Ts/Tm) = ((2*a)/(1+a**2))\n",
      "#where  a = (R2/X20)\n",
      "#at starting contion math.since Tm = Ts\n",
      "print (\"At starting contion math.since Tm = Ts\")\n",
      "\n",
      "# Calculations and Results\n",
      "a = 1     #we obtain from the relations\n",
      "R2 = 0.05;                    #circuit resistance in ohms\n",
      "X2 = 0.4;                    #stanstill reactance in ohms\n",
      "r = (a*X2)-R2;                #r is the extra that is added to the rotor circuit\n",
      "print \"extra resistance added ,r = %fohms\"%(r)\n",
      "\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "At starting contion math.since Tm = Ts\n",
        "extra resistance added ,r = 0.350000ohms\n"
       ]
      }
     ],
     "prompt_number": 25
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.24  Page No : 321"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "# Given Data\n",
      "V = 400.;                #supply voltage in volts\n",
      "f = 50.;                    #frequency in hertz\n",
      "P = 6.;                  #number of poles\n",
      "ph = 3.;                  #three phase supply\n",
      "R2 = 0.03;                #rotor resistance in ohms\n",
      "X20 = 0.4;                 #rptor reactance in ohms\n",
      "Nr = 960.;                #full load speed in rpm\n",
      "\n",
      "# Calculations and Results\n",
      "Ns = (120*f)/P;\n",
      "print \"synchronous speed = %drpm\"%(Ns)\n",
      "S = (Ns-Nr)/Ns;            #corresponding slip\n",
      "#maximium torque Tm occurs at S = (R2/X20)\n",
      "#we get Tm = k/(2*X20)\n",
      "a = R2/X20;\n",
      "#r = Tm/T\n",
      "r = (a**2+S**2)/(2*a*S);\n",
      "Sm = (R2/X20);\n",
      "print \"Slip at maximium torque, Sm = %f\"%(Sm);\n",
      "#corresponding speed\n",
      "Nr2 = Ns*(1-Sm);\n",
      "print \"Rotor speed at maximium torque = %drpm\"%(Nr2)\n",
      "\n",
      "\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "synchronous speed = 1000rpm\n",
        "Slip at maximium torque, Sm = 0.075000\n",
        "Rotor speed at maximium torque = 925rpm\n"
       ]
      }
     ],
     "prompt_number": 26
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.25  Page No : 321"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math \n",
      "\n",
      "# Given Data\n",
      "V = 400.;                #supply voltage in volts\n",
      "f = 50.;                    #frequency in hertz\n",
      "P = 4.;                  #number of poles\n",
      "ph = 3.;                  #three phase supply\n",
      "S = 0.04;\n",
      "If = 30.;                 #Full load current in amperes\n",
      "\n",
      "# Calculations and Results\n",
      "Isc = 6*If;\n",
      "#let r be the ratio of starting torque nd full load torque, r = Ts/Tf\n",
      "r = (Isc/If)**2*S;\n",
      "#Tf = Tm is produced when voltage is Vm\n",
      "Vm = math.sqrt(V**2/r);\n",
      "print \"voltage at maximium torque = %fvolts\"%(Vm);\n",
      "Is = 6*If*(Vm/V);\n",
      "print \"Full-load current at 333.3 volts is = %fA\"%(Is)\n",
      "\n",
      "\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "voltage at maximium torque = 333.333333volts\n",
        "Full-load current at 333.3 volts is = 150.000000A\n"
       ]
      }
     ],
     "prompt_number": 27
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.26  Page No : 330"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "# Given Data\n",
      "V = 400.;                #supply voltage in volts\n",
      "f = 50.;                    #frequency in hertz\n",
      "Id = 75.;                    #current taken when delta-connected in amperes\n",
      "\n",
      "# Calculations and Results\n",
      "print \"current taken when delta-connected = %dA\"%(Id);\n",
      "Is = Id/3;                    #current taken when star-connected in amperes\n",
      "print \"current taken when star-connected = %dA\"%(Is);\n",
      "#Tfl be the full load torque\n",
      "#r = Ts/Tfl\n",
      "r = 1.5;\n",
      "#math.since voltage becomes (1/math.sqrt(3)) when star connected \n",
      "#torque is directly proportional to square of voltage\n",
      "print \"Starting torque with winding star connected = %f times of Tfl\"%(r/3);\n",
      "\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "current taken when delta-connected = 75A\n",
        "current taken when star-connected = 25A\n",
        "Starting torque with winding star connected = 0.500000 times of Tfl\n"
       ]
      }
     ],
     "prompt_number": 29
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.28  Page No : 333"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math \n",
      "\n",
      "# Given Data\n",
      "ph = 3;\n",
      "#rotor copper loss = slip*rotor input\n",
      "#Tst =  starting torque\n",
      "#Tfl = torque at full load\n",
      "#Ist/Ifl = r\n",
      "r = 6;\n",
      "\n",
      "# Calculations and Results\n",
      "S = 0.04\n",
      "print \" At slip = 0.04\"\n",
      "print \"For direct-on-line starting ( Tst/Tfl) = %f\"%(r**2*S);\n",
      "#phase current in start is (1/math.sqrt(3)) times the phase current in delta\n",
      "\n",
      "print \"For direct-on-line starting( Tst/Tfl) = %f\"%((r/math.sqrt(3))**2*S);"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " At slip = 0.04\n",
        "For direct-on-line starting ( Tst/Tfl) = 1.440000\n",
        "For direct-on-line starting( Tst/Tfl) = 0.480000\n"
       ]
      }
     ],
     "prompt_number": 31
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.29  Page No : 334"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "# Given Data\n",
      "V = 400.;                    #voltage in volts\n",
      "f = 50.;                    #frequency in hertz\n",
      "P = 4.;                    #number of poles\n",
      "#r1 = (Ts/Tfl)\n",
      "r1 = 1.6;\n",
      "#r2 = (Tm/Tfl)\n",
      "r2 = 2.;\n",
      "#r3 = (Ts/Tm) = (2*a)/(1+a**2)\n",
      "r3 = 0.8;\n",
      "#on solving , we get a = 0.04  ,\n",
      "a = 0.04;\n",
      "\n",
      "# Calculations and Results\n",
      "Sm = 0.04;   #slip at maximium torque\n",
      "print \"Slip at maximium torque, Sm = %f\"%(Sm)\n",
      "Ns = (120*f)/P;            #synchronous speed in rpm\n",
      "Nr = Ns*(1-Sm)             #rotor speed in rpm\n",
      "#r2 = (a**2+Sfl**2)/(2*a*Sfl)\n",
      "Sfl = 0.01;\n",
      "Nr2 = Ns*(1-Sfl);\n",
      "print \"full load speed, Nr = %drpm\"%(Nr2)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Slip at maximium torque, Sm = 0.040000\n",
        "full load speed, Nr = 1485rpm\n"
       ]
      }
     ],
     "prompt_number": 32
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.30  Page No : 345"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Given Data\n",
      "hp = 20.;                    #power in horsepower\n",
      "f = 50.;                    #frequency in hertz\n",
      "P = 4.;                    #number of poles\n",
      "\n",
      "# Calculations and Results\n",
      "Ns = (120*f)/P;                #synchronous speed\n",
      "print \"Synchronous speed, Ns = %drpm\"%(Ns);\n",
      "S = 0.04;                            #slip\n",
      "Nr = Ns*(1-S);\n",
      "OP = hp*735.5;\n",
      "print \"Output power = %fW\"%(OP);\n",
      "OT = OP/(2*3.14*(Nr/60));\n",
      "print \"Output torque = %fNm\"%(OT);\n",
      "FL = 0.02*OP;          #Friction and windage loss\n",
      "PD = OP+FL;\n",
      "print \"Power developed by the rotor = %fW\"%(PD);\n",
      "#from relation, (rotor I**2R-loss = S*Rotor input) we get following relation \n",
      "RL = (S*PD)/(1-S);        \n",
      "print \"Rotor I**2R-loss = %fW\"%(RL);\n",
      "RI = RL/S;\n",
      "print \"Rotor input = %dW\"%(RI)\n",
      "\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Synchronous speed, Ns = 1500rpm\n",
        "Output power = 14710.000000W\n",
        "Output torque = 97.598195Nm\n",
        "Power developed by the rotor = 15004.200000W\n",
        "Rotor I**2R-loss = 625.175000W\n",
        "Rotor input = 15629W\n"
       ]
      }
     ],
     "prompt_number": 33
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.31  Page No : 347"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "# Given Data\n",
      "P = 4.;                #number of poles\n",
      "f = 50.;                #frequency in hertz\n",
      "V = 230.;               #voltage in volts\n",
      "hp = 5.;                #power in horsepower\n",
      "Ib = 15.;                #current in block rotor test in amperes\n",
      "\n",
      "# Calculations and Results\n",
      "output = hp*735.5;        #output in watts\n",
      "#in block rotor test: power input = Full = load I**2R losses = 735W\n",
      "FLl = 735;                                #Full-load I**2R losses\n",
      "print \"Full-load I**2R losses = %fW\"%(FLl);\n",
      "Re = FLl/(3*Ib**2);\n",
      "Io = 6.3;                #current in no load condition in amperes\n",
      "lossNL = (3*(Io)**2*Re);    #I**2R loss at no-load condition\n",
      "print \"I**2R loss at no-load = %fW\"%(lossNL);\n",
      "PiNL = 275;                  #power input at no-load\n",
      "print \"Core loss plus friction and windage loss = %dW\"%(PiNL-lossNL);\n",
      "TL = FLl+(PiNL-lossNL);\n",
      "effi = (output*100)/(output+TL);\n",
      "print \"Efficiency = %fpercent\"%(effi)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Full-load I**2R losses = 735.000000W\n",
        "I**2R loss at no-load = 129.654000W\n",
        "Core loss plus friction and windage loss = 145W\n",
        "Efficiency = 80.685043percent\n"
       ]
      }
     ],
     "prompt_number": 34
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.32  Page No : 347"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Given Data\n",
      "Vl = 415.;            #voltage in volts\n",
      "Il = 50.;                #line current in amperes\n",
      "R1 = 0.5;                #resistrance of stator winding per phase in ohms\n",
      "pf = 0.85;              #power factor\n",
      "S = 0.04;\n",
      "\n",
      "# Calculations and Results\n",
      "IFL = (math.sqrt(3)*Vl*Il*pf)         #input to the motor on full load\n",
      "print \"Input to the motor on full load = %dW\"%(IFL);\n",
      "I1 = Il/math.sqrt(3);\n",
      "SLFL = (3*I1**2*R1)            #Stator I**2R loss on full load\n",
      "print \"Stator I**2R loss on full load = %dW\"%(SLFL);\n",
      "#given ratio of stator core loss friction and windahe loss be r = (r1:r2)\n",
      "r1 = 3.;\n",
      "r2 = 2.;\n",
      "TL = 1500.;            #total loss\n",
      "SCL = (r1*TL)/(r1+r2);             #stator core loss\n",
      "FWL = (r2*TL)/(r1+r2);             #Friction and windage loss\n",
      "SL = SLFL+SCL;                      #total stator loss\n",
      "SI = IFL;                            #Stator input\n",
      "Pa = SI-SL;                            #power transferred through the air-gap = input to the rotor\n",
      "RI = Pa\n",
      "RL = S*RI;                           #rotor losses\n",
      "TRL = FWL+RL;                         #total rotor losses \n",
      "OP = RI-TRL;                            #Output power at the shaft\n",
      "effi = (OP*100)/SI;\n",
      "print \"Efficiency = %f percent\"%(effi)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Input to the motor on full load = 30549W\n",
        "Stator I**2R loss on full load = 1250W\n",
        "Efficiency = 87.279597 percent\n"
       ]
      }
     ],
     "prompt_number": 35
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.33  Page No : 351"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "# Given Data\n",
      "E20 = 100.;                               #induced emf between slip terminals in volts\n",
      "\n",
      "# Calculations and Results\n",
      "E20p = E20/math.sqrt(3);                       #induced emf per phase in volts\n",
      "print \"induced emf per phase = %fV\"%(E20p)\n",
      "S = 3/100;                           #slip\n",
      "R2 = 0.2;                                 #resistance in ohms\n",
      "X20 = 1;                                #stanstill resistance in ohms\n",
      "I2 = (S*E20p)/math.sqrt((R2)**2+(S*X20)**2)\n",
      "print \"rotor current at slip 0.03  = %fA per phase\"%(I2)\n",
      "Sm = R2/X20;\n",
      "I2m = (Sm*E20p)/math.sqrt((R2)**2+(Sm*X20)**2)\n",
      "print \"rotor current when the rotor develops maximum torque = %fA per phase\"%(I2m)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "induced emf per phase = 57.735027V\n",
        "rotor current at slip 0.03  = 0.000000A per phase\n",
        "rotor current when the rotor develops maximum torque = 40.824829A per phase\n"
       ]
      }
     ],
     "prompt_number": 36
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.34  Page No : 352"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\n",
      "# Given Data\n",
      "E20 = 120.;                      #induced emf of motor at stanstill in volts\n",
      "E20p = 120./math.sqrt(3);                     #induced emf per phase\n",
      "f = 50.;                               #frequency of the motor in hertz\n",
      "R2 = 0.2;                                 #Rotor resistance  per phase\n",
      "X20 = 1.;                                     #stanstill resistance in ohms\n",
      "P = 4.;                                #pole\n",
      "I = 16.;                        #\n",
      "\n",
      "# Calculations and Results\n",
      "S = (I*R2)/math.sqrt((E20)**2-(I*X20)**2);\n",
      "Ns = (120*f)/P;\n",
      "print \"Synchronous speed = %frpm\"%(Ns)\n",
      "Nr = Ns-(Ns*S)\n",
      "Sm = R2/X20;\n",
      "Nr = Ns-(Ns*Sm)\n",
      "I2 = (Sm*E20p)/math.sqrt((R2)**2+(Sm*X20)**2)\n",
      "print \"rotor current at maximum torque = %fAper Phase\"%(I2)\n",
      "Pi = (3*((I2)**2)*R2)/Sm;\n",
      "print \"Rotor input for the three phase = %fW\"%(Pi)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Synchronous speed = 1500.000000rpm\n",
        "rotor current at maximum torque = 48.989795Aper Phase\n",
        "Rotor input for the three phase = 7200.000000W\n"
       ]
      }
     ],
     "prompt_number": 37
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 4.35  Page No : 356"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math \n",
      "\n",
      "# Given Data\n",
      "R1dc = 0.01;                    #DC resistance in ohms\n",
      "V = 400.;                        #voltage in volts\n",
      "r = 1.5;                    #ratio of ac to dc resistance\n",
      "R1 = r*R1dc;                  #AC resistance in ohms\n",
      "#at no-load\n",
      "Io = 20.;                    #no-load current in amperes\n",
      "SL = (3*Io**2*R1);        #I**2R loss in the stator phases in watts\n",
      "FWL = 300.;                 #Friction and windage loss in watts\n",
      "TL = 1200.;                    #total losses = no-load power input in watts\n",
      "\n",
      "# Calculations\n",
      "CL = TL-(SL+FWL);            #core loss in watt\n",
      "CLp = CL/math.sqrt(3);              #core loss per phase\n",
      "Vp = V/math.sqrt(3);                #voltage per phase\n",
      "Rm = (Vp**3)/CL;                  #motor resistance\n",
      "pf = CL/(Vp*Io);\n",
      "phi0 = math.degrees(math.acos(pf));\n",
      "Xm = Vp/(Io*math.sin(math.radians(phi0)));                #motor reactance\n",
      "#Under blocked rotor test\n",
      "Vb = 100;                    #voltage in volts\n",
      "Isc = 45;                      #current in amperes\n",
      "Vbp = 100/math.sqrt(3);           #voltage per phase in volts\n",
      "P = 2750;                    #power supplied in watts\n",
      "Ze = Vbp/Isc;                       #Motor impedance reffered to stator side in ohms\n",
      "Re = P/(3*Isc**2);\n",
      "R2 = Re-R1;                #rotor resistance referred to stator side\n",
      "Xe = math.sqrt(Ze**2-Re**2);\n",
      "#assuming X1 = X2\n",
      "X2 = Xe/2\n",
      "X1 = X2;\n",
      "\n",
      "# Results\n",
      "print \"Thus the elements of the equivalent circuit are:\";\n",
      "print \"Rm = %fohms\"%(Rm);\n",
      "print \"Xm = %fohms\"%(Xm);\n",
      "print \"R1 = %fohms\"%(R1);\n",
      "print \"rotor resistance referred to stator side, R2 = %fohms\"%(R2);\n",
      "print \"equivalent resistance referred to stator side, Re = %fohms\"%(Re);\n",
      "\n",
      "print \"X1 = %fohms\"%(X1);\n",
      "print \"rotor reactance referred to stator side, X2 = %fohms\"%(X2);\n",
      "print \"equivalent reactance referred to stator side, Xe = %fohms\"%(Xe);\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Thus the elements of the equivalent circuit are:\n",
        "Rm = 13964.632361ohms\n",
        "Xm = 11.763476ohms\n",
        "R1 = 0.015000ohms\n",
        "rotor resistance referred to stator side, R2 = -0.015000ohms\n",
        "equivalent resistance referred to stator side, Re = 0.000000ohms\n",
        "X1 = 0.641500ohms\n",
        "rotor reactance referred to stator side, X2 = 0.641500ohms\n",
        "equivalent reactance referred to stator side, Xe = 1.283001ohms\n"
       ]
      }
     ],
     "prompt_number": 38
    }
   ],
   "metadata": {}
  }
 ]
}