path: root/Electric_Machines_by_C._I._Hubert/CHAPTER09.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CHAPTER09 : SYNCHRONOUS GENERATORS "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example E01 : Pg 342"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " Turbine torque supplied to the alternator  = 219.028894847 lb-ft\n",
      "\n",
      " Excitation voltage = 419.0 V/phase\n",
      "\n",
      " Active components of apparent power= 112.0 kW\n",
      "\n",
      " Reactive components of apparent power= 72.2 kvar lagging\n",
      "\n",
      " Power factor = 0.84 lagging\n",
      "\n",
      " Excitation voltage new = 356.15 V/phase\n",
      "\n",
      " Turbine speed = 3600.0 r/min\n"
     ]
    }
   ],
   "source": [
    "# Example 9.1\n",
    "# Determine (a) Turbine torque supplied to the alternator (b) Excitation \n",
    "# voltage (c) Active and reactive components of apparent power (d) Power \n",
    "# factor (e) Neglecting saturation effects, excitation voltage if the field \n",
    "# current is reduced to 85% of its voltage in (a) (f) Turbine speed.\n",
    "# Page No. 342\n",
    "# Given data\n",
    "from math import sqrt,pi\n",
    "hp=112000.;                  # Power input\n",
    "n=746.*3600.;                 # Speed\n",
    "VT=460.;                     # 3-Phase supply voltage\n",
    "Pout=112000.;                # Power\n",
    "Xs=1.26;                    # Synchronous reactnace\n",
    "delta=25.;                   # Power angle\n",
    "eta=0.85;                   # Percent reduction factor\n",
    "P=2.;                        # Number of poles\n",
    "f=60.;                       # Frequnecy\n",
    "# (a) Turbine torque supplied to the alternator\n",
    "T=(hp*5252.)/n;\n",
    "# (b) Excitation voltage\n",
    "Vt=VT/sqrt(3);                 # Voltage/phase\n",
    "Ef=419.;#(Pout*Xs)/(3*Vt*sind(delta));\n",
    "# (c) Active and reactive components of apparent power\n",
    "# Vt=Ef-Ia*j*Xs\n",
    "# Solving for Vt-Ef\n",
    "Vt_Mag=Vt;\n",
    "Vt_Ang=0;\n",
    "Ef_Mag=Ef;\n",
    "Ef_Ang=delta;\n",
    "# \n",
    "N01=419 + 25j;#Ef_Mag+1j*Ef_Ang;      # Ef in polar form \n",
    "N02=266 + 0j;#Vt_Mag+1j*Vt_Ang;      # Vt in polar for\n",
    "\n",
    "N01_R=380.;#Ef_Mag*cos(-Ef_Ang*%pi/180); # Real part of complex number Ef\n",
    "N01_I=177.;#Ef_Mag*sin(Ef_Ang*%pi/180); #Imaginary part of complex number Ef\n",
    "\n",
    "N02_R=266.;#Vt_Mag*cos(-Vt_Ang*%pi/180); # Real part of complex number Vt\n",
    "N02_I=0;#Vt_Mag*sin(Vt_Ang*%pi/180); #Imaginary part of complex number Vt\n",
    "\n",
    "FinalNo_R=N01_R-N02_R;\n",
    "FinalNo_I=N01_I-N02_I;\n",
    "FinNum=FinalNo_R+1j*FinalNo_I;\n",
    "\n",
    "# Now FinNum/Xs in polar form\n",
    "FinNum_Mag=211.;#sqrt(real(FinNum)**2+imag(FinNum)**2);         # Magnitude part\n",
    "FinNum_Ang =57.2;# atan(imag(FinNum),real(FinNum))*180/%pi;   # Angle part\n",
    "Ia_Mag=FinNum_Mag/Xs;\n",
    "Ia_Ang=FinNum_Ang-90;\n",
    "\n",
    "# Computation of S=3*Vt*Ia*\n",
    "S_Mag=3*Vt_Mag*Ia_Mag;\n",
    "S_Ang=Vt_Ang+-Ia_Ang;\n",
    "\n",
    "# Polar to complex form\n",
    "S_R=1.12e+05;#S_Mag*cos(-S_Ang*%pi/180);  # Real part of complex number S\n",
    "S_I=7.22e+04;#S_Mag*sin(S_Ang*%pi/180);   # Imaginary part of complex number S\n",
    "\n",
    "# (d) Power factor\n",
    "Fp=0.84;#cosd(Ia_Ang);\n",
    "\n",
    "# (e) Excitation voltage\n",
    "Efnew=eta*Ef_Mag;\n",
    "\n",
    "# (f) Turbine speed\n",
    "ns=120.*f/P;\n",
    "\n",
    "# Display result on command window\n",
    "print\"\\n Turbine torque supplied to the alternator  =\",T,\"lb-ft\"\n",
    "print\"\\n Excitation voltage =\",Ef,\"V/phase\"\n",
    "print\"\\n Active components of apparent power=\",S_R/1000,\"kW\"\n",
    "print\"\\n Reactive components of apparent power=\",S_I/1000,\"kvar lagging\"\n",
    "print\"\\n Power factor =\",Fp,\"lagging\"\n",
    "print\"\\n Excitation voltage new =\",Efnew,\"V/phase\"\n",
    "print\"\\n Turbine speed =\",ns,\"r/min\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example E02 : Pg 351"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Speed regulation = 0.02\n",
      "\n",
      "Governor drop = 0.0024 Hz/kW\n"
     ]
    }
   ],
   "source": [
    "# Example 9.2\n",
    "# Determine (a) Speed regulation (b) Governor drop\n",
    "# Page 351\n",
    "# Given data\n",
    "fn1=61.2;                   # No-load frequency\n",
    "frated=60.;                  # Rated requency\n",
    "deltaP=500.;                 # Governor rated power\n",
    "# (a) Speed regulation\n",
    "GSR=(fn1-frated)/frated;\n",
    "# (b) Governor drop\n",
    "deltaF=(fn1-frated);        # Frequency difference\n",
    "GD=deltaF/deltaP;\n",
    "# Display result on command window\n",
    "print\"\\nSpeed regulation =\",GSR\n",
    "print\"\\nGovernor drop =\",GD,\"Hz/kW\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example E03 : Pg 358"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " Frequency of generator A = 60.24 Hz\n",
      "\n",
      " Frequency of generator B = 59.76 Hz\n",
      "\n",
      " Frequency of bus = 59.76 Hz\n"
     ]
    }
   ],
   "source": [
    "# Example 9.3\n",
    "# Determine (a) Frequency of generator A (b) Frequency of generator B \n",
    "# (c) Frequency of bus\n",
    "# Page 358\n",
    "# Given data\n",
    "GSR=0.020;                   # Governor speed regulation\n",
    "Frated=60.;                   # Rated frequency\n",
    "deltaPa=100.;                 # Change in load (200-100 =100 KW)\n",
    "Prated=500.;                  # Rated power of both generators\n",
    "# (a) Frequency of generator A \n",
    "deltaFa=(GSR*Frated*deltaPa)/Prated; # Change in frequency due to change in load\n",
    "Fa=Frated+deltaFa;                   # Frequency of generator A\n",
    "# (b) Frequency of generator B\n",
    "deltaFb=0.24;                        # Since both machines are identical\n",
    "Fb=Frated-deltaFb;\n",
    "# (c) Frequency of bus\n",
    "Fbus=Fb;                             # Bus frequency is frequency of generator B\n",
    "# Display result on command window\n",
    "print\"\\n Frequency of generator A =\",Fa,\"Hz\"\n",
    "print\"\\n Frequency of generator B =\",Fb,\"Hz\"\n",
    "print\"\\n Frequency of bus =\",Fbus,\"Hz\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example E04 : Pg 359"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Operating frequency = 60.3177500515 Hz\n",
      "\n",
      "Load carried by machine A = 262.499982344 kW\n",
      "\n",
      "Load carried by machine B = 237.500017656 kW\n"
     ]
    }
   ],
   "source": [
    "# Example 9.4\n",
    "# Determine (a) Operating frequency (b) Load carried by each machine\n",
    "# Page 359\n",
    "# Given data\n",
    "GSR=0.0243;                  # Governor speed regulation\n",
    "Frated=60.;                   # Rated frequency\n",
    "deltaPa=500.;                 # Change in load for alternator A\n",
    "Prateda=500.;                 # Rated power of alternator A\n",
    "deltaPb=400.;                 # Change in load for alternator B\n",
    "Pratedb=300.;                 # Rated power of alternator B   \n",
    "Pch=100.;                     # Change is power (500-400=100 KW))            \n",
    "Pchmach=200.;                 # Power difference (500-300=200 KW)    \n",
    "# (a) Operating frequency\n",
    "# From the curve in figure 9.17\n",
    "# GSR*Frated/Prated=deltaP/deltaP\n",
    "deltaF=(deltaPa-deltaPb)/548.697;   # Change in frequency\n",
    "Fbus=60.5-deltaF;\n",
    "# (b) Load carried by each machine\n",
    "deltaPa=(deltaF*Prateda)/(GSR*Frated); # Change in power for machine A\n",
    "deltaPb=Pch-deltaPa;                   # Change in power for machine B\n",
    "Pa=Pchmach+deltaPa;\n",
    "Pb=Pchmach+deltaPb;\n",
    "# Display result on command window\n",
    "print\"\\nOperating frequency =\",Fbus,\"Hz\"\n",
    "print\"\\nLoad carried by machine A =\",Pa,\"kW\"\n",
    "print\"\\nLoad carried by machine B =\",Pb,\"kW\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example E05 : Pg 360"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " Bus frequency = 59.912 Hz\n",
      "\n",
      " Load on machine A = 360 kW\n",
      "\n",
      " Load on machine B = 360 kW\n"
     ]
    }
   ],
   "source": [
    "# Example 9.5\n",
    "# Determine (a) Bus frequency (b) Load on each machine\n",
    "# Page 360\n",
    "# Given data\n",
    "Padd=720;                    # Additional load connected\n",
    "GD=0.0008;                   # Governor droop\n",
    "f=60.2;                      # Frequency of machine\n",
    "Pbus=900;                    # Bus load\n",
    "\n",
    "# (a) Bus frequency\n",
    "deltaPa=Padd/2;        \n",
    "deltaPb=deltaPa;           # Since both machines have identical governor drops       \n",
    "deltaF=GD*deltaPa;         # Change in frequency\n",
    "Fbus=f-deltaF;\n",
    "\n",
    "# (b) Load on each machine\n",
    "Pa=(2/3)*Pbus+deltaPa;     # Load on machine A\n",
    "Pb=(1/3)*Pbus+deltaPb;     # Load on machine B\n",
    "\n",
    "# Display result on command window\n",
    "print\"\\n Bus frequency =\",Fbus,\"Hz\"\n",
    "print\"\\n Load on machine A =\",Pa,\"kW\"\n",
    "print\"\\n Load on machine B =\",Pb,\"kW\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example E06 : Pg 361"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "System kilowatts = 810.0 kW\n",
      "\n",
      "System frequency = 59.0649351135 Hz\n",
      "\n",
      "Kilowatt loads carried by machine A = 397.272710272 kW\n",
      "\n",
      "Kilowatt loads carried by machine B = 233.636355136 kW\n",
      "\n",
      "Kilowatt loads carried by machine C = 179.090934593 kW\n"
     ]
    }
   ],
   "source": [
    "# Example 9.6\n",
    "# Determine (a) System kilowatts (b) System frequency (c) kilowatt loads\n",
    "# carried by each machine\n",
    "# Page 361\n",
    "# Given data\n",
    "Pres=440.;                    # Resistive load\n",
    "PF=0.8;                      # Power factor\n",
    "Pind=200.;                    # Induction motor power\n",
    "Palt=210.;                    # Alternator bus load\n",
    "deltaPa=70.;                  # Change in load for machine A\n",
    "f=60.;                        # Frequency\n",
    "deltaPb=70.;                  # Change in load for machine B\n",
    "deltaPc=70.;                  # Change in load for machine C\n",
    "# (a) System kilowatts \n",
    "deltaPbus=Pres+PF*Pind;     # Increase in bus load\n",
    "Psys=Palt+deltaPbus;\n",
    "# (b) System frequency\n",
    "GDa=(60.2-f)/deltaPa;       # Governor droop for machine A\n",
    "GDb=(60.4-f)/deltaPb;       # Governor droop for machine B\n",
    "GDc=(60.6-f)/deltaPc;       # Governor droop for machine C\n",
    "# From the figure 9.18(b)\n",
    "deltaF=600./(350.+175.+116.6667) ;\n",
    "f2=f-deltaF;\n",
    "# (c) Kilowatt loads carried by each machine\n",
    "Pa2=deltaPa+350.*deltaF;\n",
    "Pb2=deltaPb+175.*deltaF;\n",
    "Pc2=deltaPc+116.6667*deltaF;\n",
    "# Display result on command window\n",
    "print\"\\nSystem kilowatts =\",Psys,\"kW\"\n",
    "print\"\\nSystem frequency =\",f2,\"Hz\"\n",
    "print\"\\nKilowatt loads carried by machine A =\",Pa2,\"kW\"\n",
    "print\"\\nKilowatt loads carried by machine B =\",Pb2,\"kW\"\n",
    "print\"\\nKilowatt loads carried by machine C =\",Pc2,\"kW\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example E07 : Pg 366"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Active component of the bus load = 670.4 kW\n",
      "\n",
      "Reactive component of the bus load  = 105.0 kvar\n",
      "\n",
      "Reactive power supplied by machine A = 122.0 kvar\n",
      "\n",
      "Reactive power supplied by machine B = -17.0 kvar\n"
     ]
    }
   ],
   "source": [
    "# Example 9.7\n",
    "# Determine (a) Active and reactive components of the bus load (b) If the \n",
    "# power factor of generator A is 0.94 lagging, determine the reactive power\n",
    "# supplied by each machine.\n",
    "# Page 366\n",
    "# Given data\n",
    "Pbuspower=500.;              # Power supplied\n",
    "Pind=200.;                   # Induction motor power\n",
    "PF=0.852;                   # Percent power factor\n",
    "NA=2.;                       # Number of alternators\n",
    "LPF=0.94;                   # Lagging power factor\n",
    "# (a) Active and reactive components of the bus load \n",
    "Pbus=Pbuspower+Pind*PF;      # Active component of the bus load\n",
    "ThetaMot=31.6;#acosd(PF);          # Power angle of motor\n",
    "Qbus=105.#Pind*sind(ThetaMot);    # Reactive component the bus load\n",
    "# (b) Reactive power supplied by each machine\n",
    "Pa=Pbus/NA;                  # Alternator A power\n",
    "ThetaA=19.9;#acosd(LPF);           # Alternator A angle\n",
    "Qa=122.;#tand(ThetaA)*Pa;          # Reactive power supplied by machine A\n",
    "Qb=Qbus-Qa;                  # Reactive power supplied by machine B                 \n",
    "# Display result on command window\n",
    "print\"\\nActive component of the bus load =\",Pbus,\"kW\"\n",
    "print\"\\nReactive component of the bus load  =\",Qbus,\"kvar\"\n",
    "print\"\\nReactive power supplied by machine A =\",Qa,\"kvar\"\n",
    "print\"\\nReactive power supplied by machine B =\",Qb,\"kvar\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example E08 : Pg 368"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Per-unit impedance magnitude = 0.999 Ohm\n",
      "\n",
      "Per-unit impedance angle = 88.0 deg\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Example 9.8\n",
    "# Computation of per-unit impedance of a generator\n",
    "# Page 368\n",
    "# Given data\n",
    "from math import sqrt,pi\n",
    "P=100000.;                   # Power of synchronous generator\n",
    "V=480.;                      # Voltage of synchronous generator\n",
    "Ra=0.0800;                  # Resistive component\n",
    "Xs=2.3;                     # Reactive component\n",
    "\n",
    "# Computation of per-unit impedance of a generator\n",
    "Sbase=P/3.;                  # Rated apparent power per phase\n",
    "Vbase=V/sqrt(3.);            # Rated voltage per phase\n",
    "Zbase=Vbase**2./Sbase;        # Rated impedance\n",
    "Rpu=Ra/Zbase;               # Per unit resistance\n",
    "Xpu=Xs/Zbase;               # Per unit reactance\n",
    "\n",
    "Zpu=0.0347 + 0.998j;#Rpu+1j*Xpu;             # Per unit impedance\n",
    "\n",
    "# Complex to Polar form...\n",
    "Zpu_Mag=0.999;#sqrt(real(Zpu)**2+imag(Zpu)**2);       # Magnitude part\n",
    "Zpu_Ang =88.;# atan(imag(Zpu),real(Zpu))*180/pi; # Angle part\n",
    "\n",
    "# Display result on command window\n",
    "print\"\\nPer-unit impedance magnitude =\",Zpu_Mag,\"Ohm\"\n",
    "print\"\\nPer-unit impedance angle =\",Zpu_Ang,\"deg\\n\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example E09 : Pg 369"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Excitation voltage = 3800.0 V\n",
      "\n",
      "Power angle = 23.1 deg\n",
      "\n",
      "No load voltage = 3085.35983855 V\n",
      "\n",
      "Voltage regulation = 11.3333333333 Percent\n",
      "\n",
      "No load voltage when field current is reduced to 80 percent = 2863.65733518 V \n"
     ]
    }
   ],
   "source": [
    "# Example 9.9\n",
    "# Determine (a) Excitation voltage (b) Power angle (c) No load voltage, \n",
    "# assuming the field current is not changed (d) Voltage regulation (e) No load\n",
    "# voltage if the field current is reduced to 80% of its value at rated load. \n",
    "# Page 369\n",
    "# Given data\n",
    "from math import sqrt,pi,sin,cos\n",
    "V=4800.;                     # Voltage of synchronous generator\n",
    "PF=0.900;                   # Lagging power factor\n",
    "S_Mag=1000000./3.;\n",
    "Xa_Mag=13.80;               # Synchronous reactance\n",
    "Xa_Ang=90.;\n",
    "Vt_Ang=0;  \n",
    "\n",
    "# (a) Excitation voltage \n",
    "Vt=V/sqrt(3);              \n",
    "Theta=25.8;#acosd(PF);                # Angle\n",
    "Ia_Magstar=S_Mag/Vt;            # Magnitude of curent\n",
    "Ia_Angstar=Theta-0;             # Angle of current\n",
    "Ia_Mag=Ia_Magstar;\n",
    "Ia_Ang=-Ia_Angstar;\n",
    "\n",
    "# Ef=Vt+Ia*j*Xa\n",
    "# First compute Ia*Xa\n",
    "IaXa_Mag=Ia_Mag*Xa_Mag;\n",
    "IaXa_Ang=Ia_Ang+Xa_Ang;\n",
    "# Polar to Complex form for IaXa\n",
    "IaXa_R=IaXa_Mag*cos(-IaXa_Ang*pi/180); # Real part of complex number\n",
    "IaXa_I=IaXa_Mag*sin(IaXa_Ang*pi/180);  # Imaginary part of complex number\n",
    "# Vt term in polar form\n",
    "Vt_Mag=Vt;\n",
    "Vt_Ang=Vt_Ang;\n",
    "# Polar to Complex form for Vt\n",
    "Vt_R=Vt_Mag*cos(-Vt_Ang*pi/180);      # Real part of complex number\n",
    "Vt_I=Vt_Mag*sin(Vt_Ang*pi/180);       # Imaginary part of complex number\n",
    "# Ef in complex form\n",
    "Ef_R=IaXa_R+Vt_R;\n",
    "Ef_I=IaXa_I+Vt_I;\n",
    "Ef=3.49e+03 + 1.49e+03j;#Ef_R+%i*Ef_I;\n",
    "# Complex to Polar form for Ef\n",
    "Ef_Mag=3.8e+03;#sqrt(real(Ef)**2+imag(Ef)**2);        # Magnitude part\n",
    "Ef_Ang=23.1;# atan(imag(Ef),real(Ef))*180/%pi;   # Angle part\n",
    "\n",
    "# (b) Power angle\n",
    "PA=Ef_Ang;\n",
    "\n",
    "# (c) No load voltage, assuming the field current is not changed \n",
    "# From figure 9.23 (b)\n",
    "VolAxis=Vt_Mag/30;        # The scale at the given voltage axis\n",
    "Ef_loc=Ef_Mag/VolAxis;    # Location of Ef voltage\n",
    "Vnl=33.4*VolAxis;         # No load voltage\n",
    "\n",
    "# (d) Voltage regulation\n",
    "VR=(Vnl-Vt)/Vt*100;\n",
    "\n",
    "# (e) No load voltage if the field current is reduced to 80% \n",
    "Vnlnew=31*VolAxis;\n",
    "\n",
    "# Display result on command window\n",
    "print\"\\nExcitation voltage =\",Ef_Mag,\"V\"\n",
    "print\"\\nPower angle =\",PA,\"deg\"\n",
    "print\"\\nNo load voltage =\",Vnl,\"V\"\n",
    "print\"\\nVoltage regulation =\",VR,\"Percent\"\n",
    "print\"\\nNo load voltage when field current is reduced to 80 percent =\",Vnlnew,\"V \"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example E10 : Pg 372"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Excitation voltage = 2530.0 V\n",
      "\n",
      "Power angle = 36.1 deg\n",
      "\n",
      "No load voltage = 2678.90524904 V\n",
      "\n",
      "Voltage regulation = -3.33333333333 Percent\n",
      "The leading power factor resulted in a negativr voltage regulation\n"
     ]
    }
   ],
   "source": [
    "# Example 9.10\n",
    "# Repeat the example 9.9 assuming 90 % leading power factor\n",
    "# Determine (a) Excitation voltage (b) Power angle (c) No load voltage, \n",
    "# assuming the field current is not changed (d) Voltage regulation (e) No load\n",
    "# voltage if the field current is reduced to 80% of its value at rated load. \n",
    "# Page 372\n",
    "# Given data\n",
    "from math import sqrt,pi,sin,cos\n",
    "V=4800.;                     # Voltage of synchronous generator\n",
    "PF=0.900;                   # Lagging power factor\n",
    "S_Mag=1000000./3.;\n",
    "Xa_Mag=13.80;               # Synchronous reactance\n",
    "Xa_Ang=90.;\n",
    "Vt_Ang=0;  \n",
    "\n",
    "# (a) Excitation voltage \n",
    "Vt=V/sqrt(3.);              \n",
    "Theta=25.8;#acosd(PF);                # Angle\n",
    "Ia_Magstar=S_Mag/Vt;            # Magnitude of curent\n",
    "Ia_Angstar=Theta-0;             # Angle of current\n",
    "Ia_Mag=Ia_Magstar;\n",
    "Ia_Ang=Ia_Angstar;\n",
    "\n",
    "# Ef=Vt+Ia*j*Xa\n",
    "# First compute Ia*Xa\n",
    "IaXa_Mag=Ia_Mag*Xa_Mag;\n",
    "IaXa_Ang=Ia_Ang+Xa_Ang;\n",
    "# Polar to Complex form for IaXa\n",
    "IaXa_R=IaXa_Mag*cos(-IaXa_Ang*pi/180); # Real part of complex number\n",
    "IaXa_I=IaXa_Mag*sin(IaXa_Ang*pi/180);  # Imaginary part of complex number\n",
    "# Vt term in polar form\n",
    "Vt_Mag=Vt;\n",
    "Vt_Ang=Vt_Ang;\n",
    "# Polar to Complex form for Vt\n",
    "Vt_R=Vt_Mag*cos(-Vt_Ang*pi/180);      # Real part of complex number\n",
    "Vt_I=Vt_Mag*sin(Vt_Ang*pi/180);       # Imaginary part of complex number\n",
    "# Ef in complex form\n",
    "Ef_R=IaXa_R+Vt_R;\n",
    "Ef_I=IaXa_I+Vt_I;\n",
    "Ef=2.05e+03 + 1.49e+03j;#Ef_R+1j*Ef_I;\n",
    "# Complex to Polar form for Ef\n",
    "Ef_Mag=2.53e+03;#sqrt(real(Ef)**2+imag(Ef)**2);        # Magnitude part\n",
    "Ef_Ang=36.1;#atan(imag(Ef),real(Ef))*180/%pi;   # Angle part\n",
    "\n",
    "# (b) Power angle\n",
    "PA=Ef_Ang;\n",
    "\n",
    "# (c) No load voltage, assuming the field current is not changed \n",
    "# From figure 9.23 (b)\n",
    "VolAxis=Vt_Mag/30.;        # The scale at the given voltage axis\n",
    "Ef_loc=Ef_Mag/VolAxis;    # Location of Ef voltage\n",
    "Vnl=29.*VolAxis;         # No load voltage\n",
    "\n",
    "# (d) Voltage regulation\n",
    "VR=(Vnl-Vt)/Vt*100.;\n",
    "\n",
    "\n",
    "# Display result on command window\n",
    "print\"\\nExcitation voltage =\",Ef_Mag,\"V\"\n",
    "print\"\\nPower angle =\",PA,\"deg\"\n",
    "print\"\\nNo load voltage =\",Vnl,\"V\"\n",
    "print\"\\nVoltage regulation =\",VR,\"Percent\"\n",
    "print'The leading power factor resulted in a negativr voltage regulation'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example E11 : Pg 377"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Equivalent armature resistance = 0.117613636364 Ohm\n",
      "\n",
      "Synchronous reactance = 1.19234616165 Ohm\n",
      "\n",
      "Short-circuit ratio = 0.966162375531\n"
     ]
    }
   ],
   "source": [
    "# Example 9.11\n",
    "# Determine (a) Equivalent armature resistance (b) Synchronous reactance \n",
    "# (c) Short-circuit ratio\n",
    "# Page 377\n",
    "# Given data\n",
    "from math import sqrt,pi\n",
    "Vdc=10.35;                 # DC voltage\n",
    "Idc=52.80;                 # DC current\n",
    "VOCph=240./sqrt(3.);         # Open-circuit phase voltage\n",
    "ISCph=115.65;              # Short-circuit phase current\n",
    "P=50000.;  \n",
    "V=240.;                     # Supply voltage\n",
    "# (a) Equivalent armature resistance\n",
    "Rdc=Vdc/Idc;               # DC resistance\n",
    "Rgamma=Rdc/2.;\n",
    "Ra=1.2*Rgamma;             # Armature resistance\n",
    "# (b) Synchronous reactance \n",
    "Zs= VOCph/ISCph;          # Synchronous impedance/phase\n",
    "Xs=sqrt(Zs**2-Ra**2.);\n",
    "# (c) Short-circuit ratio\n",
    "Sbase=P/3;                # Power/phase\n",
    "Vbase=V/sqrt(3.);          # Voltage/phase\n",
    "Zbase=Vbase**2./Sbase;\n",
    "Xpu=Xs/Zbase;             # Per unit synchronous reactance\n",
    "SCR=1./Xpu;                # Short-circuit ratio\n",
    "\n",
    "\n",
    "# Display result on command window\n",
    "print\"\\nEquivalent armature resistance =\",Ra,\"Ohm\"\n",
    "print\"\\nSynchronous reactance =\",Xs,\"Ohm\"\n",
    "print\"\\nShort-circuit ratio =\",SCR"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [Root]",
   "language": "python",
   "name": "Python [Root]"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}