path: root/Electric_Machinery_and_Transformers/CHAP_6.ipynb

{
 "metadata": {
  "name": ""
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "CHAPTER 6: AC DYNAMO VOLTAGE RELATIONS-ALTERNATORS"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 6.1, Page number 160"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Variable declaration\n",
      "kVA = 1000.0   #Rating of the 3-phase alternator(kVA) \n",
      "V_L = 4600.0   #Rated line voltage(V)\n",
      "R_a = 2.0      #Armature resistance per phase(ohm)\n",
      "X_s = 20.0     #Synchronous armature reactance per phase(ohm)\n",
      "pf_a = 1.0     #Unity power factor\n",
      "pf_b = 0.75    #Lagging power factor\n",
      "\n",
      "#Calculation\n",
      "V_P = V_L/3**0.5            #Phase voltage(V)\n",
      "I_P = kVA*1000/(3*V_P)      #Phase current(A)\n",
      "I_a  = I_P                  #Armature current(A)\n",
      "#Case(a)\n",
      "E_g_a = complex((V_P+I_a*R_a),(I_a*X_s))                        #Full-load generated voltage per phase(V/phase)\n",
      "#Case(b)\n",
      "sin_theta_b = (1-pf_b**2)**0.5                                  #Sin of angle of theta_b\n",
      "E_g_b = complex((V_P*pf_b+ I_a*R_a),(V_P*sin_theta_b+I_a*X_s))  #Full-load generated voltage per phase(V/phase)\n",
      "\n",
      "#Result\n",
      "print('Case(a): Full-load generated voltage per phase at unity PF , E_g = %d V/phase' %(abs(E_g_a)))\n",
      "print('Case(b): Full-load generated voltage per phase at 0.75 PF lagging , E_g = %d V/phase' %(abs(E_g_b)))\n",
      "print('\\nNOTE: \u221a3 value is taken as %f instead of 1.73 as in textbook so slight variations in the obtained answer' %(3**0.5))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Case(a): Full-load generated voltage per phase at unity PF , E_g = 3840 V/phase\n",
        "Case(b): Full-load generated voltage per phase at 0.75 PF lagging , E_g = 4820 V/phase\n",
        "\n",
        "NOTE: \u221a3 value is taken as 1.732051 instead of 1.73 as in textbook so slight variations in the obtained answer\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 6.2, Page number 161"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Variable declaration\n",
      "kVA = 1000.0   #Rating of the 3-phase alternator(kVA) \n",
      "V_L = 4600.0   #Rated line voltage(V)\n",
      "R_a = 2.0      #Armature resistance per phase(ohm)\n",
      "X_s = 20.0     #Synchronous armature reactance per phase(ohm)\n",
      "pf_a = 0.75    #Leading power factor\n",
      "pf_b = 0.40    #Leading power factor\n",
      "\n",
      "#Calculation\n",
      "V_P = V_L/3**0.5            #Phase voltage(V)\n",
      "I_P = kVA*1000/(3*V_P)      #Phase current(A)\n",
      "I_a  = I_P                  #Armature current(A)\n",
      "#Case(a)\n",
      "sin_theta_a = (1-pf_a**2)**0.5                                  #Sin of angle of theta_a\n",
      "E_g_a = complex((V_P*pf_a+I_a*R_a),(V_P*sin_theta_a-I_a*X_s))   #Full-load generated voltage per phase(V/phase)\n",
      "#Case(b)\n",
      "sin_theta_b = (1-pf_b**2)**0.5                                  #Sin of angle of theta_b\n",
      "E_g_b = complex((V_P*pf_b+ I_a*R_a),(V_P*sin_theta_b+-I_a*X_s))  #Full-load generated voltage per phase(V/phase)\n",
      "\n",
      "#Result\n",
      "print('Case(a): Full-load generated voltage per phase at 0.75 PF leading , E_g = %d V/phase' %(abs(E_g_a)))\n",
      "print('Case(b): Full-load generated voltage per phase at 0.40 PF leading , E_g = %d V/phase' %(abs(E_g_b)))\n",
      "print('\\nNOTE: \u221a3 value is taken as %f instead of 1.73 as in textbook so slight variations in the obtained answer' %(3**0.5))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Case(a): Full-load generated voltage per phase at 0.75 PF leading , E_g = 2366 V/phase\n",
        "Case(b): Full-load generated voltage per phase at 0.40 PF leading , E_g = 1315 V/phase\n",
        "\n",
        "NOTE: \u221a3 value is taken as 1.732051 instead of 1.73 as in textbook so slight variations in the obtained answer\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 6.3, Page number 162"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "V_P = 2655.0     #Phase voltage(V) \n",
      "E_g_a1 = 4820.0  #Full-load generated voltage per phase at 0.75 PF lagging(V/phase)\n",
      "E_g_b1 = 3840.0  #Full-load generated voltage per phase at unity PF(V/phase)\n",
      "E_g_a2 = 2366.0  #Full-load generated voltage per phase at 0.75 PF leading(V/phase)\n",
      "E_g_b2 = 1315.0  #Full-load generated voltage per phase at 0.40 PF leading(V/phase)\n",
      "\n",
      "#Calculation\n",
      "VR_a = (E_g_a1-V_P)/V_P*100     #Voltage regulation at 0.75 PF lagging(percent)\n",
      "VR_b = (E_g_b1-V_P)/V_P*100     #Voltage regulation at unity PF(percent)\n",
      "VR_c = (E_g_a2-V_P)/V_P*100     #Voltage regulation at 0.75 PF leading(percent)\n",
      "VR_d = (E_g_b2-V_P)/V_P*100     #Voltage regulation at 0.75 PF leading(percent)\n",
      "\n",
      "#Result\n",
      "print('Case(a): Voltage regulation at 0.75 PF lagging , VR = %.1f percent' %VR_a)\n",
      "print('Case(b): Voltage regulation at unity PF , VR = %.1f percent' %VR_b)\n",
      "print('Case(c): Voltage regulation at 0.75 PF leading , VR = %.2f percent' %VR_c)\n",
      "print('Case(d): Voltage regulation at 0.40 PF leading , VR = %.1f percent' %VR_d)\n",
      "print('\\nNOTE: \u221a3 value is taken as %f instead of 1.73 as in textbook so slight variations in the obtained answer' %(3**0.5))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Case(a): Voltage regulation at 0.75 PF lagging , VR = 81.5 percent\n",
        "Case(b): Voltage regulation at unity PF , VR = 44.6 percent\n",
        "Case(c): Voltage regulation at 0.75 PF leading , VR = -10.89 percent\n",
        "Case(d): Voltage regulation at 0.40 PF leading , VR = -50.5 percent\n",
        "\n",
        "NOTE: \u221a3 value is taken as 1.732051 instead of 1.73 as in textbook so slight variations in the obtained answer\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 6.4, Page number 168"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Variable declaration\n",
      "kVA = 100.0    #Rating of the 3-phase alternator(kVA)\n",
      "V_L = 1100.0   #Line voltage of the 3-phase alternator(V)\n",
      "E_gp1 = 6.0    #DC voltage between lines in dc resistance test(V)\n",
      "I_a1 = 10.0    #DC current in lines dc resistance test(A)\n",
      "pf_1 = 0.8     #Lagging power factor\n",
      "pf_2 = 0.8     #Leading power factor\n",
      "E_gp2 = 420.0  #Voltage between lines in open-circuit test(V)\n",
      "I_f2 = 12.5    #DC Field current in open-circuit test(A)\n",
      "I_f3 = 12.5    #DC Field current in short-circuit test(A)\n",
      "\n",
      "#Calculation\n",
      "#Case(a)\n",
      "I_a_rated = kVA*1000/(V_L*3**0.5)      #Rated current per phase(A)\n",
      "I_a = 3**0.5*I_a_rated                 #Rated Line current(A)\n",
      "V_l = E_gp1\n",
      "R_dc = V_l/(2*I_a1)                    #Effective dc armature resistance(ohm/winding)\n",
      "R_ac = R_dc*1.5                        #Effective ac armature resistance(ohm/phase)\n",
      "R_a = R_ac                             #Effective ac armature resistance from dc resistance test(ohm/phase)\n",
      "Z_p = E_gp2/I_a                        #Synchronous impedance per phase(ohm/phase)\n",
      "X_s = (Z_p**2-R_a**2)**0.5             #Synchronous reactance per phase(ohm/phase)\n",
      "#Case(b)\n",
      "V_p = V_L/3**0.5                       #Phase voltage(V/phase)\n",
      "V_fl = V_p                             #Full-load voltage(V/phase)\n",
      "sin_theta_1 = (1-pf_1**2)**0.5         #Sin value of theta 1\n",
      "E_gp_lag = complex((V_p*pf_1+I_a_rated*R_a),(V_p*sin_theta_1+I_a_rated*X_s))  #Generated voltage per phase at 0.8 PF lagging(V/phase)\n",
      "V_nl_lag = abs(E_gp_lag)                    #No-load voltage(V/phase)\n",
      "VR1 = (V_nl_lag-V_fl)/V_fl*100              #Voltage regulation at 0.8 PF lagging(%)\n",
      "sin_theta_2 = (1-pf_2**2)**0.5              #Sin value of theta 2\n",
      "E_gp_lead = complex((V_p*pf_2+I_a_rated*R_a),(V_p*sin_theta_2-I_a_rated*X_s))  #Generated voltage per phase at 0.8 PF leading(V/phase)\n",
      "V_nl_lead = abs(E_gp_lead)                  #No-load voltage(V/phase)\n",
      "VR2 = (V_nl_lead-V_fl)/V_fl*100             #Voltage regulation at 0.8 PF leading(%)\n",
      "\n",
      "#Result\n",
      "print('Case(a): Effective resistance per phase , R_ac = %.2f \u03a9/phase' %R_ac)\n",
      "print('         Synchronous impedance per phase , Z_p = %.2f \u03a9/phase' %Z_p)\n",
      "print('         Synchronous reactance per phase , X_s = %.1f \u03a9/phase' %X_s)\n",
      "print('Case(b): Voltage regulation at 0.8 PF lagging = %.f percent' %VR1)\n",
      "print('         Voltage regulation at 0.8 PF leading = %.1f percent' %VR2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Case(a): Effective resistance per phase , R_ac = 0.45 \u03a9/phase\n",
        "         Synchronous impedance per phase , Z_p = 4.62 \u03a9/phase\n",
        "         Synchronous reactance per phase , X_s = 4.6 \u03a9/phase\n",
        "Case(b): Voltage regulation at 0.8 PF lagging = 29 percent\n",
        "         Voltage regulation at 0.8 PF leading = -13.4 percent\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 6.5, Page number 169"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Variable declaration\n",
      "kVA = 100.0    #Rating of the 3-phase alternator(kVA)\n",
      "V_L = 1100.0   #Line voltage of the 3-phase alternator(V)\n",
      "E_gp1 = 6.0    #DC voltage between lines in dc resistance test(V)\n",
      "I_a1 = 10.0    #DC current in lines dc resistance test(A)\n",
      "pf_1 = 0.8     #Lagging power factor\n",
      "pf_2 = 0.8     #Leading power factor\n",
      "E_gp2 = 420.0  #Voltage between lines in open-circuit test(V)\n",
      "I_f2 = 12.5    #DC Field current in open-circuit test(A)\n",
      "I_f3 = 12.5    #DC Field current in short-circuit test(A)\n",
      "\n",
      "#Calculation\n",
      "#Case(a)\n",
      "I_a_rated = kVA*1000/(V_L*3**0.5)      #Rated current per phase(A)\n",
      "I_L = I_a_rated                        #Rated Line current(A)\n",
      "I_p = I_L/3**0.5                       #Phase current(A)\n",
      "I_a = I_p                              #Rated Line current(A)\n",
      "Z_s = E_gp2/I_p                        #Synchronous impedance per phase(ohm/phase)\n",
      "V_l = E_gp1\n",
      "R_dc = V_l/(2*I_a1)                    #Effective dc armature resistance(ohm/winding)\n",
      "R_ac = R_dc*1.5                        #Effective ac armature resistance(ohm/phase)\n",
      "R_eff = 3*R_ac                         #Effective resistance(ohm/phase)\n",
      "R_a = R_eff\n",
      "X_s = (Z_s**2-R_eff**2)**0.5           #Synchronous reactance per phase(ohm/phase)\n",
      "#Case(b)\n",
      "V_p = V_L                              #Phase voltage(V/phase)\n",
      "V_fl = V_p                             #Full-load voltage(V/phase)\n",
      "sin_theta_1 = (1-pf_1**2)**0.5         #Sin value of theta 1\n",
      "E_gp_lag = complex((V_p*pf_1+I_a*R_a),(V_p*sin_theta_1+I_a*X_s))  #Generated voltage per phase at 0.8 PF lagging(V/phase)\n",
      "V_nl_lag = abs(E_gp_lag)                    #No-load voltage(V/phase)\n",
      "VR1 = (V_nl_lag-V_fl)/V_fl*100              #Voltage regulation at 0.8 PF lagging(%)\n",
      "sin_theta_2 = (1-pf_2**2)**0.5              #Sin value of theta 2\n",
      "E_gp_lead = complex((V_p*pf_2+I_a*R_a),(V_p*sin_theta_2-I_a*X_s))  #Generated voltage per phase at 0.8 PF leading(V/phase)\n",
      "V_nl_lead = abs(E_gp_lead)                  #No-load voltage(V/phase)\n",
      "VR2 = (V_nl_lead-V_fl)/V_fl*100             #Voltage regulation at 0.8 PF leading(%)\n",
      "\n",
      "print('Case(a): Effective resistance per phase , R_eff = %.2f \u03a9/phase' %R_eff)\n",
      "print('         Synchronous impedance per phase , Z_s = %.2f \u03a9/phase' %Z_s)\n",
      "print('         Synchronous reactance per phase , X_s = %.1f \u03a9/phase' %X_s)\n",
      "print('Case(b): Voltage regulation at 0.8 PF lagging = %.f percent' %VR1)\n",
      "print('         Voltage regulation at 0.8 PF leading = %.1f percent' %VR2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Case(a): Effective resistance per phase , R_eff = 1.35 \u03a9/phase\n",
        "         Synchronous impedance per phase , Z_s = 13.86 \u03a9/phase\n",
        "         Synchronous reactance per phase , X_s = 13.8 \u03a9/phase\n",
        "Case(b): Voltage regulation at 0.8 PF lagging = 29 percent\n",
        "         Voltage regulation at 0.8 PF leading = -13.4 percent\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 6.6, Page number 172"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Variable declaration\n",
      "E_L = 11000.0    #Line voltage generated(V)\n",
      "kVA = 165000.0   #Rating of the alternator(kVA)\n",
      "Z_p = 1.0        #Synchronous reactance(ohm)\n",
      "R_p = 0.1        #Armature resistance(ohm/phase)\n",
      "Z_r = 0.8        #Reactor reactance(ohm/phase)\n",
      "\n",
      "#Calculation\n",
      "E_p = E_L/3**0.5              #Rated phase voltage(V)\n",
      "I_p = kVA*1000/(3*E_p)        #Rated current per phase(A)\n",
      "#Case(a)\n",
      "I_max_a = E_p/R_p             #Maximum short-circuit current(A)\n",
      "overload_a = I_max_a/I_p      #Overload\n",
      "#Case(b)\n",
      "I_steady = E_p/Z_p            #Sustained short-circuit current(A)\n",
      "overload_b = I_steady/I_p     #Overload\n",
      "#Case(c)\n",
      "Z_t = complex(R_p,Z_r)        #Total reactance per phase(ohm)\n",
      "I_max_c = E_p/abs(Z_t)        #Maximum short-circuit current(A)\n",
      "overload_c = abs(I_max_c)/I_p #Overload\n",
      "\n",
      "#Result\n",
      "print('Case(a): Maximum short-circuit current at instant of short-circuit , I_max = %.f A' %I_max_a)\n",
      "print('         Overload = %.1f * rated current' %overload_a)\n",
      "print('Case(b): Sustained short-circuit current , I_steady = %.f A' %I_steady)\n",
      "print('         Overload = %.2f * rated current' %overload_b)\n",
      "print('Case(c): Maximum short-circuit current with reactors , I_max = %.f A' %I_max_c)\n",
      "print('         Overload = %.3f * rated current' %overload_c)\n",
      "print('\\nNOTE: \u221a3 value is taken as %f instead of 1.73 as in textbook so slight variations in the obtained answer' %(3**0.5))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Case(a): Maximum short-circuit current at instant of short-circuit , I_max = 63509 A\n",
        "         Overload = 7.3 * rated current\n",
        "Case(b): Sustained short-circuit current , I_steady = 6351 A\n",
        "         Overload = 0.73 * rated current\n",
        "Case(c): Maximum short-circuit current with reactors , I_max = 7877 A\n",
        "         Overload = 0.910 * rated current\n",
        "\n",
        "NOTE: \u221a3 value is taken as 1.732051 instead of 1.73 as in textbook so slight variations in the obtained answer\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 6.7, Page number 174"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "import cmath\n",
      "\n",
      "#Variable declaration\n",
      "kVA = 100.0    #Rating of the 3-phase alternator(kVA)\n",
      "V_L = 1100.0   #Line voltage of the 3-phase alternator(V)\n",
      "E_gp1 = 6.0    #DC voltage between lines in dc resistance test(V)\n",
      "I_a1 = 10.0    #DC current in lines dc resistance test(A)\n",
      "pf = 0.8       #Lagging power factor\n",
      "E_gp2 = 420.0  #Voltage between lines in open-circuit test(V)\n",
      "I_f2 = 12.5    #DC Field current in open-circuit test(A)\n",
      "I_f3 = 12.5    #DC Field current in short-circuit test(A)\n",
      "I_L = 52.5     #Rated line current(A)\n",
      "I_a = I_L      #Rated current per phase(A)\n",
      "E_gp = complex(532,623)  #Generated voltage at 0.8 PF lagging(V/phase)\n",
      "X_s = 4.6      #Synchronous reactance per phase(ohm/phase)\n",
      "V_p = 635.0    #Phase voltage(V)\n",
      "\n",
      "#Calculation\n",
      "#Case(a)\n",
      "P_T = 3**0.5*V_L*I_L*pf                                    #Total output 3-phase power(W)\n",
      "#Case(b)\n",
      "P_p_b = P_T*10**-3/3.0                                     #Total output 3-phase power per phase(W)\n",
      "#Case(d)\n",
      "theta = math.acos(0.8)*180/math.pi                         #Phase angle of PF(degree)\n",
      "theta_plus_deba = cmath.phase(E_gp)*180/math.pi            #Phase angle of E_gp(degrees)\n",
      "deba = theta_plus_deba-theta                               #Torque angle(degrees)\n",
      "#Case(e)\n",
      "P_p_e = abs(E_gp)*10**-3/X_s*V_p*math.sin(deba*math.pi/180)         #Approximate output power per phase(W)\n",
      "#Case(f)\n",
      "P_p_f = abs(E_gp)*10**-3*I_a*math.cos(theta_plus_deba*math.pi/180)  #Approximate output power per phase(W)\n",
      "\n",
      "#Result\n",
      "print('Case(a): Total output 3-phase power , P_T = %.f W' %P_T)\n",
      "print('Case(b): Output power per phase , P_p = %.2f kW' %P_p_b)\n",
      "print('Case(c): Generated voltage , E_gp = %.1f\u2220%.1f\u00b0 V' %(abs(E_gp),cmath.phase(E_gp)*180/math.pi))\n",
      "print('Case(d): Torque angle , \u03b4 = %.2f\u00b0 ' %deba)\n",
      "print('Case(e): Approximate output power per phase , P_p = %.f W' %P_p_e)\n",
      "print('Case(f): Approximate output power per phase , P_p = %.f W' %P_p_f)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Case(a): Total output 3-phase power , P_T = 80021 W\n",
        "Case(b): Output power per phase , P_p = 26.67 kW\n",
        "Case(c): Generated voltage , E_gp = 819.2\u222049.5\u00b0 V\n",
        "Case(d): Torque angle , \u03b4 = 12.64\u00b0 \n",
        "Case(e): Approximate output power per phase , P_p = 25 W\n",
        "Case(f): Approximate output power per phase , P_p = 28 W\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 6.8, Page number 174"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "\n",
      "#Variable declaration\n",
      "E_g = 819.0     #Magnitude of generated voltage(V)\n",
      "V_p = 635.0     #Phase voltage(V)\n",
      "X_s = 4.6       #Synchronous reactance per phase(ohm/phase)\n",
      "S = 1200.0      #Synchronous speed(rpm)\n",
      "delta = 12.64   #Angle(degree)\n",
      "\n",
      "#Calculation\n",
      "#Case(a)\n",
      "T_p_a = 7.04*E_g*V_p*math.sin(delta*math.pi/180)/(S*X_s)  #Output torque per phase(lb-ft)\n",
      "T_3ph_a = 3*T_p_a                                         #Total output torque(lb-ft)\n",
      "#Case(b)\n",
      "omega = S*2*math.pi/60                                    #Speed(rad/s)\n",
      "T_p_b = E_g*V_p*math.sin(delta*math.pi/180)/(omega*X_s)   #Output torque per phase(N-m)\n",
      "T_3ph_b = 3*T_p_b                                         #Total output torque(N-m)\n",
      "#Case(c)\n",
      "T_p_c = T_p_a*1.356                                       #Output torque per phase(N-m)\n",
      "T_3ph_c = 3.0*T_p_c                                       #Total output torque(N-m)\n",
      "\n",
      "#Result\n",
      "print('Case(a): Output torque per phase , T_p = %.f lb-ft' %T_p_a)\n",
      "print('         Total output torque , T_3\u03c6 = %.f lb-ft' %T_3ph_a)\n",
      "print('Case(b): Output torque per phase , T_p = %.f N-m' %T_p_b)\n",
      "print('         Total output torque , T_3\u03c6 = %.f N-m' %T_3ph_b)\n",
      "print('Case(c): Output torque per phase , T_p = %.f N-m' %T_p_c)\n",
      "print('         Total output torque , T_3\u03c6 = %.f N-m' %T_3ph_c)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Case(a): Output torque per phase , T_p = 145 lb-ft\n",
        "         Total output torque , T_3\u03c6 = 435 lb-ft\n",
        "Case(b): Output torque per phase , T_p = 197 N-m\n",
        "         Total output torque , T_3\u03c6 = 591 N-m\n",
        "Case(c): Output torque per phase , T_p = 197 N-m\n",
        "         Total output torque , T_3\u03c6 = 590 N-m\n"
       ]
      }
     ],
     "prompt_number": 1
    }
   ],
   "metadata": {}
  }
 ]
}