{
 "metadata": {
  "name": ""
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Chapter 09 : Induction Machine"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 9.1, Page No 148"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "# to campute cu loss in rotoe windings, input to the motor, efficiency\n",
      "\n",
      "  \n",
      "f_s=120.0/60         #cycles/min\n",
      "f=50.0\n",
      "s=f_s/f \n",
      "n_s=1000.0 \n",
      "\n",
      "#Calculations\n",
      "n=(1-s)*n_s \n",
      "w=n*2*math.pi/60.0 \n",
      "T=160.0 \n",
      "P=T*w \n",
      "T_L=10 \n",
      "P_m=(T+T_L)*w \n",
      "cu=P_m*(s/(1.0-s))     \n",
      "print(cu,'rotor cu loss(W)') \n",
      "P_sl=800.0     #stator loss\n",
      "P_in=P_m+cu+P_sl     \n",
      "print(P_in,'power i/p to motor(W)') \n",
      "\n",
      "eff=P/P_in \n",
      "\n",
      "#Results\n",
      "print(eff*100.0,'efficiency(%)') "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(712.0943348136864, 'rotor cu loss(W)')\n",
        "(18602.358370342157, 'power i/p to motor(W)')\n",
        "(86.46728584706803, 'efficiency(%)')\n"
       ]
      }
     ],
     "prompt_number": 18
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 9.2, Page No 149"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to calculate torque,resitance to be added to rotor ckt\n",
      "\n",
      "f=50.0\n",
      "P=6.0 \n",
      "n_s=120.0*f/P \n",
      "w_s=2*math.pi*n_s/60 \n",
      "n=875.0 \n",
      "s_maxT=(n_s-n)/n_s \n",
      "R_2=.25 \n",
      "X_2=R_2/s_maxT \n",
      "T_max=10.0 \n",
      "#v=V/a\n",
      "\n",
      "#Calculations\n",
      "v=math.sqrt((T_max*w_s*X_2)/(3*.5)) \n",
      "T=((3.0)*v**2*(R_2/s))/(w_s*((R_2/s)**2+(X_2)**2)) \n",
      "print(T,'torque(Nm)') \n",
      "\n",
      "#from eqn(T_start/T_max)=(R2+Rext)*(X2/.5)/((R2+Rext)**2+X2**2)\n",
      "#after solving\n",
      "#Rt**2-6.67*Rt+4=0\n",
      "def quad(a,b,c):\n",
      "    d=math.sqrt(b**2-4*a*c)\n",
      "    x1=(-b+d)/(2*a) \n",
      "    x2=(-b-d)/(2*a) \n",
      "    if(x1>x2):\n",
      "        x=x2\n",
      "    else:\n",
      "        x=x1 \n",
      "    return x\n",
      "Rt=quad(1,-6.67,4) \n",
      "r2=.25 \n",
      "\n",
      "#Results\n",
      "print(Rt-r2,'external resistance(ohm)') \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(5.805515239477503, 'torque(Nm)')\n",
        "(0.41625029274006264, 'external resistance(ohm)')\n"
       ]
      }
     ],
     "prompt_number": 19
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 9.3, Page No 149"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to find slip at max torque,full load slip and rotor current at starting\n",
      "\n",
      "  \n",
      "#Tfl=(3/w_s)*(V**2*Rs/s_fl)/((R2/s_fl)**2+X2**2)     (i)\n",
      "#Ts=(3/w_s)*(V**2*R2)/(R2**2+X2**2)     (ii)\n",
      "#Tmax=(3/w_s)*(.5*V**2)/X2**2     (iii)\n",
      "#Tmax/Ts=2     k=R2/X2     (iii)/(ii)and solving\n",
      "#k**2-4*k+1=0 \n",
      "\n",
      "#Calculations\n",
      "def quad(a,b,c):\n",
      "    d=math.sqrt(b**2-4*a*c)\n",
      "    x1=(-b+d)/(2*a) \n",
      "    x2=(-b-d)/(2*a) \n",
      "    if(x1>x2):\n",
      "        x=x2\n",
      "    else:\n",
      "        x=x1 \n",
      "    return x\n",
      "k=quad(1,-4,1) \n",
      "print(k,'s_max_T') \n",
      "\n",
      "#(iii)/(i)and solving\n",
      "#s_fl**2-1.072*s_fl+.072=0\n",
      "s_fl=quad(1,-1.072,.072) \n",
      "print(s_fl,'s_fl') \n",
      "\n",
      "#a=I2_start/I2_fullload\n",
      "a=math.sqrt((k/s_fl)**2+1)/(k**2+1) \n",
      "\n",
      "#Results\n",
      "print(a,'I2_start/I2_fullload') "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(0.2679491924311228, 's_max_T')\n",
        "(0.07200000000000001, 's_fl')\n",
        "(3.59539147554005, 'I2_start/I2_fullload')\n"
       ]
      }
     ],
     "prompt_number": 20
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 9.5 Page No 150"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to determine ckt model parameters,parameters of thevenin equivalent, max torque and slip, stator current, pf and eff\n",
      "\n",
      "  \n",
      "j=math.sqrt(1.0) \n",
      "#NL test\n",
      "V=3300.0 \n",
      "f=50.0 \n",
      "Inl=5.0 \n",
      "Po=2500.0 \n",
      "Zo=V/(math.sqrt(3.0)*Inl) \n",
      "Ro=Po/(3*Inl**2) \n",
      "print(Ro,'Ro(ohm)') \n",
      "Xo=math.sqrt(Zo**2-Ro**2) \n",
      "print(Xo,'Xo(ohm)') \n",
      "#BR test\n",
      "V_BR=400.0 \n",
      "I_BR=27.0 \n",
      "ff=15.0 \n",
      "P_BR=15000.0\n",
      "\n",
      "#Calculations\n",
      "Z_BR=V_BR/(math.sqrt(3.0)*I_BR) \n",
      "R_BR=P_BR/(3*I_BR**2) \n",
      "X_BR=math.sqrt(Z_BR**2-R_BR**2) \n",
      "x1=X_BR/2     #at 15 Hz\n",
      "X1=x1*f/ff     #at 50Hz\n",
      "print(X1,'X1(ohm)') \n",
      "Xm=Xo-X1 \n",
      "print(Xm,'Xm(ohm)') \n",
      "R1=3.75 \n",
      "R2=(R_BR-R1)*((Xm+X1)/Xm)**2 \n",
      "print(R2,'R2(ohm)') \n",
      "\n",
      "V_TH=(V/math.sqrt(3))*complex(math.cos(math.radians(0)),math.sin(math.radians(0)))*complex(0,Xm)/complex(R1,X1+Xm) \n",
      "print(V_TH,'V_TH(V)') \n",
      "Z_TH=complex(0,Xm)*complex(R1,X1)/complex(R1,X1+Xm) \n",
      "print((Z_TH.real),'R_TH(ohm)') \n",
      "print((Z_TH.imag),'X_TH(ohm)') \n",
      "\n",
      "a=(math.sqrt((Z_TH.real)**2+(X1+(Z_TH.imag))**2)) \n",
      "s_max_T=R2/a \n",
      "n_s=1000.0\n",
      "Z_tot=complex((Z_TH.real)+a,X1+(Z_TH.imag)) \n",
      "I2=abs(V_TH)/abs(Z_tot) \n",
      "T_max=3*(I2**2)*R2/(s_max_T*(2*math.pi*n_s/60)) \n",
      "print(T_max,'T_max(Nm)') \n",
      "\n",
      "Z_f=complex(0,Xm)*complex(81.25,X1)/complex(81.25,X1+Xm) \n",
      "Z_in=Z_f+complex(R1,X1) \n",
      "I1=V/(math.sqrt(3)*abs(Z_in)) \n",
      "pf=math.cos(math.radians(math.degrees(math.atan((Z_in.imag)/(Z_in.real)))))\n",
      "s=.04 \n",
      "Pmechg=(1-s)*3*I1**2*(Z_f.real) \n",
      "Prot=Po-Inl**2*R1 \n",
      "Pip=math.sqrt(3.0)*V*I1*pf \n",
      "Pop=Pmechg-Prot \n",
      "eff=Pop/Pip \n",
      "print(eff,'efficiency') \n",
      "Tint=Pmechg/((1-s)*2*math.pi*n_s/60) \n",
      "\n",
      "#Results\n",
      "print(Tint,'internal torque developed(Nm)') "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(33.333333333333336, 'Ro(ohm)')\n",
        "(379.5904225463136, 'Xo(ohm)')\n",
        "(8.517574764607758, 'X1(ohm)')\n",
        "(371.07284778170583, 'Xm(ohm)')\n",
        "(3.2530626454410436, 'R2(ohm)')\n",
        "((1862.3223709107285+18.39801131985398j), 'V_TH(V)')\n",
        "(3.583247004147812, 'R_TH(ohm)')\n",
        "(8.36184927709782, 'X_TH(ohm)')\n",
        "(2384.194780011334, 'T_max(Nm)')\n",
        "(0.8935727897525297, 'efficiency')\n",
        "(1079.130406010449, 'internal torque developed(Nm)')\n"
       ]
      }
     ],
     "prompt_number": 21
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 9.6, Page No 151"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to calculate starting torque and current,full load current,pf, torque , internal and overall eff,slip and max torque\n",
      "\n",
      "  \n",
      "R1=.3 \n",
      "R2=.25 \n",
      "X1=.6 \n",
      "X2=.6 \n",
      "Xm=35 \n",
      "Prot=1500.0 \n",
      "V=231.0 \n",
      "Z_TH=complex(0,Xm)*complex(R1,X1)/complex(R1,X1+Xm) \n",
      "V_TH=(V*complex(0,Xm))/complex(R1,X1+Xm) \n",
      "n_s=1500.0 \n",
      "w_s=2*math.pi*n_s/60 \n",
      "\n",
      "s=1 \n",
      "Z_f=complex(0,Xm)*complex(R2,X2)/complex(R2,X2+Xm) \n",
      "R_f=(Z_f.real) \n",
      "Z_in=Z_f+complex(R1,X1) \n",
      "I1=V/abs(Z_in) \n",
      "print(I1,'starting current(A)') \n",
      "Tstart=3*I1**2*R_f/w_s \n",
      "print(Tstart,'starting torque(Nm)') \n",
      "\n",
      "n=1450.0 \n",
      "s=1-n/n_s \n",
      "a=R2/s \n",
      "Z_f=complex(0,Xm)*complex(a,X2)/complex(a,X2+Xm) \n",
      "R_f=(Z_f.real) \n",
      "Z_in=Z_f+complex(R1,X1) \n",
      "I1=V/abs(Z_in) \n",
      "print(I1,'full load current(A)') \n",
      "\n",
      "#Calculations\n",
      "pf=math.cos(math.radians(math.degrees(math.atan((Z_in.imag)/(Z_in.real)))))\n",
      "print(pf,'pf') \n",
      "P_G=3*I1**2*R_f \n",
      "Popg=P_G*(1-s) \n",
      "Pop=Popg-Prot \n",
      "Tnet=Pop/((1.0-s)*w_s) \n",
      "print(Tnet,'net torque(Nm)') \n",
      "Vt=400 \n",
      "Pip=math.sqrt(3)*Vt*I1*pf \n",
      "eff=Pop/Pip \n",
      "print(eff*100,'efficiency(%)') \n",
      "int_eff=Popg/Pip \n",
      "print(int_eff*100,'internal eff(%)') \n",
      "\n",
      "s_max_T=1/(math.sqrt((Z_TH.real)**2+((Z_TH.imag)+X1)**2)/R2) \n",
      "print(s_max_T,'max slip') \n",
      "Z_tot=Z_TH+complex(R2/s_max_T,X2) \n",
      "I2=abs(V_TH)/abs(Z_tot) \n",
      "T_max=3*I2**2*(R2/s_max_T)/w_s \n",
      "\n",
      "#Results\n",
      "print(T_max,'max torque(Nm)') \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(176.48305256673922, 'starting current(A)')\n",
        "(143.73484876981178, 'starting torque(Nm)')\n",
        "(29.954582094223984, 'full load current(A)')\n",
        "(0.9389975693602858, 'pf')\n",
        "(109.07162925039286, 'net torque(Nm)')\n",
        "(84.9884813377422, 'efficiency(%)')\n",
        "(92.6858609868727, 'internal eff(%)')\n",
        "(0.2037356745317859, 'max slip')\n",
        "(324.6427710199817, 'max torque(Nm)')\n"
       ]
      }
     ],
     "prompt_number": 22
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 9.9, Page No 152"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to determine the line current,pf, power ip, shaft torque, mech op and efficiency\n",
      "\n",
      "  \n",
      "R1=1.4 \n",
      "R2=.6 \n",
      "X1=2 \n",
      "X2=1 \n",
      "Xm=50.0 \n",
      "V=400.0 \n",
      "Prot=275.0 \n",
      "n_s=1000.0 \n",
      "\n",
      "#Calculations\n",
      "w_s=2*math.pi*n_s/60.0 \n",
      "\n",
      "print('slip=0.03') \n",
      "s=0.03 \n",
      "I2=(V/math.sqrt(3.0))/complex(R1+R2/s,X1+X2) \n",
      "Im=(V/math.sqrt(3.0))/(Xm*complex(math.cos(math.radians(90)),math.sin(math.radians(90)))) \n",
      "I1=Im+I2 \n",
      "I_L=abs(I1) \n",
      "print(I_L,'line current(A)') \n",
      "pf=math.cos(math.radians(math.degrees(math.atan((Z_in.imag)/(Z_in.real)))))\n",
      "print(pf,'pf') \n",
      "Pip=math.sqrt(3.0)*V*abs(I1)*math.cos(math.radians(math.degrees(math.atan((I1.imag)/(I1.real)))))\n",
      "print(Pip,'power i/p(W)') \n",
      "\n",
      "P_G=3*abs(I2)**2*R2/s \n",
      "Pmechg=(1-s)*P_G \n",
      "print(Pmechg,'mech power op(W)') \n",
      "Popnet=Pmechg-Prot \n",
      "Tnet=Popnet/(w_s*(1.0-s)) \n",
      "print(Tnet,'shaft torque(Nm)') \n",
      "eff=Popnet/Pip \n",
      "print(eff,'efficiency') \n",
      "\n",
      "print('slip= -0.03') \n",
      "s=-0.03 \n",
      "I2=(V/math.sqrt(3))/complex(R1+R2/s,X1+X2) \n",
      "Im=(V/math.sqrt(3))/(Xm*complex(math.cos(math.radians(90)),math.sin(math.radians(90)))) \n",
      "I1=-(Im+I2) \n",
      "I_L=abs(I1) \n",
      "print(I_L,'line current(A)') \n",
      "pf=math.cos(math.radians(math.degrees(math.atan((I1.imag)/(I1.real)))))\n",
      "print(pf,'pf') \n",
      "Pip=math.sqrt(3.0)*V*abs(I1)*math.cos(math.radians(math.degrees(math.atan((I1.imag)/(I1.real)))))\n",
      "print(Pip,'power i/p(W)') \n",
      "\n",
      "P_G=3*abs(I2)**2*R2/s \n",
      "Pmechop=(1-s)*P_G \n",
      "Pmechipnet=-Pmechop \n",
      "Pmechipg=Pmechipnet+Prot \n",
      "print(Pmechipg,'mech power op(W)') \n",
      "Tnet=Pmechipg/(w_s*(1-s)) \n",
      "print(Tnet,'shaft torque(Nm)') \n",
      "eff=Pip/Pmechipg \n",
      "print(eff,'efficiency') \n",
      "\n",
      "print('slip= 1.2') \n",
      "s=1.2 \n",
      "I2=(V/math.sqrt(3))/complex(R1+R2/s,X1+X2) \n",
      "Im=(V/math.sqrt(3))/(Xm*complex(math.cos(math.radians(90)),math.sin(math.radians(90)))) \n",
      "I1=Im+I2 \n",
      "I_L=abs(I1) \n",
      "print(I_L,'line current(A)') \n",
      "pf=math.cos(math.radians(math.degrees(math.atan((I1.imag)/(I1.real)))))\n",
      "print(pf,'pf') \n",
      "Pip=math.sqrt(3)*V*abs(I1)*pf \n",
      "print(Pip,'power i/p(W)') \n",
      "\n",
      "P_G=3*abs(I2)**2*.5/s \n",
      "Pmechg=(1-s)*P_G \n",
      "print(Pmechg,'mech power op(W)') \n",
      "Pmechabs=-Pmechg \n",
      "n=n_s*(1-s) \n",
      "w=2*math.pi*n/60 \n",
      "Tnet=Pmechg/w \n",
      "\n",
      "#Results\n",
      "print(Tnet,'torque developed(Nm)') \n",
      "P=Pmechabs+Pip \n",
      "print(P,'power disipated(W)') "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "slip=0.03\n",
        "(12.216911505440674, 'line current(A)')\n",
        "(0.9389975693602858, 'pf')\n",
        "(7332.533835874596, 'power i/p(W)')\n",
        "(6647.250299811549, 'mech power op(W)')\n",
        "(62.732482505184755, 'shaft torque(Nm)')\n",
        "(0.8690379672897196, 'efficiency')\n",
        "slip= -0.03\n",
        "(13.770083713222693, 'line current(A)')\n",
        "(0.8788126748308187, 'pf')\n",
        "(8384.043272481405, 'power i/p(W)')\n",
        "(9560.553301780481, 'mech power op(W)')\n",
        "(88.63743592263522, 'shaft torque(Nm)')\n",
        "(0.8769412195965717, 'efficiency')\n",
        "slip= 1.2\n",
        "(68.98053758242195, 'line current(A)')\n",
        "(0.5044420753093245, 'pf')\n",
        "(24107.85091197462, 'power i/p(W)')\n",
        "(-1057.3618821041503, 'mech power op(W)')\n",
        "(50.48531105214763, 'torque developed(Nm)')\n",
        "(25165.21279407877, 'power disipated(W)')\n"
       ]
      }
     ],
     "prompt_number": 23
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 9.10 Page No 163"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to calculate max torque and slip, starting torque\n",
      "\n",
      "  \n",
      "k=5.0     #k=I_s/I_fl\n",
      "s_fl=0.04 \n",
      "\n",
      "#Calculations\n",
      "s_max_T=math.sqrt((s_fl**2*(1-k**2))/((k*s_fl)**2-1)) \n",
      "print(s_max_T,'slip') \n",
      "T_max=.5*(s_max_T**2+s_fl**2)/(s_fl*s_max_T) \n",
      "print(T_max,'max torque(pu)') \n",
      "\n",
      "T_s=k**2*s_fl \n",
      "\n",
      "#Results\n",
      "print(T_s,'starting torque(pu)') "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(0.2, 'slip')\n",
        "(2.6, 'max torque(pu)')\n",
        "(1.0, 'starting torque(pu)')\n"
       ]
      }
     ],
     "prompt_number": 24
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 9.11, Page No 164"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to find starting current and torque, necessary exteranl resistance and corresponding starting torque\n",
      "\n",
      "  \n",
      "f=50.0 \n",
      "R2=.1 \n",
      "X2=2*math.pi*f*3.61*10**-3 \n",
      "a=3.6 \n",
      "R22=a**2*R2 \n",
      "X22=a**2*X2 \n",
      "V=3000.0 \n",
      "n_s=1000.0 \n",
      "\n",
      "#Calculations\n",
      "w_s=2*math.pi*n_s/60 \n",
      "I_s=(V/math.sqrt(3.0))/math.sqrt(R22**2+X22**2) \n",
      "print(I_s,'starting current(A)') \n",
      "T_s=(3/w_s)*(V/math.sqrt(3.0))**2*R22/(R22**2+X22**2) \n",
      "print(T_s,'torque(Nm)') \n",
      "\n",
      "Iss=30 \n",
      "Rext=math.sqrt(((V/math.sqrt(3.0)/Iss)**2-X22**2)-R22) \n",
      "print(Rext,'external resistance(ohm)') \n",
      "T_s=(3/w_s)*(V/math.sqrt(3.0))**2*(R22+Rext)/((R22+Rext)**2+X22**2) \n",
      "\n",
      "#Results\n",
      "print(T_s,'torque(Nm)') \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(117.38613867026375, 'starting current(A)')\n",
        "(511.600867712354, 'torque(Nm)')\n",
        "(55.821163691822676, 'external resistance(ohm)')\n",
        "(1411.238212203274, 'torque(Nm)')\n"
       ]
      }
     ],
     "prompt_number": 25
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 9.12 Page No 165"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#find line current and starting torque with direct switching, stator resistance starting, autotransformer starting, star delta starting, autotransformer ratio give 1 pu\n",
      "\n",
      "  \n",
      "#I_s/I_fl=6 \n",
      "s_fl=0.05 \n",
      "print('by direct switching') \n",
      "Is=6.0\n",
      "\n",
      "#Calculations\n",
      "print(Is,'line current(pu)') \n",
      "T=Is**2*s_fl \n",
      "print(T,'torque(pu)') \n",
      "\n",
      "print('by stator resistance starting') \n",
      "Is=2.0\n",
      "print(Is,'line current(pu)')         #given\n",
      "T=Is**2*s_fl \n",
      "print(T,'torque(pu)') \n",
      "\n",
      "print('by autotransformer starting') \n",
      "x=2/6.0 \n",
      "Is_motor=2 \n",
      "Is=Is_motor*x \n",
      "print(Is,'line current(pu)') \n",
      "T=Is**2*s_fl \n",
      "print(T,'torque(pu)') \n",
      "\n",
      "print('by star delta starting') \n",
      "Is=(1/3.0)*6 \n",
      "print(Is,'line current(pu)') \n",
      "T=Is**2*s_fl*3.0 \n",
      "\n",
      "#Results\n",
      "print(T,'torque(pu)') \n",
      "\n",
      "print('by autotransformer starting') \n",
      "Ts=1.0 \n",
      "x=math.sqrt(Ts/((6**2)*s_fl)) \n",
      "print(x,'x') "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "by direct switching\n",
        "(6.0, 'line current(pu)')\n",
        "(1.8, 'torque(pu)')\n",
        "by stator resistance starting\n",
        "(2.0, 'line current(pu)')\n",
        "(0.2, 'torque(pu)')\n",
        "by autotransformer starting\n",
        "(0.6666666666666666, 'line current(pu)')\n",
        "(0.022222222222222223, 'torque(pu)')\n",
        "by star delta starting\n",
        "(2.0, 'line current(pu)')\n",
        "(0.6000000000000001, 'torque(pu)')\n",
        "by autotransformer starting\n",
        "(0.7453559924999299, 'x')\n"
       ]
      }
     ],
     "prompt_number": 26
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 9.13 Page No 165"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to find resistance added to ckt\n",
      "\n",
      "  \n",
      "Rrot=.061 \n",
      "R2=Rrot/2.0 \n",
      "f=50.0 \n",
      "P=12.0 \n",
      "w_s=(120.0*f/P)*(2*math.pi/60.0) \n",
      "s=0.045 \n",
      "\n",
      "#Calculations\n",
      "w=(1.0-s)*w_s \n",
      "P=200.0*10.0**3 \n",
      "T_fan=P/w \n",
      "I2=math.sqrt(T_fan*w_s*s/(3.0*R2)) \n",
      "E2=I2*R2/s \n",
      "n=450.0 \n",
      "ww=2*math.pi*n/60 \n",
      "nn=500.0 \n",
      "ss=(nn-n)/nn \n",
      "Tnew=T_fan*(ww/w)**2 \n",
      "Rt=(3.0/w_s)*(E2*ss)**2/(ss*Tnew) \n",
      "Rext=Rt-R2 \n",
      "\n",
      "#Results\n",
      "print(Rext,'external resistance(ohm)') "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(0.04581484910836761, 'external resistance(ohm)')\n"
       ]
      }
     ],
     "prompt_number": 27
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 9.14 Page No 172"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to find resistance added to ckt\n",
      "\n",
      "  \n",
      "n_s=1500.0\n",
      "w_s=2*math.pi*n_s/60.0 \n",
      "n=1250.0 \n",
      "s=1-n/n_s \n",
      "#Im=(1/3.0)*(0.3+.25/s+j*1.83)ohm/ph\n",
      "T=150.0 \n",
      "V=440.0 \n",
      "\n",
      "#Calculations\n",
      "#T=(3.0/w_s)*(V**2*(R_2t/s))/((.1+(R_2t/s))**2+(X1+X2)**2) \n",
      "#after solving R_2t**2-1.34*R_2t+0.093=0\n",
      "\n",
      "def quad(a,b,c):\n",
      "    d=math.sqrt(b**2-4*a*c) \n",
      "    x1=(-b+d)/(2*a) \n",
      "    x2=(-b-d)/(2*a) \n",
      "    if(x1>x2):\n",
      "        x=x1 \n",
      "    else:\n",
      "        x=x2 \n",
      "    return x\n",
      "x=quad(1,-1.34,0.093) \n",
      "Rext=x-0.083 \n",
      "\n",
      "#Results\n",
      "print(Rext,'external resitance(ohm)') "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(1.1835735495309863, 'external resitance(ohm)')\n"
       ]
      }
     ],
     "prompt_number": 28
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 9.15, Page No 176"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to calculate the min resistance to be added and speed of the motor\n",
      " \n",
      "V=400.0 \n",
      "a=2.5 \n",
      "X2=.4 \n",
      "R2=0.08 \n",
      "n_s=750.0 \n",
      "\n",
      "#Calculations\n",
      "w_s=2*math.pi*n_s/60.0 \n",
      "T=250.0 \n",
      "x=[];\n",
      "#T=(3.0/w_s)*((V/math.sqrt(3))/a)*R2t/(R2t**2+X2**2) \n",
      "#after solving\n",
      "#R2t**2-1.304*R2t+0.16=0\n",
      "\n",
      "def quad(a,b,c):\n",
      "    d=math.sqrt(b**2-4*a*c) \n",
      "    x1=(-b+d)/(2*a) \n",
      "    x2=(-b-d)/(2*a) \n",
      "    if(x1>x2):\n",
      "        x=x1 \n",
      "    else:\n",
      "        x=x2 \n",
      "    return x1,x2\n",
      "x=quad(1,-1.304,0.16) \n",
      "if x[0]>x[1]:\n",
      "    R2t=x[1] \n",
      "else:\n",
      "    R2t=x[0]\n",
      "Rext=R2t-R2 \n",
      "print(Rext,'external resistance(ohm)') \n",
      "\n",
      "#T=(3/w_s)*((V/math.sqrt(3))/a)*(R2t/s)/((R2t/s)**2+X2**2) \n",
      "#after solving\n",
      "#(R2t/s)**2-1.304*(R2t/s)+0.16=0\n",
      "x=[0,0]\n",
      "x=quad(1,-1.304,0.16) \n",
      "s=x[1]/x[0] \n",
      "n=n_s*(1-s) \n",
      "print(n,'speed(rpm)') \n",
      "\n",
      "#T=(3/w_s)*((V/math.sqrt(3))/a)*(R2/s)/((R2/s)**2+X2**2) \n",
      "#after solving\n",
      "#(R2/s)**2-1.304*(R2/s)+0.16=0\n",
      "x=quad(1,-1.304,0.16) \n",
      "R2=0.08 \n",
      "s1=R2/x[0]\n",
      "s2=R2/x[1]\n",
      "if s1>s2:\n",
      "    ss=s2 \n",
      "else:\n",
      "    ss=s1\n",
      "\n",
      "n=n_s*(1-ss) \n",
      "\n",
      "#Results\n",
      "print(n,'speed(rpm)') \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(0.057117489129801594, 'external resistance(ohm)')\n",
        "(661.8693476940879, 'speed(rpm)')\n",
        "(698.5809415763244, 'speed(rpm)')\n"
       ]
      }
     ],
     "prompt_number": 29
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 9.16, Page No 186"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "\n",
      "T_jm=125\n",
      "th_jc=.15     #degC/W\n",
      "th_cs=0.075     #degC/W\n",
      "\n",
      "\n",
      "#Calculations\n",
      "dT=54     #dT=T_s-T_a\n",
      "P_av=120\n",
      "th_sa=dT/P_av\n",
      "T_a=40     #ambient temp\n",
      "P_av=(T_jm-T_a)/(th_sa+th_jc+th_cs)\n",
      "if (P_av-120)<1 :\n",
      "    print(\"selection of heat sink is satisfactory\")\n",
      "\n",
      "dT=58     #dT=T_s-T_a\n",
      "P_av=120\n",
      "th_sa=dT/P_av\n",
      "T_a=40     #ambient temp\n",
      "P_av=(T_jm-T_a)/(th_sa+th_jc+th_cs)\n",
      "if (P_av-120)<1 :\n",
      "    print(\"selection of heat sink is satisfactory\")\n",
      "\n",
      "V_m=math.sqrt(2)*230\n",
      "R=2\n",
      "I_TAV=V_m/(R*math.pi)\n",
      "P_av=90\n",
      "th_sa=(T_jm-T_a)/P_av-(th_jc+th_cs)\n",
      "dT=P_av*th_sa\n",
      "print(\"for heat sink\")    \n",
      "print(\"T_s-T_a=%.2f degC\" %dT)   \n",
      "print(\"\\nP_av=%.0f W\" %P_av)\n",
      "P=(V_m/2)**2/R\n",
      "eff=P/(P+P_av)   \n",
      "print(\"\\nckt efficiency=%.3f pu\" %eff)\n",
      "a=60     #delay angle\n",
      "I_TAV=(V_m/(2*math.pi*R))*(1+math.cos(math.radians(a)))\n",
      "print(\"\\nI_TAV=%.2f A\" %I_TAV)\n",
      "dT=46\n",
      "T_s=dT+T_a\n",
      "T_c=T_s+P_av*th_cs    \n",
      "T_j=T_c+P_av*th_jc    \n",
      "\n",
      "#Results\n",
      "print(\"\\ncase temp=%.2f degC\" %T_c)\n",
      "print(\"\\njunction temp=%.2f degC\" %T_j)\n",
      "\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "for heat sink\n",
        "T_s-T_a=-20.25 degC\n",
        "\n",
        "P_av=90 W\n",
        "\n",
        "ckt efficiency=0.993 pu\n",
        "\n",
        "I_TAV=38.83 A\n",
        "\n",
        "case temp=92.75 degC\n",
        "\n",
        "junction temp=106.25 degC\n"
       ]
      }
     ],
     "prompt_number": 30
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 9.17, Page No 187"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to find the ratio of currents and torques at the starting,V2/V1\n",
      "\n",
      "  \n",
      "f1=50.0 \n",
      "f2=60.0 \n",
      "f=f2/f1 \n",
      "V=1     #V=V2/V1\n",
      "s_max_T=0.2 \n",
      "#Is=I_s2/I_s1\n",
      "\n",
      "#Calculations\n",
      "Is=V*math.sqrt((s_max_T**2+1)/(s_max_T**2+f**2)) \n",
      "print(Is,'ratio of currents at starting') \n",
      "#Ts=T_s2/T_s1\n",
      "Ts=V**2*((s_max_T**2+1)/(s_max_T**2+f**2)) \n",
      "print(Ts,'ratio of torques at starting') \n",
      "#Tmax=Tmax2/Tmax1\n",
      "Tmax=V**2/f**2 \n",
      "print(Tmax,'ratio of max torques') \n",
      "Vr=math.sqrt(1/math.sqrt((s_max_T**2+1)/(s_max_T**2+f**2)))\n",
      "\n",
      "#Results\n",
      "print(Vr,'V2/V1') "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(0.8382736442849094, 'ratio of currents at starting')\n",
        "(0.7027027027027027, 'ratio of torques at starting')\n",
        "(0.6944444444444444, 'ratio of max torques')\n",
        "(1.0922123778851107, 'V2/V1')\n"
       ]
      }
     ],
     "prompt_number": 31
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 9.18, Page No 197"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to calculate ratio of torques at starting and at slip=0.05\n",
      "\n",
      "  \n",
      "R1=0.01 \n",
      "X1=.5 \n",
      "R2=0.05 \n",
      "X2=.1 \n",
      "\n",
      "#Calculations\n",
      "Ts=((R1**2+X1**2)/(R2**2+X2**2))*(R2/R1) \n",
      "print(Ts,'Tso/Tsi') \n",
      "\n",
      "s=0.05 \n",
      "T=(((R1/s)**2+X1**2)/((R2/s)**2+X2**2))*(R2/R1) \n",
      "\n",
      "#Results\n",
      "print(T,'To/Ti')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(100.03999999999998, 'Tso/Tsi')\n",
        "(1.4356435643564356, 'To/Ti')\n"
       ]
      }
     ],
     "prompt_number": 32
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Example 9.19, Page No 198"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import math\n",
      "#initialisation of variables\n",
      "#to compute acc time and value of rotor resistance\n",
      "\n",
      "  \n",
      "s=1-.96     #load is brought to .96 of n_s\n",
      "s_max_T=math.sqrt((1.0-s**2)/(2*math.log(1.0/s))) \n",
      "R=1.5 \n",
      "R2_opt=R*s_max_T \n",
      "\n",
      "#Calculations\n",
      "print(R2_opt,'rotor resistance(ohm)') \n",
      "n=1000 \n",
      "w_s=2*math.pi*n/60 \n",
      "V=415 \n",
      "Tmax=(3.0/w_s)*(.5*(V/math.sqrt(3.0))**2)/R \n",
      "J=11 \n",
      "t_A=(J*w_s/(2*Tmax))*((1-s**2)/(2*s_max_T)+s_max_T*math.log(1.0/s))\n",
      "\n",
      "#Results\n",
      "print(t_A,'acc time(min)') \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(0.5907128737793668, 'rotor resistance(ohm)')\n",
        "(2.663571640987115, 'acc time(min)')\n"
       ]
      }
     ],
     "prompt_number": 33
    }
   ],
   "metadata": {}
  }
 ]
}