path: root/Electrical_Machines_by_R._K._Srivastava/ch5.ipynb

{
 "metadata": {
  "name": "",
  "signature": "sha256:089ff648fbdb8af7f4f6a1404eb482e8189978dc2c47f0a03d442fd2b9195a5b"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Chapter 5 : Induction Machines"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 5.1  Page No : 198"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math \n",
      "\n",
      "# GIVEN DATA\n",
      "# For Case (a)\n",
      "\n",
      "S_a = 30;               # Total number of Slots\n",
      "m_a = 3;                # Total number of Poles\n",
      "p_a = 2;                # Total number of Phases\n",
      "\n",
      "# For Case (b)\n",
      "\n",
      "S_b = 60;               # Total number of Slots\n",
      "m_b = 3;                # Total number of Poles\n",
      "p_b = 4;                # Total number of Phases\n",
      "\n",
      "# For Case (c)\n",
      "\n",
      "S_c = 24;              # Total number of Slots\n",
      "m_c = 3;               # Total number of Poles\n",
      "p_c = 4;               # Total number of Phases\n",
      "\n",
      "# For Case (d)\n",
      "\n",
      "S_d = 12;              # Total number of Slots\n",
      "m_d = 3;               # Total number of Poles\n",
      "p_d = 2;               # Total number of Phases\n",
      "\n",
      "\n",
      "# CALCULATIONS\n",
      "# For Case (a)\n",
      "\n",
      "spp_a = S_a/(p_a*m_a);              # Slot per poles per phase \n",
      "\n",
      "# For Case (b)\n",
      "\n",
      "spp_b = S_b/(p_b*m_b);              # Slot per poles per phase \n",
      "\n",
      "# For Case (c)\n",
      "\n",
      "spp_c = S_c/(p_c*m_c);              # Slot per poles per phase \n",
      "\n",
      "# For Case (d)\n",
      "\n",
      "spp_d = S_d/(p_d*m_d);              # Slot per poles per phase \n",
      "\n",
      "\n",
      "# DISPLAY RESULTS\n",
      "\n",
      "print (\"EXAMPLE : 5.1 : SOLUTION :-\") ;\n",
      "print \" For case a) Slot per poles per phase, spp = %.f   \"%(spp_a);\n",
      "print \" For case b) Slot per poles per phase, spp = %.f   \"%(spp_b);\n",
      "print \" For case c) Slot per poles per phase, spp = %.f   \"%(spp_c);\n",
      "print \" For case d) Slot per poles per phase, spp = %.f   \"%(spp_d);"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "EXAMPLE : 5.1 : SOLUTION :-\n",
        " For case a) Slot per poles per phase, spp = 5   \n",
        " For case b) Slot per poles per phase, spp = 5   \n",
        " For case c) Slot per poles per phase, spp = 2   \n",
        " For case d) Slot per poles per phase, spp = 2   \n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 5.2  Page No : 201"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math \n",
      "\n",
      "\n",
      "# GIVEN DATA\n",
      "# For Case (a)\n",
      "\n",
      "S_a = 54;               # Total number of Slots\n",
      "m_a = 3;                # Total number of Poles\n",
      "p_a = 8;                # Total number of Phases\n",
      "\n",
      "# For Case (b)\n",
      "\n",
      "S_b = 32;               # Total number of Slots\n",
      "m_b = 3;                # Total number of Poles\n",
      "p_b = 4;                # Total number of Phases\n",
      "\n",
      "# For Case (c)\n",
      "\n",
      "S_c = 30;              # Total number of Slots\n",
      "m_c = 3;               # Total number of Poles\n",
      "p_c = 4;               # Total number of Phases\n",
      "\n",
      "\n",
      "# CALCULATIONS\n",
      "# For Case (a)\n",
      "\n",
      "spp_a = S_a/(p_a*m_a);                # Slot per poles per phase \n",
      "l_a = 0 * spp_a;                      # Phase allociation Series\n",
      "m_a = 1 * spp_a;                      # Phase allociation Series\n",
      "n_a = 2 * spp_a;                      # Phase allociation Series\n",
      "o_a = 3 * spp_a;                      # Phase allociation Series\n",
      "p_a = 4 * spp_a;                      # Phase allociation Series\n",
      "d_a = 0;                              # d_a = l_a (Rounding off)\n",
      "e_a = 2;                              # e_a = m_a (Rounding off)\n",
      "f_a = 4;                              # f_a = n_a (Rounding off)\n",
      "g_a = 6;                              # g_a = o_a (Rounding off)\n",
      "h_a = 9;                              # h_a = p_a (Rounding off)\n",
      "R_a = e_a - d_a;                      # Phase allociation\n",
      "Y_a = f_a - e_a;                      # Phase allociation\n",
      "B_a = g_a - f_a;                      # Phase allociation\n",
      "R1_a = h_a - g_a;                     # Phase allociation\n",
      "\n",
      "# For Case (b)\n",
      "\n",
      "spp_b = S_b/(p_b*m_b);                # Slot per poles per phase \n",
      "l_b = 0 * spp_b;                      # Phase allociation Series\n",
      "m_b = 1 * spp_b;                      # Phase allociation Series\n",
      "n_b = 2 * spp_b;                      # Phase allociation Series\n",
      "o_b = 3 * spp_b;                      # Phase allociation Series\n",
      "d_b = 0;                              # d_b = l_b (Rounding off)\n",
      "e_b = 2;                              # e_b = m_b (Rounding off)\n",
      "f_b = 5;                              # f_b = n_b (Rounding off)\n",
      "g_b = 8;                              # g_b = o_b (Rounding off)\n",
      "R_b = e_b - d_b;                      # Phase allociation\n",
      "Y_b = f_b - e_b;                      # Phase allociation\n",
      "B_b = g_b - f_b;                      # Phase allociation\n",
      "\n",
      "# For Case (c)\n",
      "\n",
      "spp_c = S_c/(p_c*m_c);                # Slot per poles per phase \n",
      "l_c = 0 * spp_c;                      # Phase allociation Series\n",
      "m_c = 1 * spp_c;                      # Phase allociation Series\n",
      "n_c = 2 * spp_c;                      # Phase allociation Series\n",
      "d_c = 0;                              # d_b = l_b (Rounding off)\n",
      "e_c = 2;                              # e_b = m_b (Rounding off)\n",
      "f_c = 5;                              # f_b = n_b (Rounding off)\n",
      "R_c = e_c - d_c;                      # Phase allociation\n",
      "Y_c = f_c - e_c;                      # Phase allociation\n",
      "\n",
      "# DISPLAY RESULTS\n",
      "\n",
      "print (\"EXAMPLE : 5.2 : SOLUTION :-\") ;\n",
      "print \"  For Case a) Slot per poles per phase  , spp = %.3f  \"%(spp_a);\n",
      "print \"               Phase allociation series is %.f, %.f, %.f, %.f, %.f, %.f, %.f, %.f, %.f, slots are allocated respectively\\\n",
      " to R, Y, B, R, Y, B, R, Y, B....... phase in Sequence \"%(R_a,Y_a,B_a,R1_a,R_a,Y_a,B_a,R1_a,R_a);\n",
      "print \"               By seeing Sequence its Slot per pole per phase is an Integer and such, balanced winding may be possible \"\n",
      "print \"  For Case b) Slot per poles per phase  , spp = %.3f  \"%(spp_b);\n",
      "print \"               Phase allociation series is %.f, %.f, %.f \"%(R_b,Y_b,B_b);\n",
      "print \"               By seeing Sequence its Slot per pole per phase are not Integer therefore R-phase will have 8 slots\\\n",
      " whereas Y-phase and B-phase will have 12 slots \";\n",
      "print \"  For Case c) Slot per poles per phase  , spp = %.1f  \"%(spp_c);\n",
      "print \"               Phase allociation series is %.f, %.f, %.f, %.f, %.f, %.f, %.f, %.f, %.f, %.f, %.f, %.f slots\\\n",
      " are allocated respectively to R, Y, B, R, Y, B, R, Y, B, R, Y, B....... phase in Sequence \"%(R_c,Y_c,R_c,Y_c,R_c,Y_c,R_c,Y_c,R_c,Y_c,R_c,Y_c);\n",
      "print \"               By seeing Sequence its Slot per pole per phase is an Integer and such, balanced winding may be possible \"\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "EXAMPLE : 5.2 : SOLUTION :-\n",
        "  For Case a) Slot per poles per phase  , spp = 2.000  \n",
        "               Phase allociation series is 2, 2, 2, 3, 2, 2, 2, 3, 2, slots are allocated respectively to R, Y, B, R, Y, B, R, Y, B....... phase in Sequence \n",
        "               By seeing Sequence its Slot per pole per phase is an Integer and such, balanced winding may be possible \n",
        "  For Case b) Slot per poles per phase  , spp = 2.000  \n",
        "               Phase allociation series is 2, 3, 3 \n",
        "               By seeing Sequence its Slot per pole per phase are not Integer therefore R-phase will have 8 slots whereas Y-phase and B-phase will have 12 slots \n",
        "  For Case c) Slot per poles per phase  , spp = 2.0  \n",
        "               Phase allociation series is 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3 slots are allocated respectively to R, Y, B, R, Y, B, R, Y, B, R, Y, B....... phase in Sequence \n",
        "               By seeing Sequence its Slot per pole per phase is an Integer and such, balanced winding may be possible \n"
       ]
      }
     ],
     "prompt_number": 2
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 5.3  Page No : 205"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math \n",
      "\n",
      "# GIVEN DATA\n",
      "\n",
      "s = 24.;                     # Total number of the pole\n",
      "p = 4.;                      # Total number of the poles in the Alternator\n",
      "\n",
      "\n",
      "# CALCULATIONS \n",
      "# For Case (a) Short pitching by one Slots\n",
      "\n",
      "spp = s/p;                     # Slot per pole \n",
      "E_a = ((180*2)/24.)*(4/2);      # Slot angle in Electrical\n",
      "kp_a = math.cos(math.radians(E_a/2));            # Pitch Factor\n",
      "kp5_a = math.cos(math.radians((5*E_a)/2));       # Pitch Factor\n",
      "kp7_a = math.cos(math.radians((7*E_a)/2));       # Pitch Factor\n",
      "\n",
      "# For Case(b) Short pitching by two Slots\n",
      "\n",
      "E_b = 2*((180*2)/24)*(4/2);    # Slot angle in Electrical\n",
      "kp_b = math.cos(math.radians(E_b/2));            # Pitch Factor\n",
      "kp5_b = math.cos(math.radians((5*E_b)/2))        # Pitch Factor\n",
      "kp7_b = math.cos(math.radians((7*E_b)/2));       # Pitch Factor\n",
      "\n",
      "\n",
      "# DISPLAY RESULTS\n",
      "\n",
      "print (\"EXAMPLE : 5.3 : SOLUTION :-\") ;\n",
      "print \" For Case a) Short pitching by one Slots:- Pitch Facor , kp = %.4f  \"%(kp_a);\n",
      "print \"                                                          kp5 = %.4f  \"%(kp5_a);\n",
      "print \"                                                          kp7 = %.4f  \"%(kp7_a);\n",
      "print \" For Case a) Short pitching by Two Slots:- Pitch Facor , kp = %.4f  \"%(kp_b);\n",
      "print \"                                                          kp5 = %.4f  \"%(kp5_b);\n",
      "print \"                                                          kp7 = %.4f  \"%(kp7_b);\n",
      "\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "EXAMPLE : 5.3 : SOLUTION :-\n",
        " For Case a) Short pitching by one Slots:- Pitch Facor , kp = 0.9659  \n",
        "                                                          kp5 = 0.2588  \n",
        "                                                          kp7 = -0.2588  \n",
        " For Case a) Short pitching by Two Slots:- Pitch Facor , kp = 0.8660  \n",
        "                                                          kp5 = -0.8660  \n",
        "                                                          kp7 = -0.8660  \n"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 5.4  Page No : 208"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math \n",
      "\n",
      "# GIVEN DATA\n",
      "\n",
      "s = 60.;                     # Total number of Slot\n",
      "m = 3.;                      # Total number of Phase\n",
      "p = 4.;                      # Total number of Pole\n",
      "\n",
      "\n",
      "# CALCULATIONS\n",
      "\n",
      "M = s/(m*p);                                 # Slot per pole per Phase\n",
      "sigma = 180/m;                               # Phase Spread in angle (deg)\n",
      "Ka = math.sin(math.radians((M*sigma)/2))/(M*math.sin(math.radians(sigma/2)));    # Distribution Factor\n",
      "\n",
      "\n",
      "# DISPLAY RESULTS\n",
      "\n",
      "print (\"EXAMPLE : 5.4 : SOLUTION :-\");\n",
      "print \" a) Distribution Factor, Ka = %.1f \"%(Ka)\n",
      "\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "EXAMPLE : 5.4 : SOLUTION :-\n",
        " a) Distribution Factor, Ka = 0.2 \n"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 5.7  Page No : 210"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math \n",
      "\n",
      "# GIVEN DATA\n",
      "\n",
      "f = 50.;                     # Frequency of the 2-pole Induction Motor\n",
      "p = 2.;                      # Total Number of Poles\n",
      "\n",
      "\n",
      "# CALCULATIONS\n",
      "\n",
      "Ns = (120*f)/p;                 # Synchronous Speed in RPM\n",
      "Ns5 = -(120*f)/(5*p);           # Synchronous Speed of 5th order space harmonic in RPM\n",
      "N5 = -(120*5*f)/p;              # Synchronous Speed of 5th order time harmonic in RPM\n",
      "Ns7 = (120*f)/(7*p);           # Synchronous Speed of 7th order space harmonic in RPM\n",
      "N7 = (120*7*f)/p;              # Synchronous Speed of 7th order time harmonic in RPM\n",
      "\n",
      "\n",
      "# DISPLAY RESULTS\n",
      "\n",
      "print (\"EXAMPLE : 5.7 : SOLUTION :-\");\n",
      "print \" a.1) Synchronous Speed of 5th order space harmonic, Ns5 = %.f RPM \"%(Ns5)\n",
      "print \" a.2) Synchronous Speed of 5th order time harmonic, N5 = %.f RPM \"%(N5)\n",
      "print \" b.1) Synchronous Speed of 7th order space harmonic, Ns7 = %.2f RPM \"%(Ns7)\n",
      "print \" b.2) Synchronous Speed of 7th order time harmonic,  N7 = %.f RPM \"%(N7)\n",
      "\n",
      "\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "EXAMPLE : 5.7 : SOLUTION :-\n",
        " a.1) Synchronous Speed of 5th order space harmonic, Ns5 = -600 RPM \n",
        " a.2) Synchronous Speed of 5th order time harmonic, N5 = -15000 RPM \n",
        " b.1) Synchronous Speed of 7th order space harmonic, Ns7 = 428.57 RPM \n",
        " b.2) Synchronous Speed of 7th order time harmonic,  N7 = 21000 RPM \n"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 5.8  Page No : 215"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math \n",
      "\n",
      "# GIVEN DATA\n",
      "\n",
      "p_a = 6;                        # Total number of Poles in the Alternator\n",
      "p_m = 4;                        # Total number of Poles of Induction Motor\n",
      "N_a = 900;                      # Running Speed of the Alternator in RPM\n",
      "N_m = 1250;                     # Running Speed of the Induction Motor in RPM\n",
      "m = 3;                          # Total Number of phase in Induction Motor\n",
      "\n",
      "\n",
      "# CALCULATIONS\n",
      "\n",
      "f = (N_a*p_a)/120;                  # Frequency of the 6-pole Alternator running at 900 RPM in Hertz\n",
      "Ns = (120*f)/p_m;                   # Synchronous Speed of 4-pole Induction Motor in RPM\n",
      "s = (Ns-N_m)/Ns;                    # Slip \n",
      "fr = s*f;                           # Frequency of the Rotor Current in Hertz \n",
      "\n",
      "\n",
      "# DISPLAY RESULTS\n",
      "\n",
      "print (\"EXAMPLE : 5.8 : SOLUTION :-\");\n",
      "print \" a) Frequency of the Rotor Current , fr = %.2f Hz \"%(fr)\n",
      "\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "EXAMPLE : 5.8 : SOLUTION :-\n",
        " a) Frequency of the Rotor Current , fr = 0.00 Hz \n"
       ]
      }
     ],
     "prompt_number": 6
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 5.9  Page No : 220"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math \n",
      "\n",
      "# GIVEN DATA\n",
      "\n",
      "p = 2;                        # Total number of Poles of Induction Motor\n",
      "f = 50;                       # Frequency in Hertz\n",
      "Nr = 2800;                    # Running Speed of the Induction Motor in RPM\n",
      "m = 3;                        # Total Number of phase in Induction Motor\n",
      "V = 400;                      # Operating Voltage of Induction Motor in Volts\n",
      "\n",
      "\n",
      "# CALCULATIONS\n",
      "\n",
      "Ns = (120.*f)/p;                   # Synchronous Speed in RPM\n",
      "s = 100*((Ns-Nr)/Ns);             # Slip in Percentage\n",
      "fr = (s/100)*f;                   # Frequency of the Rotor Current in Hertz \n",
      "\n",
      "\n",
      "# DISPLAY RESULTS\n",
      "\n",
      "print (\"EXAMPLE : 5.9 : SOLUTION :-\");\n",
      "print \" a) Slip, s = %.2f percent \"%(s);\n",
      "print \" b) Frequency of the Rotor Current, fr = %.2f Hz \"%(fr)\n",
      "\n",
      "\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "EXAMPLE : 5.9 : SOLUTION :-\n",
        " a) Slip, s = 6.67 percent \n",
        " b) Frequency of the Rotor Current, fr = 3.33 Hz \n"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 5.10  Page No : 223"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# GIVEN DATA\n",
      "m = 3;                          # Total Number of phase in Induction Motor\n",
      "p = 4;                          # Total number of Poles in Induction Motor\n",
      "f = 50;                         # Frequency in Hertz\n",
      "s = 0.03;                       # Slip\n",
      "\n",
      "\n",
      "# CALCULATIONS\n",
      "\n",
      "Ns = (120*f)/p;                     # Synchronous Speed in RPM\n",
      "Nr = (1-s)*Ns;                      # Rotor Speed in RPM\n",
      "\n",
      "\n",
      "# DISPLAY RESULTS\n",
      "\n",
      "print (\"EXAMPLE : 5.10 : SOLUTION :-\");\n",
      "print \" a) Rotor Speed , Nr = %.f RPM \"%(Nr)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "EXAMPLE : 5.10 : SOLUTION :-\n",
        " a) Rotor Speed , Nr = 1455 RPM \n"
       ]
      }
     ],
     "prompt_number": 9
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 5.11  Page No : 225"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# GIVEN DATA\n",
      "\n",
      "\n",
      "m = 3;                          # Total Number of phase in Induction Motor\n",
      "p = 6;                          # Total number of Poles of Induction Motor\n",
      "f = 50;                         # Frequency in Hertz\n",
      "s = 0.03;                       # Slip\n",
      "\n",
      "\n",
      "# CALCULATIONS\n",
      "\n",
      "Ns = (120*f)/p;                     # Synchronous Speed in RPM\n",
      "Nr = (1-s)*Ns;                      # Rotor Speed in RPM\n",
      "Nf = Ns - Nr;                       # Speed of Forward Rotating magnetic fields with respect to stator and rotor in RPM\n",
      "Nb = Ns + Nr;                       # Speed of Backward Rotating magnetic fields with respect to stator and rotor in RPM\n",
      "\n",
      "\n",
      "# DISPLAY RESULTS\n",
      "\n",
      "print (\"EXAMPLE : 5.11 : SOLUTION :-\");\n",
      "print \" a) Speed of Forward Rotating magnetic fields with respect to stator and rotor is equal to + %.f RPM \"%(Nf)\n",
      "print \" b) Speed of Backward Rotating magnetic fields with respect to stator and rotor is equal to + %.f RPM \"%(Nb)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "EXAMPLE : 5.11 : SOLUTION :-\n",
        " a) Speed of Forward Rotating magnetic fields with respect to stator and rotor is equal to + 30 RPM \n",
        " b) Speed of Backward Rotating magnetic fields with respect to stator and rotor is equal to + 1970 RPM \n"
       ]
      }
     ],
     "prompt_number": 10
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 5.12  Page No : 230"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# GIVEN DATA\n",
      "\n",
      "m = 3;                          # Total Number of phase in Induction Motor\n",
      "p = 2;                          # Total number of Poles of Induction Motor\n",
      "f = 50;                         # Frequency in Hertz\n",
      "s = 0.05;                       # Slip\n",
      "\n",
      "\n",
      "# CALCULATIONS\n",
      "\n",
      "Ns = (120*f)/p;                     # Synchronous Speed in RPM\n",
      "Nr = (1-s)*Ns;                      # Rotor Speed in RPM\n",
      "Nf = s*Ns;                          # Speed of Forward Rotating magnetic fields with respect to stator and rotor in RPM\n",
      "Nb = (p-s)*Ns;                      # Speed of Backward Rotating magnetic fields with respect to stator and rotor in RPM\n",
      "fr = (p-s)*f;                       # Backward rotating magnetic field induces a current of frequency in Hertz\n",
      "\n",
      "\n",
      "# DISPLAY RESULTS\n",
      "\n",
      "print (\"EXAMPLE : 5.12 : SOLUTION :-\");\n",
      "print \" a) Speed of Forward Rotating magnetic fields with respect to stator and rotor is equal to + %.f RPM \"%(Nf)\n",
      "print \" b) Speed of Backward Rotating magnetic fields with respect to stator and rotor is equal to + %.f RPM \"%(Nb)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "EXAMPLE : 5.12 : SOLUTION :-\n",
        " a) Speed of Forward Rotating magnetic fields with respect to stator and rotor is equal to + 150 RPM \n",
        " b) Speed of Backward Rotating magnetic fields with respect to stator and rotor is equal to + 5850 RPM \n"
       ]
      }
     ],
     "prompt_number": 11
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 5.13  Page No : 234"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# GIVEN DATA\n",
      "m = 3;                          # Total Number of phase in Induction Motor\n",
      "p = 4;                          # Total number of Poles of Induction Motor\n",
      "f = 50;                         # Frequency in Hertz\n",
      "s = 0.05;                       # Slip\n",
      "\n",
      "\n",
      "# CALCULATIONS\n",
      "\n",
      "Ns = (120*f)/p;                     # Synchronous Speed in RPM\n",
      "fr = s*f;                           # Rotor-induced Frequency of forward field in Hertz\n",
      "Nfr = s*Ns;                         # Speed of Forward Rotating magnetic fields with respect to rotor surface in RPM\n",
      "f2r = s*f;                           # Rotor-induced Frequency of Backward field in Hertz\n",
      "Nbr = -(s*Ns);                       # Speed of Backward Rotating magnetic fields with respect to rotor surface in RPM\n",
      "Nr = (1-s)*Ns;                       # Rotor running in Forward direction in RPM\n",
      "Nfs = Nr+(s*Ns);                     # Speed of Forward Rotating magnetic fields with respect to stator surface in RPM\n",
      "Nbs = Nr-(s*Ns);                     # Speed of Backward Rotating magnetic fields with respect to stator surface in RPM\n",
      "Nbs_new = -(0.5*Ns)+(1-0.5)*Nr;      # Speed of Backward Rotating magnetic fields with respect to stator for 50% of slip in RPM\n",
      "\n",
      "\n",
      "# DISPLAY RESULTS\n",
      "\n",
      "print (\"EXAMPLE : 5.13 : SOLUTION :-\");\n",
      "print \" a.1) Speed of Forward Rotating magnetic fields with respect to rotor surface is equal to + %.f RPM \"%(Nfr)\n",
      "print \" a.2) Speed of Backward Rotating magnetic fields with respect to rotor surface is equal to + %.f RPM \"%(Nbr)\n",
      "print \" b.1) Speed of Forward Rotating magnetic fields with respect to stator surface is equal to + %.f RPM \"%(Nfs)\n",
      "print \" b.2) Speed of Backward Rotating magnetic fields with respect to stator surface is equal to + %.f RPM \"%(Nbs)\n",
      "print \"  c)  Speed of Backward Rotating magnetic fields with respect to stator for 50 percenatge slip is equal to  %.1f RPM \"%(Nbs_new)\n",
      "print \"    [ TEXT BOOK SOLUTION IS PRINTED WRONGLY  I verified by manual calculation ]\" ;\n",
      "print \"      WRONGLY PRINTED ANSWERS ARE :- a) Speed of Backward Rotating magnetic fields with respect to stator for 50 percenatge slip is equal to 0 RPM instead of %.1f RPM   \"%(Nbs_new);\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "EXAMPLE : 5.13 : SOLUTION :-\n",
        " a.1) Speed of Forward Rotating magnetic fields with respect to rotor surface is equal to + 75 RPM \n",
        " a.2) Speed of Backward Rotating magnetic fields with respect to rotor surface is equal to + -75 RPM \n",
        " b.1) Speed of Forward Rotating magnetic fields with respect to stator surface is equal to + 1500 RPM \n",
        " b.2) Speed of Backward Rotating magnetic fields with respect to stator surface is equal to + 1350 RPM \n",
        "  c)  Speed of Backward Rotating magnetic fields with respect to stator for 50 percenatge slip is equal to  -37.5 RPM \n",
        "    [ TEXT BOOK SOLUTION IS PRINTED WRONGLY  I verified by manual calculation ]\n",
        "      WRONGLY PRINTED ANSWERS ARE :- a) Speed of Backward Rotating magnetic fields with respect to stator for 50 percenatge slip is equal to 0 RPM instead of -37.5 RPM   \n"
       ]
      }
     ],
     "prompt_number": 12
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 5.14  Page No : 235"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# GIVEN DATA\n",
      "\n",
      "f = 50;             # Stator Frequency of Inductor Motor in Hertz\n",
      "fr = 10;            # Rotor Frequency of Inductor Motor in Hertz\n",
      "p = 2;              # Number of poles\n",
      "\n",
      "\n",
      "# CALCULATIONS\n",
      "\n",
      "Ns = (120*f)/p;      # Synchronous Speed of Induction Motor in RPM\n",
      "s = fr/f;            # Slip of the Induction Motor\n",
      "Nr = (1-s)*Ns;       # Rotor Speed of the Induction Motor\n",
      "\n",
      "\n",
      "# DISPLAY RESULTS\n",
      "\n",
      "print (\"EXAMPLE : 5.14 : SOLUTION :-\");\n",
      "print \" a) Rotor Speed of Induction Motor, Nr = %.f RPM \"%(Nr)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "EXAMPLE : 5.14 : SOLUTION :-\n",
        " a) Rotor Speed of Induction Motor, Nr = 3000 RPM \n"
       ]
      }
     ],
     "prompt_number": 13
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 5.15  Page No : 237"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "\n",
      "# GIVEN DATA\n",
      "\n",
      "print \" EXAMPLE : 5.15 :           Given Data No-load test : 440V, 30A, 4.5KW \";\n",
      "print \"          Blocked rotor test :      90V%(50Hz, 120A, 16KW \";\n",
      "m = 3;                          # Total Number of phase in Induction Motor\n",
      "p = 6;                          # Total number of Poles of Induction Motor\n",
      "V = 440;                        # Operating voltage of the Induction motor in Volts\n",
      "out_hp = 100;                   # Output of the Induction motor in Horse-Power\n",
      "R = 0.15;                       # Average dc resistance in Ohms\n",
      "Wsc = 16000;                    # Power at Blocked Rotor test in Watts\n",
      "Vsc = 90;                       # Voltage at Blocked Rotor test in Volts\n",
      "Isc = 120;                      # Current at Blocked Rotor test in Amphere\n",
      "W0 = 4500;                      # Power at No-load test in Watts\n",
      "V0 = 440;                       # Voltage at No-load test in Volts\n",
      "I0 = 30;                        # Current at No-load test in Amphere \n",
      "s = 0.05;                       # Slip\n",
      "f = 50;                         # Frequency in Hertz\n",
      "\n",
      "\n",
      "# CALCULATIONS\n",
      "\n",
      "R1 = R/2;                                       # DC winding resistance per phase in Ohms\n",
      "Rac = Wsc/(3*Isc**2);                            # AC resistance referred to stator from locked rotor test at supply frequency in Ohms\n",
      "R_2 = Rac - R1;                                 # Per phase Rotor resistance to Stator in Ohms\n",
      "Zsc = Vsc/(math.sqrt(3)*Isc);                        # Per phase Impedance from locked rotor test in Ohms\n",
      "Xs = math.sqrt((Zsc**2)-(Rac**2));                     # Per phase leakage reactance referred to stator in Ohms\n",
      "theta_0 = math.acos(math.radians(W0/(V0*I0*math.sqrt(3))));            # No-load power factor angle in degree\n",
      "Im = I0*math.degrees(math.sin(math.radians(theta_0)));                          # Reactive component of no-load current in Amphere\n",
      "Xm = V0/(Im*math.sqrt(3));                           # Magnetizing reactance in Ohms\n",
      "Pc = W0 - 3*I0**2*R1;                            # Total Core loss in Watts\n",
      "Rc = (V0/math.sqrt(3))**2*(3/Pc);                     # Per phase core loss resistance in Watts\n",
      "Vph = V0/math.sqrt(3);                               # Per phase Voltage in Volts\n",
      "Ic = Vph/Rc;                                    # Core loss current in Amphere\n",
      "I_m = Vph/(1j * Xm);                            # Magnetizing Current in Amphere\n",
      "I_o = Ic + I_m;                                 # No-load current in Amphere\n",
      "I_2 = Vph/(R1+(R_2/s)+(1j*Xs));                 # Current in Amphere\n",
      "I1 = I_o + I_2;                                 # Input Current in Amphere\n",
      "Pf = math.cos(math.radians(math.degrees(math.atan(I1.imag/I1.real))));            # Power factor \n",
      "P1 = (3*(abs(I_2)**2*R_2)/s)/1000.;               # 3-phase air gap power or Rotor intake Power in Kilo-Watts\n",
      "Po = P1*(1-s);                                  # Output Power in Kilo-Watts\n",
      "Ws = 2*math.pi*((120*f/p)*(1./60.));                  # Angular Roatation in Radians per Seconds\n",
      "T = P1*1000/Ws;                                 # Torque in Newton-Meter\n",
      "\n",
      "\n",
      "# DISPLAY RESULTS\n",
      "\n",
      "print (\"EXAMPLE : 5.15 : SOLUTION :-\") ;\n",
      "print \" a.1)  DC winding resistance per phase, R1 = %.3f Ohms \"%(R1)\n",
      "print \" a.2)  AC resistance referred to stator from locked rotor test at supply frequency  = %.4f Ohms \"%(Rac)\n",
      "print \" a.3)  Per phase Rotor resistance to Stator, R2 = %.4f Ohms \"%(R_2)\n",
      "print \" a.4)  Per phase Impedance from locked rotor test, Zsc = %.3f Ohms \"%(Zsc)\n",
      "print \" a.5)  Per phase leakage reactance referred to stator, Xs = %.4f Ohms \"%(Xs)\n",
      "print \" a.6)  No-load power factor angle, theta_O = %.2f Degree \"%(theta_0)\n",
      "print \" a.7)  Reactive component of no-load current, Im = %.1f A \"%(Im)\n",
      "print \" a.8)  Magnetizing reactance, Xm = %.2f Ohms \"%(Xm)\n",
      "print \" a.9)  Total Core loss, Pc = %.1f W \"%(Pc)\n",
      "print \" a.10) Per phase core loss resistance, Pc = %.f Ohms \"%(Rc)\n",
      "print \" a.11) Per phase Voltage, Vph = %.f V \"%(Vph)\n",
      "print \" a.12) Core loss current, Ic = %.2f < %.f A \"%(abs(Ic),math.degrees(math.atan2(Ic.imag,Ic.real)))\n",
      "print \" a.13) Magnetizing Current, Im = %.1f < %.f A \"%(abs(I_m),math.degrees(math.atan2(I_m.imag,I_m.real)))\n",
      "print \" a.14) No-load current, I0 = %.2f < %.2f A \"%(abs(I_o),math.degrees(math.atan2(I_o.imag,I_o.real)))\n",
      "print \" a.15) Current, I2 = %.2f < %.2f A \"%(abs(I_2),math.degrees(math.atan2(I_2.imag,I_2.real)))\n",
      "print \"   b)  Input current, I1 = %.2f < %.2f A \"%(abs(I1),math.degrees(math.atan2(I1.imag,I1.real)))\n",
      "print \"   c)  Power Factor, Pf = %.4f Lagging \"%(Pf)\n",
      "print \"   d)  Output Power, P0 = %.1f kW \"%(Po)\n",
      "print \"   e)  Torque, T = %.2f NM \"%(T)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " EXAMPLE : 5.15 :           Given Data No-load test : 440V, 30A, 4.5KW \n",
        "          Blocked rotor test :      90V%(50Hz, 120A, 16KW \n",
        "EXAMPLE : 5.15 : SOLUTION :-\n",
        " a.1)  DC winding resistance per phase, R1 = 0.075 Ohms \n",
        " a.2)  AC resistance referred to stator from locked rotor test at supply frequency  = 0.0000 Ohms \n",
        " a.3)  Per phase Rotor resistance to Stator, R2 = -0.0750 Ohms \n",
        " a.4)  Per phase Impedance from locked rotor test, Zsc = 0.433 Ohms \n",
        " a.5)  Per phase leakage reactance referred to stator, Xs = 0.4330 Ohms \n",
        " a.6)  No-load power factor angle, theta_O = 1.57 Degree \n",
        " a.7)  Reactive component of no-load current, Im = 47.0 A \n",
        " a.8)  Magnetizing reactance, Xm = 5.40 Ohms \n",
        " a.9)  Total Core loss, Pc = 4297.5 W \n",
        " a.10) Per phase core loss resistance, Pc = 45 Ohms \n",
        " a.11) Per phase Voltage, Vph = 254 V \n",
        " a.12) Core loss current, Ic = 5.64 < 0 A \n",
        " a.13) Magnetizing Current, Im = 47.0 < -90 A \n",
        " a.14) No-load current, I0 = 47.35 < -83.16 A \n",
        " a.15) Current, I2 = 170.57 < -163.10 A \n",
        "   b)  Input current, I1 = 184.82 < -148.49 A \n",
        "   c)  Power Factor, Pf = 0.8525 Lagging \n",
        "   d)  Output Power, P0 = -124.4 kW \n",
        "   e)  Torque, T = -1250.21 NM \n"
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 5.17  Page No : 239"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math \n",
      "\n",
      "\n",
      "# GIVEN DATA\n",
      "\n",
      "print \" EXAMPLE : 5.17 :           Given Data No-load test : 440V%( 3.0A, 500KW, 50Hz \";\n",
      "print \"          Blocked rotor test at rated frequency : 110V%( 18A, 2500W, 50Hz \";\n",
      "print \"          DC test on Stator per phase : 10V, 15A \";\n",
      "m = 3;                          # Total Number of phase in Induction Motor\n",
      "p = 4;                          # Total number of Poles of Induction Motor\n",
      "f = 50;                         # Frequency in Hertz\n",
      "V = 440;                        # Operating Voltage of the Inductuon Motor\n",
      "out_hp = 20;                    # Motor Power Rating in Horse-Power \n",
      "Vdc = 10;                       # DC Voltage in Volts\n",
      "Idc = 15;                       # DC Current in Amphere\n",
      "Wsc = 2500;                     # Power at Blocked Rotor test rated frequency in Watts\n",
      "Wsc_red = 2050;                 # Power at Blocked Rotor test reduced frequency in Watts\n",
      "Vsc = 110;                      # Voltage at Blocked Rotor test rated frequency in Volts\n",
      "Isc = 18;                       # Current at Blocked Rotor test rated frequency in Amphere\n",
      "Wo = 500;                       # Power at No-load test in Watts\n",
      "Vo = 440;                       # Voltage at No-load test in Volts\n",
      "Io = 4.0;                       # Current at No-load test in Amphere\n",
      "fsc = 50;                       # Rated Frequency at blocked rotor test in Hertz\n",
      "fo = 50;                        # Rated Frequency at no-load test in Hertz\n",
      "fsc1 = 15;                      # Reduced Frequency at blocked rotor in Hertz\n",
      "Pfw = 200;                      # Friction and Windage loss in Watts\n",
      "\n",
      "\n",
      "# CALCULATIONS\n",
      "\n",
      "R1dc = Vdc/Idc;                         # DC winding resistance per phase in Ohms\n",
      "Rac = Wsc/(3*Isc**2);                    # AC resistance from Locked rotor test at supply frequency\n",
      "Rac_red = Wsc_red/(3*Isc**2);            # AC resistance from Locked rotor test at reduced frequency\n",
      "R1ac = (Rac/Rac_red)*R1dc;              # Corrected Value of AC stator winding resistance in Ohms\n",
      "R2dc = Rac_red - R1dc;                  # Second rotor parameter, rotor resistance referred to stator is at low frequency in Ohms\n",
      "Zsc = Vsc/(math.sqrt(3)*Isc);                        # Per phase Impedance from locked rotor test at power frequency in Ohms\n",
      "Xs = math.sqrt((Zsc**2)-(Rac**2));                     # Per phase leakage reactance referred to stator in Ohms\n",
      "theta_0 = math.acos(math.radians(Wo/(Vo*Io*math.sqrt(3))));            # No-load power factor angle in degree\n",
      "Im = Io*math.degrees(math.sin(math.radians(theta_0)));                          # Reactive component of no-load current in Amphere\n",
      "Xm = Vo/(Im*math.sqrt(3));                           # Magnetizing reactance in Ohms\n",
      "Pc = Wo - 3*Io**2*R1ac-Pfw;                      # Total Core loss in Watts\n",
      "Rc = (Vo/math.sqrt(3))**2*(3/Pc);                     # Per phase core loss resistance in Watts\n",
      "\n",
      "\n",
      "# DISPLAY RESULTS\n",
      "\n",
      "print (\"EXAMPLE : 5.17 : SOLUTION :-\") ;\n",
      "print \" a)  Magnetizing reactance of Equivalent circuit, Xm = %.1f Ohms \"%(Xm)\n",
      "print \" b) Per phase core loss resistance, Pc = %.f Ohms \"%(Rc)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " EXAMPLE : 5.17 :           Given Data No-load test : 440V%( 3.0A, 500KW, 50Hz \n",
        "          Blocked rotor test at rated frequency : 110V%( 18A, 2500W, 50Hz \n",
        "          DC test on Stator per phase : 10V, 15A \n",
        "EXAMPLE : 5.17 : SOLUTION :-\n",
        " a)  Magnetizing reactance of Equivalent circuit, Xm = 40.5 Ohms \n",
        " b) Per phase core loss resistance, Pc = 645 Ohms \n"
       ]
      }
     ],
     "prompt_number": 15
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 5.18  Page No : 240"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math \n",
      "\n",
      "# GIVEN DATA\n",
      "# From Previous problem data (Example 5.17)\n",
      "\n",
      "R1ac = 0.8127;                  # Corrected Value of AC stator winding resistance in Ohms\n",
      "R2dc = 1.4433;                  # Second rotor parameter, rotor resistance referred to stator is at low frequency in Ohms\n",
      "Xs = 2.42;                     # Per phase leakage reactance referred to stator in Ohms\n",
      "Xm = 64.4;                     # Magnetizing reactance in Ohms\n",
      "Rc = 742;                      # Per phase core loss resistance in Watts\n",
      "s = 0.035;                     # Slip\n",
      "m = 3;                         # Total Number of phase in Induction Motor\n",
      "p = 4;                         # Total number of Poles of Induction Motor\n",
      "f = 50;                        # Frequency in Hertz\n",
      "V = 440;                       # Operating Voltage of the Inductuon Motor\n",
      "out_hp = 20;                   # Motor Power Rating in Horse-Power\n",
      "\n",
      "\n",
      "# CALCULATIONS\n",
      "\n",
      "Vph = V/math.sqrt(3);                                # Per phase Voltage in Volts\n",
      "Ic = Vph/Rc;                                    # Core loss current in Amphere\n",
      "I_m = Vph/(1j * Xm);                            # Magnetizing Current in Amphere\n",
      "I_o = Ic + I_m;                                 # No-load current in Amphere\n",
      "I_2 = Vph/(R1ac+(R2dc/s)+(1j*Xs));              # Current in Amphere\n",
      "I1 = I_o + I_2;                                 # Input Current in Amphere\n",
      "Pf = math.cos(math.radians(math.degrees(math.atan(I1.imag/I1.real))));            # Power factor \n",
      "P1 = 3*(abs(I_2)**2*R2dc)/s;                    # 3-phase air gap power or Rotor intake Power in Watts\n",
      "Po = P1*(1-s);                                  # Output Power in Watts\n",
      "Ws = 2*math.pi*((120*f/p)*(1./60));                  # Angular Roatation in Radians per Seconds\n",
      "T = P1/Ws;                                      # Torque in Newton-Meter\n",
      "\n",
      "\n",
      "# DISPLAY RESULTS\n",
      "\n",
      "print (\"EXAMPLE : 5.18 : SOLUTION :-\");\n",
      "print \"   a)  Input current, I1 = %.2f < %.2f A \"%(abs(I1),math.degrees(math.atan2(I1.imag,I1.real)))\n",
      "print \"   b)  Power Factor, Pf = %.3f Lagging \"%(Pf)\n",
      "print \"   c)  Output Power, P0 = %.2f W \"%(Po)\n",
      "print \"   d)  Torque, T = %.2f NM \"%(T)\n",
      "print \"    [ TEXT BOOK SOLUTION IS PRINTED WRONGLY  I verified by manual calculation ]\" ;\n",
      "print \"      WRONGLY PRINTED ANSWERS ARE :- a) T = 4340.82 Nm instead of %.2f Nm  \"%(T);\n",
      "print \"       IN TEXT BOOK, CALCULATION OF TORQUE IS NOT DONE  \";\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "EXAMPLE : 5.18 : SOLUTION :-\n",
        "   a)  Input current, I1 = 7.68 < -33.99 A \n",
        "   b)  Power Factor, Pf = 0.829 Lagging \n",
        "   c)  Output Power, P0 = 4342.67 W \n",
        "   d)  Torque, T = 28.65 NM \n",
        "    [ TEXT BOOK SOLUTION IS PRINTED WRONGLY  I verified by manual calculation ]\n",
        "      WRONGLY PRINTED ANSWERS ARE :- a) T = 4340.82 Nm instead of 28.65 Nm  \n",
        "       IN TEXT BOOK, CALCULATION OF TORQUE IS NOT DONE  \n"
       ]
      }
     ],
     "prompt_number": 16
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 5.19  Page No : 243"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math \n",
      "from numpy import imag,real\n",
      "\n",
      "\n",
      "# GIVEN DATA\n",
      "\n",
      "s = 0.05;                       # Slip\n",
      "m = 3;                          # Total Number of phase in Induction Motor\n",
      "p = 4;                          # Total number of Poles of Induction Motor\n",
      "f = 50;                         # Frequency in Hertz\n",
      "V = 440;                        # Operrating Voltage of the Inductuon Motor\n",
      "R1 = 0.10;                      # Circuit Parameter in Ohms\n",
      "R2 = 0.11;                      # Circuit Parameter in Ohms\n",
      "X1 = 0.35;                      # Circuit Parameter in Ohms\n",
      "X2 = 0.40;                      # Circuit Parameter in Ohms\n",
      "pf = 0.2;                       # Power factor (Lagging)\n",
      "Pr = 900;                       # Rotational Loss in Watts\n",
      "Psc = 1000;                     # Stator core loss in Watts\n",
      "I = 15;                         # Line current draws by the motor in Amphere\n",
      "\n",
      "\n",
      "# CALCULATIONS\n",
      "\n",
      "Vph = V/math.sqrt(3);                                    # Per phase Voltage in Volts\n",
      "I_2 = Vph/(R1+(R2/s)+(1j*(X1+X2)));                 # Current in Amphere\n",
      "Io = I * (-(1j * math.degrees(math.acos(pf)) * math.pi/180.))**2;         # No-load current in Amphere\n",
      "I1 = Io + I_2;                                      # Input line Current in Amphere\n",
      "PF = math.cos(math.radians(math.degrees(math.atan(I1.imag/I1.real))));                # Power factor\n",
      "Ws = 2*math.pi*((120*f/p)*(1./60.));                      # Angular Roatation in Radians per Seconds\n",
      "Pg = (3*(abs(I1)**2*R2))/s;                          # 3-phase air gap power or Rotor intake Power in Watts\n",
      "T = Pg/Ws;                                          # Torque in Newton-Meter\n",
      "Po = Pg*(1-s)-Pr;                                   # Output Power in Watts\n",
      "Po_HP = Po/746;                                     # Output Power in Horse-Power\n",
      "eta = (Po/(Po+Psc+Pr))*100.;                         # Efficiency in Percentage\n",
      "\n",
      "\n",
      "# DISPLAY RESULTS\n",
      "\n",
      "print (\"EXAMPLE : 5.19 : SOLUTION :-\");\n",
      "print \"   a)  Input line current, I1 = %.1f < %.2f A \"%(abs(I1),math.degrees(math.atan2(I1.imag,I1.real)))\n",
      "print \"   b)  Power Factor, Pf = %.4f Lagging \"%(PF)\n",
      "print \"   c)  Output Power, P0 = %.1f HP \"%(Po_HP)\n",
      "print \"   d)  Torque, T = %.2f Nm \"%(T)\n",
      "print \"   e)  Efficiency, eta = %.1f Percenatge \"%(eta)\n",
      "print \"    [ TEXT BOOK SOLUTION IS PRINTED WRONGLY  I verified by manual calculation ]\" ;\n",
      "print \"      WRONGLY PRINTED ANSWERS ARE :- a) I1 = 114.2<-24.68 A instead of %.1f<%.2f A  \"%(abs(I1),math.degrees(math.atan2(I1.imag,I1.real)));\n",
      "print \"                                     b) T = 548.24 Nm instead of %.2f Nm  \"%(T);\n",
      "print \"                                     c) Po = 108.4 HP instead of %.1f HP  \"%(Po_HP);\n",
      "\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "EXAMPLE : 5.19 : SOLUTION :-\n",
        "   a)  Input line current, I1 = 78.7 < -24.42 A \n",
        "   b)  Power Factor, Pf = 0.9105 Lagging \n",
        "   c)  Output Power, P0 = 50.9 HP \n",
        "   d)  Torque, T = 260.56 Nm \n",
        "   e)  Efficiency, eta = 95.2 Percenatge \n",
        "    [ TEXT BOOK SOLUTION IS PRINTED WRONGLY  I verified by manual calculation ]\n",
        "      WRONGLY PRINTED ANSWERS ARE :- a) I1 = 114.2<-24.68 A instead of 78.7<-24.42 A  \n",
        "                                     b) T = 548.24 Nm instead of 260.56 Nm  \n",
        "                                     c) Po = 108.4 HP instead of 50.9 HP  \n"
       ]
      }
     ],
     "prompt_number": 17
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 5.20  Page No : 246"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math \n",
      "from numpy import imag,real\n",
      "\n",
      "# GIVEN DATA\n",
      "\n",
      "m = 3;                         # Total Number of phase in Induction Motor\n",
      "p = 6;                         # Total number of Poles of Induction Motor\n",
      "f = 50;                        # Frequency in Hertz\n",
      "V = 440;                       # Operating Voltage of the Inductuon Motor\n",
      "R1 = 0.25;                     # Circuit Parameter in Ohms\n",
      "R2 = 0.25;                     # Circuit Parameter in Ohms\n",
      "X1 = 0.75;                     # Circuit Parameter in Ohms\n",
      "X2 = 0.75;                     # Circuit Parameter in Ohms\n",
      "Xm = 1000;                     # Circuit Parameters in Ohms\n",
      "Rc = 100;                      # Circuit Parameters in Watts\n",
      "s = 0.025;                     # Slip\n",
      "Pr = 450;                      # Rotational Loss in Watts\n",
      "Psc = 800;                     # Stator core loss in Watts\n",
      "\n",
      "\n",
      "# CALCULATIONS\n",
      "\n",
      "Vph = V/math.sqrt(3);                                    # Per phase Voltage in Volts\n",
      "I_2 = Vph/(R1+(R2/s)+(1j*(X1+X2)));                 # Current in Amphere\n",
      "Ic = Vph/Rc;                                    # Core loss current in Amphere\n",
      "I_m = Vph/(1j * Xm);                            # Magnetizing Current in Amphere\n",
      "I_o = Ic + I_m;                                 # No-load current in Amphere\n",
      "I1 = I_o + I_2;                                 # Input Current in Amphere\n",
      "Pf = math.cos(math.radians(math.degrees(math.atan(I1.imag/I1.real))));            # Power factor \n",
      "Ns = (120*f)/p;                                 # Synronous Speed in RPM\n",
      "Pg = 3*(abs(I_2)**2*R2)/s;                       # 3-phase air gap power or Rotor intake Power in Watts\n",
      "Pm = Pg*(1-s);                                  # Output Power in Watts\n",
      "Ws = 2*math.pi*Ns*(1./60.);                           # Angular Roatation in Radians per Seconds\n",
      "T = Pg/Ws;                                      # Torque in Newton-Meter\n",
      "Po = Pm-Pr;                                     # Output Power in Watts\n",
      "Po_HP = Po/746;                                 # Output Power in Horse-Power\n",
      "eta = (Po/(Po+Psc+Pr))*100;                     # Efficiency in Percentage\n",
      "\n",
      "\n",
      "# DISPLAY RESULTS\n",
      "\n",
      "print (\"EXAMPLE : 5.20 : SOLUTION :-\");\n",
      "print \"   a)  Input line current, I1 = %.f < %.2f A \"%(abs(I1),math.degrees(math.atan(I1.imag%(I1.real))))\n",
      "print \"   b)  Power Factor, Pf = %.4f Lagging \"%(Pf)\n",
      "print \"   c)  Output Power, P0 = %.2f HP \"%(Po_HP)\n",
      "print \"   d)  Torque, T = %.1f Nm \"%(T)\n",
      "print \"   e)  Efficiency, eta = %.1f Percenatge \"%(eta)\n",
      "print \"    [ TEXT BOOK SOLUTION IS PRINTED WRONGLY  I verified by manual calculation ]\" ;\n",
      "print \"      WRONGLY PRINTED ANSWERS ARE :- a) I1 = 26.8-j3.584 {27<-7.62} A in instead of %.1f)+j%.3f) {%.f<%.2f} A  \"%(I1.real,I1.imag,abs(I1),math.degrees(math.atan2(I1.imag,I1.real)));\n",
      "print \"                                     b) pf = 0.9885 Lagging instead of %.4f Lagging  \"%(Pf);\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "EXAMPLE : 5.20 : SOLUTION :-\n",
        "   a)  Input line current, I1 = 27 < 87.51 A \n",
        "   b)  Power Factor, Pf = 0.9901 Lagging \n",
        "   c)  Output Power, P0 = 22.98 HP \n",
        "   d)  Torque, T = 172.3 Nm \n",
        "   e)  Efficiency, eta = 93.2 Percenatge \n",
        "    [ TEXT BOOK SOLUTION IS PRINTED WRONGLY  I verified by manual calculation ]\n",
        "      WRONGLY PRINTED ANSWERS ARE :- a) I1 = 26.8-j3.584 {27<-7.62} A in instead of 26.8)+j-3.805) {27<-8.08} A  \n",
        "                                     b) pf = 0.9885 Lagging instead of 0.9901 Lagging  \n"
       ]
      }
     ],
     "prompt_number": 18
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 5.21  Page No : 251"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math \n",
      "from numpy import roots\n",
      "\n",
      "# GIVEN DATA\n",
      "m = 3;                          # Total Number of phase in Induction Motor\n",
      "p = 4;                          # Total number of Poles of Induction Motor\n",
      "s = 0.05;                       # Slip\n",
      "f = 50;                         # Frequency in Hertz\n",
      "Tm = 500;                       # Maximum Torque in Newton-Meter\n",
      "Tst = 200;                      # Starting Torque in Newton-Meter\n",
      "sst = 1.0;                      # Starting Slip\n",
      "\n",
      "\n",
      "# CALCULATONS\n",
      "\n",
      "p1 = [1, -5, 1]           # Slip at Maximum Torque (obtained from Equation  Tst = (2*Tm)/((sst/sm)+(sm+sst))\n",
      "a = roots(p1);                  # Value of slip at Maximum Torque (obtained from Equation  Tst = (2*Tm)/((sst/sm)+(sm+sst)) \n",
      "sm = a[1]#(2,1);                    # Slip at Maximum Torque (obtained from Equation  Tst = (2*Tm)/((sst/sm)+(sm+sst)) { 1st root is 4.8 so its out of range because slip value is lies between 0-1 so its neglected and second root will be slip }\n",
      "T = (2*Tm)/((s/sm)+(sm/s));     # Torque at 0.05 slip\n",
      "Ns = (120*f)/p;                 # Synchronous Speed in RPM\n",
      "Wr = (2*math.pi)*(1-s)*(Ns/60);     # Angular Velocity in Radians-per-Second\n",
      "P = T * Wr;                     # Power Output in Watts\n",
      "P_HP = P/746;                   # Power Output in Horse-Power\n",
      "\n",
      "\n",
      "# DISPLAY RESULTS\n",
      "\n",
      "print (\"EXAMPLE : 5.21 : SOLUTION :-\");\n",
      "print \" a) Torque at 0.05 slip, T = %.2f Nm \"%(T)\n",
      "print \" b) Power Output at 0.05 slip, P = %.1f W = %.2f HP \"%(P,P_HP)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "EXAMPLE : 5.21 : SOLUTION :-\n",
        " a) Torque at 0.05 slip, T = 226.56 Nm \n",
        " b) Power Output at 0.05 slip, P = 33808.8 W = 45.32 HP \n"
       ]
      }
     ],
     "prompt_number": 19
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 5.22  Page No : 255"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math \n",
      "\n",
      "# GIVEN DATA\n",
      "Wsc = 1000.;                    # Power at Blocked Rotor test in Watts\n",
      "Vsc = 56.;                      # Voltage at Blocked Rotor test in Volts\n",
      "Isc = 18.;                      # Current at Blocked Rotor test in Amphere\n",
      "Woc = 52.;                      # Power at No-load test in Watts\n",
      "Voc = 220.;                     # Voltage at No-load test in Volts\n",
      "Ioc = 2.6;                     # Current at No-load test in Amphere \n",
      "m = 3.;                         # Total Number of phase in Induction Motor\n",
      "p = 4.;                         # Total number of Poles of Induction Motor\n",
      "V = 220.;                       # Operating voltage of the Induction motor in Volts\n",
      "f = 50.;                        # Frequency in Hertz\n",
      "s = 0.05;                      # Slip\n",
      "R = 0.65;                      # Per phase stator resistance in Ohms\n",
      "\n",
      "\n",
      "# CALCULATIONS\n",
      "\n",
      "Vph = Voc/math.sqrt(3);                               # Per phase Voltage in Volts\n",
      "Wo = Woc/m;                                      # Per phase No-load loss in Watts\n",
      "theta_0 = math.acos(math.radians(Wo/(Voc*Ioc*math.sqrt(3))));           # No-load power factor angle in degree\n",
      "VSC = Vsc/math.sqrt(3);                               # Per phase locked rotor Voltage in Volts\n",
      "WSC = Wsc/m;                                     # Per phase locked rotor loss in Watts\n",
      "theta_sc = math.acos(math.radians(WSC/(VSC*Isc)));                 # No-load power factor angle in degree\n",
      "ISC = Isc*(Voc/Vsc);                             # locked rotor current at full Voltage in Amphere\n",
      "Re = WSC/Isc**2;                                  # resistance in Ohms\n",
      "R1 = R*1.1;                                      # Per phase AC stator resistance in Ohms\n",
      "R_2 = Re - R1;                                   # Per phase rotor resistance in Ohms\n",
      "Zsc = VSC/Isc;                                   # Per phase impedance in Ohms\n",
      "Xs = math.sqrt((Zsc**2)-(Re**2));                       # Leakage reactance in Ohms\n",
      "I_2 = (Voc/math.sqrt(3))/math.sqrt((R1+(R_2/s))**2+(Xs**2)); # Current in Amphere\n",
      "pf = math.cos(math.radians(math.degrees(math.atan(Xs/(R1+(R_2/s))))));               # Power Factor\n",
      "Ws = 2*math.pi*((120*f/p)*(1./60.));                   # Rotational Speed in Radians per Seconds\n",
      "Pg = (3*(abs(I_2)**2*R_2))/s;                     # 3-phase air gap power or Rotor intake Power in Watts\n",
      "T = Pg/Ws;                                       # Torque in Newton-Meter\n",
      "# CALCULATIONS OR DATA OBTAINED FROM CIRCLE DIAGRAM FIGURE 5.35 and PAGE NO:-303\n",
      "OA = 2.60;                                       # Correspounding Current in Amphere at 87' from Y-axis (from Circle diagram)\n",
      "OE = 70.70;                                      # Correspounding Current in Amphere at 55' from Y-axis (from Circle diagram)\n",
      "OP = 17.77;                                      # Current in Amphere (from Circle diagram)\n",
      "OV = Voc/math.sqrt(3);                                # Phase Voltage in No-load test or value obatined from circle diagram in Volts\n",
      "PK = 11.6;                                       # Correspounding Value from Circle diagram\n",
      "JK = 0.8;                                        # Correspounding Value from Circle diagram\n",
      "PJ = 10.8;                                       # Correspounding Value from Circle diagram\n",
      "PM = 11.6;                                       # Correspounding Value from Circle diagram\n",
      "Pir = 3*OV*PK;                                   # Total Rotor intake in Watts\n",
      "Plr = 3*OV*JK;                                   # Total Rotor loss in Watts\n",
      "Po = 3*OV*PJ;                                    # Total Mechanical power output in Watts\n",
      "T_c = (3*OV*PK)/Ws;                              # Total Torque in Newton-Meter\n",
      "s_c = JK/PK;                                     # Slip obtained from Circle diagram\n",
      "s_pc = 100*s_c;                                  # Slip in percentage\n",
      "eta = 100*(PJ/PM);                               # Eifficiency in Percentage\n",
      "\n",
      "\n",
      "# DISPLAY RESULTS\n",
      "\n",
      "print (\"EXAMPLE : 5.22 : SOLUTION :-\");\n",
      "print \"   a)  Input line current, I2 = %.2f A \"%(I_2)\n",
      "print \"   b)  Power Factor, Pf = %.3f \"%(pf)\n",
      "print \"   c)  Torque, T = %.2f Nm \"%(T)\n",
      "print \"  Verification Results from Circle Diagram :-\";\n",
      "print \"   a)  Efficency, eta = %.2f Percent \"%(eta)\n",
      "print \"   b)  slip, s = %.3f = %.f percent \"%(s_c,s_pc)\n",
      "print \"   c)  Torque, T = %.2f Nm \"%(T_c)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "EXAMPLE : 5.22 : SOLUTION :-\n",
        "   a)  Input line current, I2 = 17.78 A \n",
        "   b)  Power Factor, Pf = 0.979 \n",
        "   c)  Torque, T = 37.89 Nm \n",
        "  Verification Results from Circle Diagram :-\n",
        "   a)  Efficency, eta = 93.10 Percent \n",
        "   b)  slip, s = 0.069 = 7 percent \n",
        "   c)  Torque, T = 28.14 Nm \n"
       ]
      }
     ],
     "prompt_number": 20
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 5.23  Page No : 259"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math \n",
      "from numpy import real,imag\n",
      "\n",
      "\n",
      "# GIVEN DATA\n",
      "\n",
      "R1 = 0.2;                      # Circuit Parameter in Ohms\n",
      "R2 = 0.4;                      # Circuit Parameter in Ohms\n",
      "X1 = 1.0;                      # Circuit Parameter in Ohms\n",
      "X2 = 1.5;                      # Circuit Parameter in Ohms\n",
      "m = 3;                          # Total Number of phase in Induction Motor\n",
      "p = 2;                          # Total number of Poles of Induction Motor\n",
      "f = 50;                         # Frequency in Hertz\n",
      "V = 440;                        # Operating Voltage of the Inductuon Motor\n",
      "\n",
      "\n",
      "# CALCULATIONS\n",
      "\n",
      "Ws = 2*math.pi*f;                               # Synchronous angular speed in Radians per second\n",
      "Z = (R1+R2)+((1j)*(X1+X2));                 # At slip s=1, the impedance seen from the terminals in Ohms\n",
      "s = 1;                                      # Slip\n",
      "\n",
      "# For Case(a) Winding is connected in star\n",
      "\n",
      "Isy_a = V/(abs(Z)*math.sqrt(3));                   # Current in Amphere\n",
      "Tsy_a = (3*Isy_a**2*R2)/(s*Ws);                # Torque in Newton-Meter\n",
      "\n",
      "# Winding is connected in delta\n",
      "\n",
      "Isd_a = (V*math.sqrt(3))/abs(Z);                   # Current in Amphere\n",
      "Tsd_a = (3*(Isd_a/math.sqrt(3))**2*R2)/(s*Ws);      # Torque in Newton-Meter\n",
      "I_R = Isd_a/Isy_a;                            # Ratio of the line current\n",
      "T_R = Tsd_a/Tsy_a;                            # Ratio of the Torque\n",
      " \n",
      "# For Case(b) Machine is started umath.sing auto-transfromer and voltage is 50% reduced\n",
      "\n",
      "Isy_b = (0.5*V)/(abs(Z)*math.sqrt(3));                 # Current in Amphere when Winding is connected star\n",
      "Tsy_b = (3*Isy_b**2*R2)/(s*Ws);                    # Torque in Newton-Meter when Winding is connected star\n",
      "Isd_b = (0.5*V*math.sqrt(3))/abs(Z);                   # Current in Amphere when Winding is connected delta\n",
      "Tsd_b = (3*(Isd_b/math.sqrt(3))**2*R2)/(s*Ws);          # Torque in Newton-Meter when Winding is connected delta\n",
      "\n",
      "# For Case(c) Both Voltage and Frequency are reduced to 50%\n",
      "\n",
      "f_new = (10./100)*f;                               # New Frequency\n",
      "Ws_c = 2*math.pi*f_new;                               # Synchronous angular speed in Radians per second\n",
      "Z_c = ((R1+R2)+((1j)*(X1+X2))*(f_new/f));         # At slip s=1, the impedance seen from the terminals in Ohms\n",
      "Isy_c = (0.1*V)/(abs(Z_c)*math.sqrt(3));               # Current in Amphere when Winding is connected star\n",
      "Tsy_c = (3*Isy_c**2*R2)/(s*Ws_c);                  # Torque in Newton-Meter when Winding is connected star\n",
      "Isd_c = (0.1*V*math.sqrt(3))/abs(Z_c);                 # Current in Amphere when Winding is connected delta\n",
      "Tsd_c = (3*(Isd_c/math.sqrt(3))**2*R2)/(s*Ws_c);        # Torque in Newton-Meter when Winding is connected delta\n",
      "\n",
      "\n",
      "# DISPLAY RESULTS\n",
      "\n",
      "print (\"EXAMPLE : 5.23 : SOLUTION :-\");\n",
      "print \" For Case a.1 Winding is connected in star \";\n",
      "print \" a.1.1) Per phase impedance seen from the terminals in Ohms, Z = %.3f < %.1f Ohms \"%(abs(Z),math.degrees(math.atan2(Z.imag,Z.real)));\n",
      "print \" a.1.2) Initial Starting Current , Isy = %.2f A \"%(Isy_a)\n",
      "print \" a.1.3) Starting Torque , Tsy = %.1f Nm \"%(Tsy_a)\n",
      "print \" For Case a.2 Winding is connected in delta \" ;\n",
      "print \" a.2.1) Initial Starting Current , Isd = %.2f A \"%(Isd_a)\n",
      "print \" a.2.2) Starting Torque , Tsd = %.2f Nm \"%(Tsd_a)\n",
      "print \" For Case b Machine is started umath.sing auto-transfromer and voltage is 50 percentage reduced :- b.1 Winding is connected in star  \"\n",
      "print \" b.1.1) Per phase impedance seen from the terminals in Ohms, Z = %.3f<%.1f Ohms \"%(abs(Z),math.degrees(math.atan2(Z.imag,Z.real)));\n",
      "print \" b.1.2) Initial Starting Current , Isy = %.1f A \"%(Isy_b)\n",
      "print \" b.1.3) Starting Torque , Tsy = %.2f Nm \"%(Tsy_b)\n",
      "print \" For Case b.2 Winding is connected in delta \" ;\n",
      "print \" b.2.1) Initial Starting Current , Isd = %.2f A \"%(Isd_b)\n",
      "print \" b.2.2) Starting Torque , Tsd = %.f Nm \"%(Tsd_b)\n",
      "print \" For Case c Both Voltage and Frequency are reduced to 50 percentage :- c.1 Winding is connected in star  \";\n",
      "print \" c.1.1) Per phase impedance seen from the terminals in Ohms, Z =  %.2f<%.2f Ohms \"%(abs(Z_c),math.degrees(math.atan2(Z_c.imag,Z_c.real)));\n",
      "print \" c.1.2) Initial Starting Current , Isy = %.2f A \"%(Isy_c)\n",
      "print \" c.1.3) Starting Torque , Tsy = %.2f Nm \"%(Tsy_c)\n",
      "print \" For Case c.2 Winding is connected in delta \" ;\n",
      "print \" c.2.1) Initial Starting Current , Isd = %.2f A \"%(Isd_c)\n",
      "print \" c.2.2) Starting Torque , Tsd = %.2f Nm \"%(Tsd_c)\n",
      "print 'Comparing the Calculated values of starting current and torque eid rated frequency and rated voltage'\n",
      "print \"                            star                           delta\"\n",
      "print \"                   440V%(50Hz   44V%(5Hz             440V,50Hz   44V,5Hz \"\n",
      "print \" starting current     %.2f A     %.f A               %.f A       %.2f A \"%(Isy_a,Isy_c,Isd_a,Isd_c)\n",
      "print \" starting Torque      %.1f Nm   %.2f Nm             %.f Nm      %.2f Nm \"%(Tsy_a,Tsy_c,Tsd_a,Tsd_c)\n",
      "print \"    [ TEXT BOOK SOLUTION IS PRINTED WRONGLY  I verified by manual calculation ]\" ;\n",
      "print \"      WRONGLY PRINTED ANSWERS ARE :- For Case a.2) Winding is connected in delta :- a) Initial Starting Current Isy = 254.01 A instead of %.2f A  \"%(Isd_a); \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "EXAMPLE : 5.23 : SOLUTION :-\n",
        " For Case a.1 Winding is connected in star \n",
        " a.1.1) Per phase impedance seen from the terminals in Ohms, Z = 2.571 < 76.5 Ohms \n",
        " a.1.2) Initial Starting Current , Isy = 98.81 A \n",
        " a.1.3) Starting Torque , Tsy = 37.3 Nm \n",
        " For Case a.2 Winding is connected in delta \n",
        " a.2.1) Initial Starting Current , Isd = 296.42 A \n",
        " a.2.2) Starting Torque , Tsd = 111.88 Nm \n",
        " For Case b Machine is started umath.sing auto-transfromer and voltage is 50 percentage reduced :- b.1 Winding is connected in star  \n",
        " b.1.1) Per phase impedance seen from the terminals in Ohms, Z = 2.571<76.5 Ohms \n",
        " b.1.2) Initial Starting Current , Isy = 49.4 A \n",
        " b.1.3) Starting Torque , Tsy = 9.32 Nm \n",
        " For Case b.2 Winding is connected in delta \n",
        " b.2.1) Initial Starting Current , Isd = 148.21 A \n",
        " b.2.2) Starting Torque , Tsd = 28 Nm \n",
        " For Case c Both Voltage and Frequency are reduced to 50 percentage :- c.1 Winding is connected in star  \n",
        " c.1.1) Per phase impedance seen from the terminals in Ohms, Z =  0.65<22.62 Ohms \n",
        " c.1.2) Initial Starting Current , Isy = 39.08 A \n",
        " c.1.3) Starting Torque , Tsy = 58.34 Nm \n",
        " For Case c.2 Winding is connected in delta \n",
        " c.2.1) Initial Starting Current , Isd = 117.25 A \n",
        " c.2.2) Starting Torque , Tsd = 175.03 Nm \n",
        "Comparing the Calculated values of starting current and torque eid rated frequency and rated voltage\n",
        "                            star                           delta\n",
        "                   440V%(50Hz   44V%(5Hz             440V,50Hz   44V,5Hz \n",
        " starting current     98.81 A     39 A               296 A       117.25 A \n",
        " starting Torque      37.3 Nm   58.34 Nm             112 Nm      175.03 Nm \n",
        "    [ TEXT BOOK SOLUTION IS PRINTED WRONGLY  I verified by manual calculation ]\n",
        "      WRONGLY PRINTED ANSWERS ARE :- For Case a.2) Winding is connected in delta :- a) Initial Starting Current Isy = 254.01 A instead of 296.42 A  \n"
       ]
      }
     ],
     "prompt_number": 21
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 5.24  Page No : 264"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math \n",
      "from numpy import imag,real\n",
      "\n",
      "# GIVEN DATA\n",
      "m = 3;                          # Total Number of phase in Induction Motor\n",
      "f = 50;                         # Frequency in Hertz\n",
      "V = 440;                        # Operating voltage of the Induction Motor in Volts\n",
      "R1 = 0.2;                      # Circuit Parameter in Ohms\n",
      "R2 = 0.4;                      # Circuit Parameter in Ohms\n",
      "X1 = 1.0;                      # Circuit Parameter in Ohms\n",
      "X2 = 1.5;                      # Circuit Parameter in Ohms\n",
      "Rc = 150;                      # Circuit Parameter in Ohms\n",
      "Xm = 30;                       # Circuit Parameter in Ohms\n",
      "\n",
      "\n",
      "# CALCULATIONS\n",
      "\n",
      "V1 = V/math.sqrt(3);                                     # Rated Voltage in Volts\n",
      "Zdol = (R1+1j*X1)+(Rc*1j*Xm*(R2+1j*X2))/(Rc*1j*Xm+Rc*(R2+1j*X2)+(1j*Xm)*(R2+1j*X2));                                           # Equivalent impedance per phase in DOL starter in Ohms\n",
      "I = V1/Zdol;                                        # Starting Current in DOL starter in Amphere\n",
      "\n",
      "# For Case(a) A per Phase resistance of 0.5 Ohms is added in Series with the stator circuit\n",
      "\n",
      "Zsr =  (0.5+R1+1j*X1)+((Rc*1j*Xm*(R2+1j*X2))/((Rc*1j*Xm+Rc*(R2+1j*X2)+(1j*Xm)*(R2+1j*X2))));                                     # Total impedance seen from the terminals in Ohms\n",
      "Isr = V1/Zsr;                                         # Starting Current in DOL starter in Amphere\n",
      "\n",
      "# For Case(b) A per Phase resistance of 0.5 Ohms is added in Series with the rotor circuit here assumed that stator to rotor turn ratio is 1.0\n",
      "\n",
      "Zrr =  (R1+1j*X1)+((Rc*1j*Xm*(0.5+R2+1j*X2))/(Rc*1j*Xm+Rc*(0.5+R2+1j*X2)+(1j*Xm)*(0.5+R2+1j*X2)));                            # Total impedance seen from the terminals in Ohms\n",
      "Irr = V1/Zrr;                                      # Starting Current in DOL starter in Amphere\n",
      "\n",
      "# For Case(c) When applied Voltage reduced to 50%\n",
      "\n",
      "I_c = (0.5*V1)/Zdol;                                # Starting Current in DOL starter in Amphere\n",
      "\n",
      "# For Case(d) When Motor is supplied by reduced Voltage of 44V ( Voltage is reduced by 10%) and the reduced frequency is 5Hz\n",
      "\n",
      "f_n = 5;                                          # Reduced Frequency in Hertz\n",
      "X1_n = (f_n/f)*X1;                                # Changed Circuit Parameter in Ohms\n",
      "X2_n = (f_n/f)*X2;                                # Changed Circuit Parameter in Ohms\n",
      "Xm_n = (f_n/f)*Xm;                                # Changed Circuit Parameter in Ohms\n",
      "Zdol_n = (R1+1j*X1_n)+((Rc*1j*Xm_n*(R2+1j*X2_n))/(Rc*1j*Xm_n+Rc*(R2+1j*X2_n)+(1j*Xm_n)*(R2+1j*X2_n)));                         # Equivalent impedance per phase in DOL starter in Ohms\n",
      "I_n = (V1*0.1)/Zdol_n;                            # Starting Current in DOL starter in Amphere\n",
      "Ratio = abs(I_n)/abs(I);                          # Ratio of the Starting Current witha the rated Voltage and frequency to the reduced Voltage and frequency\n",
      "\n",
      "\n",
      "# DISPLAY RESULTS\n",
      "\n",
      "print (\"EXAMPLE : 5.24 : SOLUTION :-\");\n",
      "print \" Normal Initial Starting Current in DOL starter, I = %.1f <%.1f A \"%(abs(I),math.degrees(math.atan2(I.imag,I.real)))\n",
      "print \" For Casea A per Phase resistance of 0.5 Ohms is added in Series with the stator circuit \"\n",
      "print \"              Initial Starting Current in DOL starter, I = %.1f <%.2f A \"%(abs(Isr),math.degrees(math.atan2(Isr.imag,Isr.real)))\n",
      "print \"  For Caseb A per Phase resistance of 0.5 Ohms is added in Series with the rotor circuit \"\n",
      "print \"              Initial Starting Current in DOL starter, I = %.2f <%.1f A \"%(abs(Irr),math.degrees(math.atan2(Irr.imag,Irr.real)))\n",
      "print \"  For Casec When applied Voltage reduced to 50 percentage \"\n",
      "print \"              Initial Starting Current in DOL starter, I = %.2f <%.1f A \"%(abs(I_c),math.degrees(math.atan2(I_c.imag,I_c.real)))\n",
      "print \"  For Cased When Motor is supplied by reduced Voltage of 44V  Voltage is reduced by 10 percenatge  and the reduced frequency is 5Hz \"\n",
      "print \"              Initial Starting Current in DOL starter, I = %.1f <%.1f A \"%(abs(I_n),math.degrees(math.atan2(I_n.imag,I_n.real)))\n",
      "print \" By reducing volatge as well as the frequency, the peak starting current at the insmath.tant os starting is reduced by a fector of %.4f of the starting current with the reted volatge and frequency \"%(Ratio)\n",
      "print \"    [ TEXT BOOK SOLUTION IS PRINTED WRONGLY  I verified by manual calculation ]\" ;\n",
      "print \"      WRONGLY PRINTED ANSWERS ARE :- For Cased) When Motor is supplied by reduced Voltage of 44V  Voltage is reduced by 10 percenatge ) and the reduced frequency is 5Hz,  I = 24.1 < 25.6 A instead of %.1f < %.2f) A  \"%(abs(I_n),math.degrees(math.atan2(I_n.imag,I_n.imag)));\n",
      "print \"  Ratio of the Starting Current with the rated Voltage and frequency to the reduced Voltage and frequency, Ratio = 0.2518 instead of %.4f  \"%(Ratio);\n",
      "\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "EXAMPLE : 5.24 : SOLUTION :-\n",
        " Normal Initial Starting Current in DOL starter, I = 101.9 <-76.7 A \n",
        " For Casea A per Phase resistance of 0.5 Ohms is added in Series with the stator circuit \n",
        "              Initial Starting Current in DOL starter, I = 95.7 <-66.09 A \n",
        "  For Caseb A per Phase resistance of 0.5 Ohms is added in Series with the rotor circuit \n",
        "              Initial Starting Current in DOL starter, I = 96.12 <-67.2 A \n",
        "  For Casec When applied Voltage reduced to 50 percentage \n",
        "              Initial Starting Current in DOL starter, I = 50.94 <-76.7 A \n",
        "  For Cased When Motor is supplied by reduced Voltage of 44V  Voltage is reduced by 10 percenatge  and the reduced frequency is 5Hz \n",
        "              Initial Starting Current in DOL starter, I = 127.0 <0.0 A \n",
        " By reducing volatge as well as the frequency, the peak starting current at the insmath.tant os starting is reduced by a fector of 1.2467 of the starting current with the reted volatge and frequency \n",
        "    [ TEXT BOOK SOLUTION IS PRINTED WRONGLY  I verified by manual calculation ]\n",
        "      WRONGLY PRINTED ANSWERS ARE :- For Cased) When Motor is supplied by reduced Voltage of 44V  Voltage is reduced by 10 percenatge ) and the reduced frequency is 5Hz,  I = 24.1 < 25.6 A instead of 127.0 < 0.00) A  \n",
        "  Ratio of the Starting Current with the rated Voltage and frequency to the reduced Voltage and frequency, Ratio = 0.2518 instead of 1.2467  \n"
       ]
      }
     ],
     "prompt_number": 22
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 5.25  Page No : 267"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math \n",
      "\n",
      "# GIVEN DATA\n",
      "\n",
      "m1 = 3;                          # Total Number of phase in 1st Induction Motor\n",
      "p1 = 6;                          # Total number of Poles of 1st Induction Motor\n",
      "f = 50;                          # Frequency in Hertz\n",
      "m2 = 3;                          # Total Number of phase in 2nd Induction Motor\n",
      "p2 = 10;                         # Total number of Poles of 2nd Induction Motor\n",
      "\n",
      "\n",
      "# CALCULATIONS \n",
      "\n",
      "Ns1 = (120*f)/p1;                           # Synchronous speed of 1st Induction Motor in RPM\n",
      "Ns2 = (120*f)/p2;                           # Synchronous speed of 2nd Induction Motor in RPM\n",
      "Nscu = (120*f)/(p1+p2);                     # Speed during cumalative casade in RPM\n",
      "Ndiff = (120*f)/(p2-p1);                    # Speed during cumalative casade in RPM\n",
      "\n",
      "\n",
      "# DISPLAY RESULTS\n",
      "\n",
      "print (\"EXAMPLE : 5.25 : SOLUTION :-\");\n",
      "print \" a)  Range of speed is %.f - %.f - %.f - %.f RPM \"%(Nscu,Ns2,Ns1,Ndiff)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "EXAMPLE : 5.25 : SOLUTION :-\n",
        " a)  Range of speed is 375 - 600 - 1000 - 1500 RPM \n"
       ]
      }
     ],
     "prompt_number": 23
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 5.26  Page No : 271"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math \n",
      "from numpy import real,imag\n",
      "\n",
      "# GIVEN DATA\n",
      "\n",
      "m = 3;                          # Total Number of phase in Induction Motor\n",
      "p = 4;                          # Total number of Poles of Induction Motor\n",
      "f = 50;                         # Frequency in Hertz\n",
      "V = 440;                        # Operating Voltage of the Inductuon Motor\n",
      "R1 = 0.25;                      # Circuit Parameter in Ohms\n",
      "R2 = 0.5;                       # Circuit Parameter in Ohms\n",
      "X1 = 1.5;                       # Circuit Parameter in Ohms\n",
      "X2 = 1.5;                       # Circuit Parameter in Ohms\n",
      "\n",
      "\n",
      "# CALCULATIONS\n",
      "\n",
      "Vph = V/math.sqrt(3);                                    # Per phase Voltage in Volts\n",
      "Ns = (120.*f)/p;                                     # Synchoronous Speed in RPM\n",
      "Ws = (2.*math.pi*Ns)/60.;                                 # Roatation Speed in Radians per Seconds\n",
      "\n",
      "# For Case (a) Machine running at, N = 1400 RPM\n",
      "\n",
      "N_a = 1400.;                                         # Machine running in RPM\n",
      "s_a = (Ns-N_a)/Ns;                                  # Slip\n",
      "I_2_a = Vph/(R1+(R2/s_a)+(1j*(X1+X2)));             # Rotor per phase Current referred to the stator side in Amphere\n",
      "Pg_a = 3*(abs(I_2_a)**2*R2)/s_a;                     # 3-phase air gap power or Rotor intake Power in Watts\n",
      "T_a = Pg_a/Ws;                                      # Torque in Newton-Meter\n",
      "\n",
      "# For Case (b) Machine running at, N = 1600 RPM\n",
      "\n",
      "N_b = 1600;                                         # Machine running in RPM\n",
      "s_b = (Ns-N_b)/Ns;                                  # Slip\n",
      "I_2_b = Vph/(R1+(R2/s_b)+(1j*(X1+X2)));             # Rotor per phase Current referred to the stator side in Amphere\n",
      "Pg_b = 3*(abs(I_2_b)**2*R2)/s_b;                     # 3-phase air gap power or Rotor intake Power in Watts\n",
      "T_b = Pg_b/Ws;                                      # Torque in Newton-Meter\n",
      "\n",
      "# For Case (b) Machine running at, N = -100 RPM\n",
      "\n",
      "N_c = -100;                                         # Machine running in RPM\n",
      "s_c = (Ns-N_c)/Ns;                                  # Slip\n",
      "I_2_c = Vph/(R1+(R2/s_c)+(1j*(X1+X2)));             # Rotor per phase Current referred to the stator side in Amphere\n",
      "Pg_c = 3*(abs(I_2_c)**2*R2)/s_c;                     # 3-phase air gap power or Rotor intake Power in Watts\n",
      "T_c = -Pg_c/Ws;                                      # Torque in Newton-Meter (minus sign because its counter oppomath.sing torque)\n",
      "\n",
      "# DISPLAY RESULTS\n",
      "\n",
      "print (\"EXAMPLE : 5.26 : SOLUTION :-\");\n",
      "print \" For Case a) Machine running at, N = 1400 RPM  \"\n",
      "print \" a.1) Rotor per phase Current referred to the stator side, I2 = %.2f < %.2f A \"%(abs(I_2_a),math.degrees(math.atan2(I_2_a.imag,real(I_2_a))))\n",
      "print \" a.2) Developed Torque, T = %.2f Nm \"%(T_a)\n",
      "print \" For Case b) Machine running at, N = 1600 RPM  \"\n",
      "print \" a.1) Rotor per phase Current referred to the stator side, I2 = %.2f < %.2f A \"%(abs(I_2_b),math.degrees(math.atan2(I_2_b.imag,real(I_2_b))))\n",
      "print \"   ( angle -157.52 + 180 = 22.48 ) \"\n",
      "print \" a.2) Developed Torque, T = %.2f Nm \"%(T_b)\n",
      "print \" For Case c) Machine running at, N = -100 RPM  \"\n",
      "print \" c.1) Rotor per phase Current referred to the stator side, I2 = %.2f < %.2f A \"%(abs(I_2_c),math.degrees(math.atan2(I_2_c.imag,real(I_2_c))))\n",
      "print \" c.2) Developed Torque, T = %.2f Nm \"%(T_c)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "EXAMPLE : 5.26 : SOLUTION :-\n",
        " For Case a) Machine running at, N = 1400 RPM  \n",
        " a.1) Rotor per phase Current referred to the stator side, I2 = 30.57 < -21.16 A \n",
        " a.2) Developed Torque, T = 133.85 Nm \n",
        " For Case b) Machine running at, N = 1600 RPM  \n",
        " a.1) Rotor per phase Current referred to the stator side, I2 = 32.38 < -157.52 A \n",
        "   ( angle -157.52 + 180 = 22.48 ) \n",
        " a.2) Developed Torque, T = -150.15 Nm \n",
        " For Case c) Machine running at, N = -100 RPM  \n",
        " c.1) Rotor per phase Current referred to the stator side, I2 = 82.35 < -76.53 A \n",
        " c.2) Developed Torque, T = -60.71 Nm \n"
       ]
      }
     ],
     "prompt_number": 24
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 5.27  Page No : 275"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math \n",
      "\n",
      "# GIVEN DATA\n",
      "\n",
      "m = 3.;                          # Total Number of phase in Induction Motor\n",
      "p = 2.;                          # Total number of Poles of Induction Motor\n",
      "f = 50.;                         # Frequency in Hertz\n",
      "V = 440.;                        # Operating Voltage of the Inductuon Motor\n",
      "R1 = 0.25;                      # Circuit Parameter in Ohms\n",
      "R2 = 0.25;                      # Circuit Parameter in Ohms\n",
      "X1 = 0.75;                      # Circuit Parameter in Ohms\n",
      "X2 = 0.75;                      # Circuit Parameter in Ohms\n",
      "out_hp = 50.;                    # Output of the induction motor in HP\n",
      "\n",
      "\n",
      "# CALCULATIONS\n",
      "\n",
      "V1 = V/math.sqrt(3);                                              # Phase Voltage in Volts\n",
      "I = (out_hp*746.)/(V*math.sqrt(3));                                # Rated Current in Amphere\n",
      "sm = R2/(math.sqrt(R1**2+(X1+X2)**2));                              # Slip at Maximum torque both its in Positive and negative sign\n",
      "Ws = 2*math.pi*((120.*f/p)*(1./60.));                               # Angular Roatation in Radians per Seconds\n",
      "Tm = (3*V1**2)/((2*Ws)*(R1+math.sqrt((R1**2)+(X1+X2)**2)));          # Maximum torque during motoring in Newton-Meter\n",
      "Tg = -(3*V1**2)/((2*Ws)*(-R1+math.sqrt((R1**2)+(X1+X2)**2)));        # Maximum torque during generating in Newton-Meter\n",
      "\n",
      "# For Case (a) slip = 0.05\n",
      "\n",
      "s_a = 0.05;                                                  # Slip\n",
      "T_a = (2*Tm)/((s_a/sm)+(sm/s_a));                            # Torque in Newton-Meter\n",
      "\n",
      "# For Case (b) slip = -0.05\n",
      "\n",
      "s_b = -0.05;                                                  # Slip\n",
      "T_b = (2*Tg)/((s_b/sm)+(sm/s_b));                             # Torque in Newton-Meter\n",
      "\n",
      "\n",
      "# DISPLAY RESULTS\n",
      "\n",
      "print (\"EXAMPLE : 5.27 : SOLUTION :-\");\n",
      "print \" Maximim Torque during Motoring Tm = %.f N-m \"%(Tm)\n",
      "print \" Maximim Torque during Generating Tm = %.2f N-m \"%(Tg)\n",
      "print \" For Case a slip = 0.05  \"\n",
      "print \" a.1) Torque, T = %.2f Nm \"%(T_a)\n",
      "print \" For Case b slip = -0.05  \"\n",
      "print \" b.1) Torque, T = %.2f Nm \"%(T_b)\n",
      "\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "EXAMPLE : 5.27 : SOLUTION :-\n",
        " Maximim Torque during Motoring Tm = 174 N-m \n",
        " Maximim Torque during Generating Tm = -242.49 N-m \n",
        " For Case a slip = 0.05  \n",
        " a.1) Torque, T = 96.89 Nm \n",
        " For Case b slip = -0.05  \n",
        " b.1) Torque, T = 135.01 Nm \n"
       ]
      }
     ],
     "prompt_number": 25
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 5.28  Page No : 277"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math \n",
      "\n",
      "# GIVEN DATA\n",
      "\n",
      "m = 3;                          # Total Number of phase in Induction Motor\n",
      "p = 2;                          # Total number of Poles of Induction Motor\n",
      "f = 50;                         # Frequency in Hertz\n",
      "V = 440;                        # Operating Voltage of the Inductuon Motor in Volts\n",
      "R0 = 0.5;                       # Circuit Parameter in Ohms\n",
      "Ri = 0.05;                      # Circuit Parameter in Ohms\n",
      "X0 = 0.2;                       # Circuit Parameter in Ohms\n",
      "Xi = 0.9;                       # Circuit Parameter in Ohms\n",
      "s = 0.07;                       # Slip\n",
      "\n",
      "\n",
      "# CALCULATIONS\n",
      "\n",
      "Ws = 2*math.pi*f;                                               # Synchronous speed in Radins per second\n",
      "v = V/math.sqrt(3);                                              # Phase Voltage in Volts\n",
      "Io = v/(R0+1j*X0);                                          # Starting Current in the outer cage in Amphere\n",
      "Ii = v/(Ri+1j*Xi);                                          # Starting Current in the inner cage in Amphere\n",
      "Tst = ((3*abs(Io)**2*R0)/Ws)+((3*abs(Ii)**2*Ri)/Ws);          # Starting torque i.e at smath.degrees(math.atanstill, s=1\n",
      "Ios = v/((R0/s)+(1j*X0));                                   # Current in the outer cage at slip = 0.07\n",
      "Iis = v/((Ri/s)+(1j*Xi));                                   # Current in the outer cage at slip = 0.07\n",
      "T = ((3*abs(Ios)**2*R0)/(s*Ws))+((3*abs(Iis)**2*Ri)/(s*Ws));          # Starting torque at s=0.07 in Newton-Meter\n",
      "\n",
      "\n",
      "# DISPLAY RESULTS\n",
      "\n",
      "print (\"EXAMPLE : 5.28 : SOLUTION :-\");\n",
      "print \" a) Starting torque Tst = %.2f Nm \"%(Tst)\n",
      "print \" b) Running torque at slip = 0.07 T = %.2f Nm \"%(T)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "EXAMPLE : 5.28 : SOLUTION :-\n",
        " a) Starting torque Tst = 1100.42 Nm \n",
        " b) Running torque at slip = 0.07 T = 419.62 Nm \n"
       ]
      }
     ],
     "prompt_number": 26
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 5.29  Page No : 278"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math \n",
      "\n",
      "\n",
      "# GIVEN DATA\n",
      "\n",
      "p = 4;                          # Total number of Poles of Induction Motor\n",
      "f = 50;                         # Frequency in Hertz\n",
      "V = 440;                        # Operating Voltage of the Inductuon Motor in Volts\n",
      "out = 25*1000;                  # Power rating of the Induction motor in Watts\n",
      "R0 = 2.5;                       # Circuit Parameter in Ohms\n",
      "Ri = 0.5;                       # Circuit Parameter in Ohms\n",
      "X0 = 1.0;                       # Circuit Parameter in Ohms\n",
      "Xi = 5.0;                       # Circuit Parameter in Ohms\n",
      "Rc = 500;                       # Circuit Parameter in Ohms\n",
      "R1 = 0.2;                       # Circuit Parameter in Ohms\n",
      "Xm = 50;                        # Circuit Parameter in Ohms\n",
      "X123 = 2.0;                     # Circuit Parameter in Ohms\n",
      "s = 0.05;                       # Slip\n",
      "\n",
      "\n",
      "# CALCULATIONS\n",
      "\n",
      "Ws = (2*math.pi*120*f)/(p*60);                                # Synchronous speed in Radins per second\n",
      "Zo = (R0/s)+(1j*X0);                                      # Outer cage impedance at slip = 0.05 in Ohms\n",
      "Zi = (Ri/s)+(1j*Xi);                                      # Inner cage impedance at slip = 0.05 in Ohms\n",
      "Z = (R1+1j*X123)+((Zo*Zi)/(Zo+Zi));                       # Total impdance in Ohms\n",
      "I = V/Z;                                                  # Current in the Cage winding in Amphere\n",
      "Io = (I*((Zo*Zi)/(Zo+Zi)))/Zo;                            # Current in the outer cage in Amphere\n",
      "Ii = (I*((Zo*Zi)/(Zo+Zi)))/Zi;                            # Current in the inner cage in Amphere\n",
      "T = ((3*abs(Io)**2*R0)/(s*Ws))+((3*abs(Ii)**2*Ri)/(s*Ws));  # Starting torque in Newton-Meter\n",
      "\n",
      "\n",
      "# DISPLAY RESULTS\n",
      "\n",
      "print (\"EXAMPLE : 5.29 : SOLUTION :-\");\n",
      "print \" a) Torque at slip %.2f T = %.2f Nm \"%(s,T)\n",
      "\n",
      "\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "EXAMPLE : 5.29 : SOLUTION :-\n",
        " a) Torque at slip 0.05 T = 296.11 Nm \n"
       ]
      }
     ],
     "prompt_number": 27
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 5.30  Page No : 282"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math \n",
      "from numpy import real,imag\n",
      "\n",
      "# GIVEN DATA\n",
      "\n",
      "m = 1;                          # Total Number of phase in Induction Motor\n",
      "p = 2;                          # Total number of Poles of Induction Motor\n",
      "f = 50;                         # Frequency in Hertz\n",
      "V = 220;                        # Operating Voltage of the Inductuon Motor in Volts\n",
      "R1 = 10;                        # Circuit Parameter in Ohms\n",
      "R2 = 11;                        # Circuit Parameter in Ohms\n",
      "X1 = 12;                        # Circuit Parameter in Ohms\n",
      "X2 = 12;                        # Circuit Parameter in Ohms\n",
      "Xm = 125;                       # Circuit Parameter in Ohms\n",
      "s = 0.03;                       # Slip\n",
      "\n",
      "\n",
      "# CALCULATIONS\n",
      "\n",
      "Zf = ((1j*Xm/2)*((R2/(2*s))+(1j*X2/2)))/((1j*Xm/2)+(R2/(2*s))+(1j*X2/2));               # Impedance offered by the forward field in Ohms\n",
      "Zb = ((1j*Xm/2)*((R2/(2*(2-s)))+(1j*X2/2)))/((1j*Xm/2)+(R2/(2*(2-s)))+(1j*X2/2));       # Impedance offered by the backward field in Ohms \n",
      "Z = (R1+1j*X1)+Zf+Zb;                               # Total Impedance in Ohms\n",
      "I = V/Z;                                            # Total input current in Amphere\n",
      "pf = math.cos(math.radians(math.degrees(math.atan2(I.imag,I.real))));                  # Power Factor (lagging)\n",
      "Vf = I*Zf;                                          # Forward Volatge at slip 0.03 in Volts\n",
      "Vb = I*Zb;                                          # Backward Volatge at slip 0.03 in Volts\n",
      "If = Vf/(0.5*R2/s);                                 # Forward Current in Amphere\n",
      "Ib = Vb/(0.5*R2/(2-s));                             # Forward Current in Amphere\n",
      "Ws = 2*math.pi*f;                                       # Synchronous Speed in radians per second\n",
      "T =  ((0.5*(If**2)*R2)/(s*Ws))-((0.5*(Ib**2)*R2)/((2-s)*Ws));          # Starting torque\n",
      "\n",
      "\n",
      "# DISPLAY RESULTS\n",
      "\n",
      "print (\"EXAMPLE : 5.30 : SOLUTION :-\");\n",
      "print \" a) Input Current, I = %.2f < %.f A \"%(abs(I),math.degrees(math.atan2(I.imag,I.real)))\n",
      "print \" b) Power factor, pf = %.2f Lagging \"%(pf)\n",
      "print \" c) Developed Torque, T = %.3f Nm \"%(T.real)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "EXAMPLE : 5.30 : SOLUTION :-\n",
        " a) Input Current, I = 2.77 < -67 A \n",
        " b) Power factor, pf = 0.39 Lagging \n",
        " c) Developed Torque, T = 0.134 Nm \n"
       ]
      }
     ],
     "prompt_number": 28
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 5.31  Page No : 287"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math \n",
      "from numpy import real,imag\n",
      "\n",
      "# GIVEN DATA\n",
      "\n",
      "Wsc = 900;                     # Power at Blocked Rotor test in Watts\n",
      "Vsc = 200;                     # Voltage at Blocked Rotor test in Volts\n",
      "Isc = 5.0;                     # Current at Blocked Rotor test in Amphere\n",
      "Wo = 60;                       # Power at No-load test in Watts\n",
      "Vo = 220;                      # Voltage at No-load test in Volts\n",
      "Io = 1.5;                      # Current at No-load test in Amphere \n",
      "m = 1;                         # Total Number of phase in Induction Motor\n",
      "p = 4;                         # Total number of Poles of Induction Motor\n",
      "V = 220;                       # Operating voltage of the Induction motor in Volts\n",
      "f = 50;                        # Frequency in Hertz\n",
      "s = 0.07;                      # Slip\n",
      "R1 = 12;                       # resistance of the main primary winding in Ohms\n",
      "\n",
      "\n",
      "# CALCULATIONS\n",
      "\n",
      "Zsc = Vsc/Isc;                      # Impedance in Blocked Rotor test in Ohms\n",
      "Rsc = Wsc/(Isc**2);                  # resistance in Blocked Rotor test in Ohms\n",
      "Xsc = math.sqrt((Zsc**2)-(Rsc**2));        # reactance in Blocked Rotor test in Ohms\n",
      "Xl1 = Xsc/2;                        # Leakage reactance of stator and rotor to be equal in Ohms\n",
      "Xl2 = Xsc/2;                        # Leakage reactance of stator and rotor to be equal in Ohms\n",
      "R2 = Rsc-R1;                    # Equivalent resistance of rotor referred to stator in Ohms\n",
      "Z0 = Vo/Io;                         # Impedance in Blocked Rotor test in Ohms\n",
      "R0 = Wo/(Io**2);                     # resistance in Blocked Rotor test in Ohms\n",
      "X0 = math.sqrt((Z0**2)-(R0**2));           # reactance in Blocked Rotor test in Ohms\n",
      "Wloss = Wo - ((Io**2)*(R1+R2));      # Loss in Watts\n",
      "Xm_half = X0-Xl1-Xl2/2;\n",
      "R2f = (R2/s)+((1j*Xl2)/2);                             # Forward resiamath.tance in Ohms\n",
      "Zf = ((1j*Xm_half)*R2f)/(1j*Xm_half+R2f);              # Total Forward impedance in Ohms\n",
      "R2b = (R2/(2-s))+((1j*Xl2)/2);                         # Backward resiamath.tance in Ohms\n",
      "Zb = ((1j*Xm_half)*R2b)/(1j*Xm_half+R2b);              # Total Backward impedance in Ohms\n",
      "Z = Zf+Zb+(R1+1j*Xl1);                                 # Total impedance in Ohms\n",
      "I = V/Z;                                               # Motor Current in Amphere\n",
      "pf = math.cos(math.radians(math.degrees(math.atan2(I.imag,I.real))));                      # Power Factor (lagging)\n",
      "\n",
      "\n",
      "# DISPLAY RESULTS\n",
      "\n",
      "print (\"EXAMPLE : 5.31 : SOLUTION :-\");\n",
      "print \" Circuit Parameters are  a) Leakage reactance of stator and rotor to be equal, Xl1 = Xl2 = %.2f Ohms \"%(Xl1)\n",
      "print \" b) Equivalent resistance of rotor referred to stator, R2 = %.f Ohms \"%(R2)\n",
      "print \" c) Total Forward impedance, Zf = %.1f < %.2f Ohms \"%(abs(Zf),math.degrees(math.atan2(Zf.imag,Zf.real)))\n",
      "print \" c) Total Backward impedance, Zb = %.2f < %.2f Ohms \"%(abs(Zb),math.degrees(math.atan2(Zb.imag,Zb.real)))\n",
      "print \" d) Total impedance, Z = %.2f < %.2f Ohms \"%(abs(Z),math.degrees(math.atan2(Z.imag,Z.real)))\n",
      "print \" e) Input Current, I = %.2f < %.2f A \"%(abs(I),math.degrees(math.atan2(I.imag,I.real)))\n",
      "print \" f) Power factor, pf = %.2f Lagging \"%(pf)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "EXAMPLE : 5.31 : SOLUTION :-\n",
        " Circuit Parameters are  a) Leakage reactance of stator and rotor to be equal, Xl1 = Xl2 = 8.72 Ohms \n",
        " b) Equivalent resistance of rotor referred to stator, R2 = 24 Ohms \n",
        " c) Total Forward impedance, Zf = 122.0 < 69.16 Ohms \n",
        " c) Total Backward impedance, Zb = 12.70 < 24.56 Ohms \n",
        " d) Total impedance, Z = 144.44 < 62.39 Ohms \n",
        " e) Input Current, I = 1.52 < -62.39 A \n",
        " f) Power factor, pf = 0.46 Lagging \n"
       ]
      }
     ],
     "prompt_number": 29
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 5.32  Page No : 288"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math \n",
      "from numpy import imag,real\n",
      "\n",
      "# GIVEN DATA\n",
      "\n",
      "Wsc = 600;                     # Power at Blocked Rotor test in Watts\n",
      "Vsc = 125;                     # Voltage at Blocked Rotor test in Volts\n",
      "Isc = 15.0;                    # Current at Blocked Rotor test in Amphere\n",
      "Wo = 360;                      # Power at No-load test in Watts\n",
      "Vo = 220;                      # Voltage at No-load test in Volts\n",
      "Io = 6.5;                      # Current at No-load test in Amphere \n",
      "m = 1;                         # Total Number of phase in Induction Motor\n",
      "p = 4;                         # Total number of Poles of Induction Motor\n",
      "V = 220;                       # Operating voltage of the Induction motor in Volts\n",
      "f = 50;                        # Frequency in Hertz\n",
      "s = 0.05;                      # Slip\n",
      "R1 = 1.2;                      # resistance of the main primary winding in Ohms\n",
      "\n",
      "\n",
      "# CALCULATIONS\n",
      "\n",
      "Zlr = Vsc/Isc;                      # Impedance in Blocked Rotor test in Ohms\n",
      "Rlr = Wsc/(Isc**2);                  # resistance in Blocked Rotor test in Ohms\n",
      "Xlr = math.sqrt((Zlr**2)-(Rlr**2));        # reactance in Blocked Rotor test in Ohms\n",
      "Xl1 = Xlr/2;                        # Leakage reactance of stator and rotor to be equal in Ohms\n",
      "Xl2 = Xlr/2;                        # Leakage reactance of stator and rotor to be equal in Ohms\n",
      "R2 = (Rlr-R1);                      # Equivalent resistance of rotor referred to stator in Ohms\n",
      "R2_half = R2/2;                     # Equivalent resistance of rotor referred to stator in Ohms\n",
      "Z0 = Vo/Io;                         # Impedance in Blocked Rotor test in Ohms\n",
      "R0 = Wo/(Io**2);                     # resistance in Blocked Rotor test in Ohms\n",
      "X0 = math.sqrt((Z0**2)-(R0**2));           # reactance in Blocked Rotor test in Ohms\n",
      "Wloss = Wo - ((Io**2)*(R1+R2));      # Loss in Watts\n",
      "Xm_half = X0-Xl1-Xl2/2;\n",
      "R2f = (R2/(2*s))+((1j*Xl2)/2);                         # Forward resiamath.tance in Ohms\n",
      "Zf = ((1j*Xm_half)*R2f)/(1j*Xm_half+R2f);              # Total Forward impedance in Ohms\n",
      "R2b = (R2/(2*(2-s)))+((1j*Xl2)/2);                     # Backward resiamath.tance in Ohms\n",
      "Zb = ((1j*Xm_half)*R2b)/(1j*Xm_half+R2b);              # Total Backward impedance in Ohms\n",
      "Z = Zf+Zb+(R1+1j*Xl1);                                 # Total impedance in Ohms\n",
      "I = V/Z;                                               # Motor Current in Amphere\n",
      "pf = math.cos(math.radians(math.degrees(math.atan2(I.imag,I.real))));                     # Power Factor (lagging)\n",
      "Vf = I*Zf;                                             # Voltage across forward impedance in Volts\n",
      "If = Vf/R2f;                                           # Forward current producing torque in Amphere\n",
      "Tf = ((abs(If)**2)*R2)/(2*s);                           # Forward torque in synchronous Watts\n",
      "Vb = I*Zb;                                             # Voltage across Backward impedance in Volts\n",
      "Ib = Vb/R2b;                                           # Backward current producing torque in Amphere\n",
      "Tb = ((abs(Ib)**2)*R2)/(2*(2-s));                       # Backward torque in synchronous Watts\n",
      "T = Tf-Tb;                                             # Net torque in Synchronous Watts\n",
      "\n",
      "\n",
      "# DISPLAY RESULTS\n",
      "\n",
      "print (\"EXAMPLE : 5.32 : SOLUTION :-\");\n",
      "print \" Circuit Parameters are  a) Leakage reactance of stator and rotor to be equal, Xl1 = Xl2 = %.2f Ohms \"%(Xl1)\n",
      "print \" b) Equivalent resistance of rotor referred to stator,R2 = %.2f Ohms \"%(R2)\n",
      "print \" c) Total Forward impedance, Zf = %.1f < %.2f Ohms \"%(abs(Zf),math.degrees(math.atan2(Zf.imag,Zf.real)))\n",
      "print \" c) Total Backward impedance, Zb = %.2f < %.2f Ohms \"%(abs(Zb),math.degrees(math.atan2(Zb.imag,Zb.real)))\n",
      "print \" d) Total impedance, Z = %.2f < %.2f Ohms \"%(abs(Z),math.degrees(math.atan2(Z.imag,Z.real)))\n",
      "print \" e) Input Current, I = %.2f < %.f A \"%(abs(I),math.degrees(math.atan2(I.imag,I.real)))\n",
      "print \" f) Power factor, pf = %.4f Lagging \"%(pf)\n",
      "print \" g) Forward torque, Tf = %.2f Synchronous Watts \"%(Tf)\n",
      "print \" h) Backward torque, Tb = %.2f Synchronous Watts \"%(Tb)\n",
      "print \" i) Net torque, T = %.2f Synchronous Watts \"%(T)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "EXAMPLE : 5.32 : SOLUTION :-\n",
        " Circuit Parameters are  a) Leakage reactance of stator and rotor to be equal, Xl1 = Xl2 = 3.95 Ohms \n",
        " b) Equivalent resistance of rotor referred to stator,R2 = 1.47 Ohms \n",
        " c) Total Forward impedance, Zf = 12.3 < 34.65 Ohms \n",
        " c) Total Backward impedance, Zb = 1.87 < 79.96 Ohms \n",
        " d) Total impedance, Z = 17.28 < 47.68 Ohms \n",
        " e) Input Current, I = 12.73 < -48 A \n",
        " f) Power factor, pf = 0.6733 Lagging \n",
        " g) Forward torque, Tf = 1638.70 Synchronous Watts \n",
        " h) Backward torque, Tb = 52.90 Synchronous Watts \n",
        " i) Net torque, T = 1585.80 Synchronous Watts \n"
       ]
      }
     ],
     "prompt_number": 30
    }
   ],
   "metadata": {}
  }
 ]
}