{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ch-14, System Interconnections"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## example 14.1 Page 302"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " speed regulation of alternator is 0.02Hz/MW \n",
      " change in power output 5MW\n"
     ]
    }
   ],
   "source": [
    "p=100  #rating of alternater\n",
    "sd=0.04 #speed of alrternator drops \n",
    "df=-0.1  #change in frequency and drops so -ve\n",
    "f=50    #frequency is 50hz\n",
    "r=sd*f/p  #r in hz/MW\n",
    "dp=-(df)/r \n",
    "print \" speed regulation of alternator is %.2fHz/MW \\n change in power output %dMW\"%(r,dp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## example14.2 Page 302"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kinetic energy stored at rated speed 5.0e+05 kW-sec \n",
      "loss in kinetic energy due to increase in load 2.5e+04 kW-sec \n",
      "new frequency 48.734Hz \n",
      "frequency deviation 2.532\n"
     ]
    }
   ],
   "source": [
    "p=100 #power of alternator\n",
    "f=50  #frequency\n",
    "h=5   #h constant of machine kW-sec kVA\n",
    "inl=50 #load suddenly increase by\n",
    "de=0.5 #time delay\n",
    "ke=h*p*10**3 #kinetic energy\n",
    "lke=inl*10**3*de #loss in kinetic energy\n",
    "nf=((1-(lke/ke))**(de))*f #now frequency \n",
    "fd=(1-nf/f)*100  #frequency deviation\n",
    "print \"kinetic energy stored at rated speed %.1e kW-sec \\nloss in kinetic energy due to increase in load %.1e kW-sec \\nnew frequency %.3fHz \\nfrequency deviation %.3f\"%(ke,lke,nf,fd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## example 14.3 Page 303"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " R1=0.005ohm \n",
      " R2=0.0125ohm\n"
     ]
    }
   ],
   "source": [
    "ar1=500 #alternator rating1\n",
    "pl=0.5  #each alternator is operating at half load \n",
    "ar2=200 #alternator rating2\n",
    "f=50   #frequency\n",
    "il=140  #load increase by 140 MW\n",
    "fd=49.5  #frequency drops\n",
    "fdd=-f+fd #frequency deviation \n",
    "dp1=(ar1*pl)-il  #change in load alternator 1\n",
    "dp2=-(ar2*pl)+il #change in load of alternator 2\n",
    "r1=-fdd/dp1  \n",
    "r2=-fdd/dp2\n",
    "print \" R1=%.3fohm \\n R2=%.4fohm\"%(r1,r2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## example14.4 Page 303"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "static frequency drop -0.019608Hz \n",
      "frequency drop -1Hz\n"
     ]
    }
   ],
   "source": [
    "from __future__ import division\n",
    "rc=10000 #rated capacity\n",
    "r=2   #regulation in all units\n",
    "li=0.02 #load increase\n",
    "f=50  #frequency\n",
    "d=rc/(2*f) #d=partial derevative with respect to frequency\n",
    "d=d/rc\n",
    "b=d+1/r\n",
    "m=li*rc/2\n",
    "mpu=m/rc\n",
    "df=-mpu/b \n",
    "dff=-mpu/d\n",
    "print \"static frequency drop %fHz \\nfrequency drop %dHz\"%(df,dff)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## example 14.5 Page 303"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "d=0.01p.u.MW/hz, \n",
      "kp=100hz/p.u.MW \n",
      "tp=20second\n"
     ]
    }
   ],
   "source": [
    "from __future__ import division\n",
    "cac=10000  #control area capacity\n",
    "nol=5000  #normal operating\n",
    "h=5       #inertial constent\n",
    "r=3       #regulation\n",
    "cf=1      #1%change in corresponds to 1% change in load\n",
    "f=50      #frequency\n",
    "d=cac/(2*f)\n",
    "dpu=d/(cac)\n",
    "kp=1/dpu\n",
    "tp=2*h/(f*dpu)\n",
    "print \"d=%.2fp.u.MW/hz, \\nkp=%dhz/p.u.MW \\ntp=%dsecond\"%(dpu,kp,tp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## example 14.6 Page 304"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the contribution of frequency drop to meet increase in load 1.961MW \n",
      "increase in generation cost Rs98.04\n"
     ]
    }
   ],
   "source": [
    "from __future__ import division\n",
    "rc=10000 #rated capacity\n",
    "r=2   #regulation in all units\n",
    "li=0.02 #load increase\n",
    "f=50  #frequency\n",
    "d=rc/(2*f) #d=partial derevative with respect to frequency\n",
    "dd=d/rc\n",
    "b=dd+1/r\n",
    "m=li*rc/2\n",
    "mpu=m/rc\n",
    "df=-mpu/b \n",
    "dff=-mpu/dd\n",
    "cf=abs(df*d)\n",
    "inc=-(df/r)*10**4\n",
    "print \"the contribution of frequency drop to meet increase in load %.3fMW \\nincrease in generation cost Rs%.2f\"%(cf,inc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## example 14.7 Page 307"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ke at no load 450MW-sec \n",
      "loss in k.e due to load 12.5MW-sec \n",
      "new frequency 49.3Hz \n",
      "frequency deviation 1.4percent\n"
     ]
    }
   ],
   "source": [
    "p=100  #MVA of generated\n",
    "f=50   #frequency\n",
    "rpm=3000 #no load rpm\n",
    "lad=25  #load applied to the machiene\n",
    "t=0.5  #time delay \n",
    "h=4.5  #inertia constent\n",
    "ke=h*p  #kinetic energy is product of h*p\n",
    "lke=lad*t  #loss of ke\n",
    "nf=(((ke-lke)/ke)**t)*f  #new frequency ((1-lke/ke)**t)*f\n",
    "fd=(1-(nf/f))*100    #frequency deviation\n",
    "print \"ke at no load %dMW-sec \\nloss in k.e due to load %.1fMW-sec \\nnew frequency %.1fHz \\nfrequency deviation %.1fpercent\"%(ke,lke,nf,fd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## example 14.8 Page 307"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "largest chang in load is 0.105p.u.MW=420MW\n",
      "\n",
      "df=(dff)(1-e**2.625000*t)\n"
     ]
    }
   ],
   "source": [
    "c=4000#capacity\n",
    "f=50  #frequency\n",
    "ol=2500 #operating load\n",
    "r=2   #speed regulation\n",
    "h=5  #inertial constant\n",
    "dl=0.02 #change in load\n",
    "df=0.01  #change in frequency\n",
    "dff=-0.2 #change in steady state frequency\n",
    "d=(dl*ol)/(df*f) #\n",
    "dpu=d/c  #din pu\n",
    "b=dpu+(1/r)\n",
    "m=-dff*b\n",
    "print \"largest chang in load is %.3fp.u.MW=%dMW\"%(m,m*c)\n",
    "kp=(1/dpu)\n",
    "tp=(kp)*2*h/f\n",
    "tt=(r+kp)/(r*tp) #time constant \n",
    "print \"\\ndf=(dff)(1-e**%f*t)\"%(tt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## example14.9 Page 307"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " df=-0.02439(1-e**(-4.1)) \n",
      " ki=2002.0005p.u.MW/Hz\n"
     ]
    }
   ],
   "source": [
    "from __future__ import division\n",
    "c=4000 #capacity of system\n",
    "f=50  #frequency #operatingload=rated area capacity\n",
    "h=5   #time constent\n",
    "r=0.025  #\n",
    "dl=0.01 #change in load\n",
    "df=0.01 #change in frequency\n",
    "rr=r*f #\n",
    "d=(dl*c)/(df*f) \n",
    "dpu=d/c\n",
    "kp=1/dpu\n",
    "tp=(kp)*(2*h/f)\n",
    "tt=(rr+kp)/(rr*tp)\n",
    "sfe=(kp*rr*dpu)/(rr+kp)\n",
    "ki=(1+(kp/r))**2/(4*tp*kp)\n",
    "print \" df=-%.5f(1-e**(-%.1f)) \\n ki=%.4fp.u.MW/Hz\"%(sfe,tt,ki)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## example14.10 Page 308"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(a)\n",
      "\n",
      "transfer function of governor gr= 1/(1+0.2*s) \n",
      " transfer function of turbine gt=1/(1+2*s)\n",
      "\n",
      "transfer function of power system \n",
      " Gp=(50/(1+10*s)\n",
      " Df=-gp/(1+(0.5*(gr*gt*gp)))\n",
      "(b)\n",
      "\n",
      "the largest step in the load if the frequency change by more than 0.01 in steady state -18765MW\n",
      "\n",
      "the minu sign is becose of the that if frequency is to increase by 0.010000 \n",
      "the change in load be negative.\n",
      "(c)\n",
      "when integral controller is used,static frequency error is zero\n"
     ]
    }
   ],
   "source": [
    "tg=0.2 #time constent of steam turbine\n",
    "t=2 #time constant of turbine\n",
    "h=5 #inertia constent\n",
    "r=0.04  #given\n",
    "dl=0.01  #change in load\n",
    "df=0.01  #change in frequency\n",
    "c=1500  #capacity\n",
    "f=50  #frequency\n",
    "adl=0.01 #max allowable change in load\n",
    "print '(a)'\n",
    "print \"\\ntransfer function of governor gr= 1/(1+%.1f*s) \\n transfer function of turbine gt=1/(1+%d*s)\"%(tg,t)\n",
    "rr=r*f\n",
    "d=(dl*c)/(df*f)\n",
    "dpu=(d/c)\n",
    "kp=(1/dpu)\n",
    "tp=(kp*(2*h)/(f))\n",
    "print \"\\ntransfer function of power system \\n Gp=(%d/(1+%d*s)\\n Df=-gp/(1+(0.5*(gr*gt*gp)))\"%(kp,tp)\n",
    "ddf=-(kp)/(1+kp/r)\n",
    "dff=df*f\n",
    "m=dff/(ddf)\n",
    "mm=m*c\n",
    "print '(b)'\n",
    "print \"\\nthe largest step in the load if the frequency change by more than %.2f in steady state %dMW\"%(adl,mm)\n",
    "if mm<0:\n",
    "    print \"\\nthe minu sign is becose of the that if frequency is to increase by %f \\nthe change in load be negative.\"%(adl)\n",
    "else:\n",
    "    print \"\\nthe largest step in load if the frequency is to decrease by %f /n the change in load be positive\"%(adl)\n",
    "print '(c)'\n",
    "\n",
    "print 'when integral controller is used,static frequency error is zero'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## example 14.11 Page 312"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "change in frequency is -0.01307Hz \n",
      "change in power -0.003333 p.u.MW\n"
     ]
    }
   ],
   "source": [
    "pa=5000   #power of unit a\n",
    "pb=10000   #power of unit b\n",
    "r=2       #given speed regulation in p.uMW\n",
    "d=0.01   #d in p.u.MW/Hz\n",
    "dpa=0    #change in power  in unit a\n",
    "dpb=-100 #change in power in unit b \n",
    "pbas=10000  #assume base as 10000 \n",
    "ra=r*pbas/pa  #speed regulation of the unit a\n",
    "da=d*pa/pbas  #da of unit b\n",
    "rb=r*pbas/pb #speed regulation of unit b\n",
    "db=d*pb/pbas  #db of unit b\n",
    "ba=da+(1/ra)  #area frequency response of a\n",
    "bb=db+(1/rb)  #area frequency response of b\n",
    "ma=dpa/pbas   #change in power a in per unit in unit a \n",
    "mb=dpb/pbas   #change in power a in per unit in unit b\n",
    "df=(ma+mb)/(ba+bb) #change in frequency\n",
    "dpab=(ba*mb-bb*ma)/(ba+bb)  #change in power between ab\n",
    "print \"change in frequency is %.5fHz \\nchange in power %.6f p.u.MW\"%(df,dpab)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## example 14.12 page 314"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(a)\n",
      "change in frequency is -0.016Hz  \n",
      " change in power between ab -0.00832p.u.MW \n",
      " \t\t-16.64MW\n",
      "(b)\n",
      " change in frequency is -0.016Hz  \n",
      " change in power between ab 0.00168p.u.MW \n",
      "\n",
      " change in power 3.360000MW\n"
     ]
    }
   ],
   "source": [
    "pa=500   #power of unit a\n",
    "pb=2000  #power of unit b\n",
    "ra=2.5   #speed regulation of a\n",
    "rb=2     #speed regulation of b\n",
    "dl=0.01  #change in load\n",
    "df=0.01  # change in frequency\n",
    "pt=20     #change in tie line power \n",
    "ptl=0     #let other power station has zero \n",
    "pbas=2000  #assume base as 2000MW\n",
    "f=50        #assume frequency\n",
    "da=(dl*pa)/(df*f)  #change in power w.r.t frequency\n",
    "dapu=da/(pbas)  # change in power w.r.t frequency in per unit\n",
    "db=(dl*pb)/(df*f) #change in power in unit b\n",
    "dbpu=db/pbas      #change in power w.r.t frequency in per unit\n",
    "raa=ra*pbas/pa  #speed regulation with pbase\n",
    "rbb=rb*pbas/pb  #speed regulation with pbase\n",
    "ba=dapu+(1/raa)  #area frequency response a\n",
    "bb=dbpu+(1/rbb)  #area frequency response b\n",
    "ma=pt/pbas       #assume change in power in unit a alone due to tie power\n",
    "mb=ptl/pbas       #change in power in unit b\n",
    "df=-(ma+mb)/(ba+bb) #change in frequency\n",
    "dpp=(ba*mb-bb*ma)/(ba+bb)  #change in power\n",
    "print '(a)'\n",
    "print \"change in frequency is %.3fHz  \\n change in power between ab %.5fp.u.MW \\n \\t\\t%.2fMW\"%(df,dpp,dpp*pbas)\n",
    "ma2=ptl/pbas       #assume change in power in unit a alone due to tie power\n",
    "mb2=pt/pbas       #change in power in unit b\n",
    "df2=-(ma2+mb2)/(ba+bb) #change in frequency\n",
    "dpp2=(ba*mb2-bb*ma2)/(ba+bb)  #change in power\n",
    "print '(b)'\n",
    "dpba=dpp2*pbas\n",
    "print \" change in frequency is %.3fHz  \\n change in power between ab %.5fp.u.MW \\n\"%(df2,dpp2)\n",
    "print \" change in power %fMW\"%(dpba)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## example 14.13 Page 315"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(a)\n",
      " the damped angular frequency is 7.11radians/sec if speed govenor loop is closed\n",
      "(b)\n",
      " since the two area are imilier ,each area will supply half of increase in load .this also evident besause ba=bb  \n",
      " change in power 50MW \n",
      " speed regulation is infininy\n",
      " damped angular frequency if speed governor loop is open 2.687rad/sec \n"
     ]
    }
   ],
   "source": [
    "from __future__ import division\n",
    "from math import cos, pi\n",
    "p=4000 #power area\n",
    "n=2    #number of units\n",
    "r=2    #speed regulation\n",
    "h=5    \n",
    "pt=600    #given tie power\n",
    "pan=40   #power angle\n",
    "stp=100\n",
    "f=50\n",
    "t=(pt/p)*cos(pan*pi/180)\n",
    "wo=((2*pi*f*t/h)**2-(f/(4*r*h))**2)**(0.5)\n",
    "print '(a)'\n",
    "print \" the damped angular frequency is %.2fradians/sec if speed govenor loop is closed\"%(wo)\n",
    "print '(b)'\n",
    "print \" since the two area are imilier ,each area will supply half of increase in load .this also evident besause ba=bb  \\n change in power %dMW \\n speed regulation is infininy\"%(stp/2)\n",
    "wo1=(2*pi*f*t/h)**(0.5) #if govenor loop is open alpha is zero\n",
    "print \" damped angular frequency if speed governor loop is open %.3frad/sec \"%(wo1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## example14.14 Page 325"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the reactive power supply and reseving power is 132kV \n",
      "reactive power -15.91Mvar\n",
      "\n",
      "the required compensator network neeeded 45.91Mvar\n",
      "(b)\n",
      "thus under no load condition the line delivers 3.33Mvar at receiving end.the reactive power must be absorbed by shunt reactor at receving end. thus the capacity of shunt reactor, for no load condition is 3.33Mvar. \n"
     ]
    }
   ],
   "source": [
    "from math import cos, acos, sin,pi\n",
    "Aa=0.98; Ap=3 #magnitude and angle of constant A\n",
    "Ba=110 ;Bp=75 #magnitude and angle of constant B\n",
    "p=50      #given power 50\n",
    "pf=0.8   #given power factor is 0.8\n",
    "vr=132   #voltage at reseving station\n",
    "vs=132  #voltage at source station to be maintained\n",
    "vsr1=p*pf+(Aa*(vr**2)/Ba)*cos(pi/180*(Bp-Ap))\n",
    "ph=vsr1*Ba/(vs*vr)\n",
    "phh=acos(ph)*180/pi\n",
    "Del=Bp-phh\n",
    "qrr=((vs*vr/Ba)*sin(phh*pi/180))-((Aa*(vr)**(2)/Ba)*sin((Bp-Ap)*pi/180))  #reactive power to maintain voltage equal\n",
    "qrre=p*sin(acos(pf)) #reactive power for the load\n",
    "qrc=qrre-qrr\n",
    "print \"the reactive power supply and reseving power is %dkV \\nreactive power %.2fMvar\"%(vs,qrr)\n",
    "print \"\\nthe required compensator network neeeded %.2fMvar\"%(qrc)\n",
    "print '(b)'\n",
    "cosb=(Aa*cos(pi/180*(Bp-Ap))*(vr)**(2)/Ba)*(Ba/(vs*vr)) #under no oad condition\n",
    "phb=acos(cosb)*180/pi\n",
    "qrb=(vs*vr*sin(phb*pi/180)/Ba)-(Aa*vr*vr*sin(pi/180*(Bp-Ap))/Ba)\n",
    "if qrb>0 :\n",
    "    print \"thus under no load condition the line delivers %.2fMvar at receiving end.the reactive power must be absorbed by shunt reactor at receving end. thus the capacity of shunt reactor, for no load condition is %.2fMvar. \"%(qrb,qrb)\n",
    "else:\n",
    "    print \"thus under no load condition the line absorbs %.2fMvar at receiving end.the reactive power must be delivered by shunt reactor at receving end. or reactive must suppiled by the source thus the capacity of shunt reactor, for no load condition is %.2fMvar. \"%(qrb,qrb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## example 14.15 Page 326"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " tapping ratio at the source 1.058  \n",
      " tapping ratio at the receving end 0.94\n"
     ]
    }
   ],
   "source": [
    "from math import sqrt,acos,sin,pi\n",
    "v=220  #line voltage\n",
    "ps=11 ; ss=220; pr=220 ;sr=11  #primer and secondary end terminal voltages of tapping transformer\n",
    "zr=20; zi=60  #impedence of line in real ndimagenary parts\n",
    "p=100  #power at recieving end is 100MVA\n",
    "pf=0.8  #power factor at recievin t=1   #prodect of 2 off terminal tap setting is  1\n",
    "vt=11  #tap setting for 11 kv voltage bus\n",
    "P=(p*pf*10**6)/3 #real power \n",
    "Q=(p*sin(acos(pf))*10**6)/3  #reactance power\n",
    "v1=v*(10**3)/sqrt(3)\n",
    "ts=(1/(1-(zr*P+zi*Q)/(v1**2)))**(0.5)\n",
    "print \" tapping ratio at the source %.3f  \\n tapping ratio at the receving end %.2f\"%(ts,1/ts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## example 14.16 page 327"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(a)\n",
      "vn=0.853.p.u \n",
      " vn=112.628kV\n",
      "(b)\n",
      "vn=1.021.p.u \n",
      " vn=134.772kV\n",
      "\n",
      " transformation ratio under load condition 3.413 \n",
      " transformation ratio under no load condition 4.084 \n",
      " the actual ratio can be taken as mean of the above value i.e.3.748percent\n",
      " varying by (+/-)0.336percent\n"
     ]
    }
   ],
   "source": [
    "from math import sqrt,acos,sin,pi\n",
    "vp=132; vs=33; vt=11  #voltage at primary ,secondary ,teritiory\n",
    "pp=75; ps=50; pt=25  #MVA rating at prinary ,secondary,teritiory \n",
    "rpr=0.12 ;rv=132; rp=75  #reactance power of primary under rv and rp as voltage and power base\n",
    "poa=60 ;rea=50  #load real and reactive power a\n",
    "pva=125 ;svaa=33 #primary and secondary voltage a\n",
    "svsb=25 ;pvb=140; svbb=33  #primary and secondary voltage at no load\n",
    "print '(a)'\n",
    "vbas=132  ;mvabas=75  #assume voltage and MVA base   \n",
    "v1pu=pva/vbas   #voltage in per unit\n",
    "v1apu=round(v1pu*1000)/1000  #rounding off \n",
    "qre=rea/mvabas  #reactive power in per unit\n",
    "vn1a=(v1apu+sqrt(v1apu**2-4*rpr*qre))/2  #voltage using quadratic equation formulae\n",
    "vn2a=(v1apu-sqrt(v1apu**2-4*rpr*qre))/2\n",
    "vnaa=vn1a*vbas\n",
    "v12=pvb/vbas\n",
    "q=svsb/mvabas\n",
    "vn1b=(v12+sqrt(v12**2-4*rpr*q))/2  #voltage using quadratic equation formulae\n",
    "vn1b=round(vn1b*1000)/1000\n",
    "vnbb=vn1b*vbas    #vn in no load condition\n",
    "print \"vn=%.3f.p.u \\n vn=%.3fkV\"%(vn1a,vnaa)\n",
    "print '(b)'\n",
    "print \"vn=%.3f.p.u \\n vn=%.3fkV\"%(vn1b,vnbb)\n",
    "z=vnaa/svaa ;x=vnbb/svbb \n",
    "print \"\\n transformation ratio under load condition %.3f \\n transformation ratio under no load condition %.3f \\n the actual ratio can be taken as mean of the above value i.e.%.3fpercent\\n varying by (+/-)%.3fpercent\"%(z,x,(z+x)/2,x-(z+x)/2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## example 14.7 page 331"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " generation at the plant a is 160MW and \n",
      " generation at the plant b is 40MW \n",
      " transfer power from plant a to b is 60MW\n"
     ]
    }
   ],
   "source": [
    "ca=200  #capacity of unit a\n",
    "cb=100   #capacity of unit b\n",
    "ra=1.5    #speed regulation of unit a   \n",
    "rb=3      #speed regulation of unit b\n",
    "f=50       #frequency\n",
    "pla=100    #load on each bus\n",
    "plb=100\n",
    "raa=ra*f/(pla*ca)\n",
    "rbb=rb*f/(plb*cb)\n",
    "pa=rbb*(pla+plb)/(raa+rbb)\n",
    "pb=pla+plb-pa\n",
    "tp=pa-pla\n",
    "print \" generation at the plant a is %dMW and \\n generation at the plant b is %dMW \\n transfer power from plant a to b is %dMW\"%(pa,pb,tp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## example 14.18 Page 332"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the current transfer is 1312.2A at an angle -36.87\n",
      "\n",
      "voltage drop in the interconnector is 3542.83+j1443.38V \n",
      "so voltage boost needed is 3542.83+j1443.38V \n"
     ]
    }
   ],
   "source": [
    "from math import sqrt,acos,sin,pi\n",
    "za=1.5 ;zb=2.5 #impedence between two lines \n",
    "v=11  #plant operatio\\ng voltage\n",
    "l=20  ; pf=0.8  #load at 20 MW at 0.8 pf\n",
    "i=l*10**3/(v*pf*sqrt(3)) ;ph=-acos(pf)*180/pi #current and phase angle of transfrming current\n",
    "vd=complex(za,zb)*complex(i*cos(ph*pi/180),i*sin(ph*pi/180))  #voltage drop due to loss\n",
    "print \"the current transfer is %.1fA at an angle %.2f\"%(i,ph)\n",
    "print \"\\nvoltage drop in the interconnector is %.2f+j%.2fV \\nso voltage boost needed is %.2f+j%.2fV \"%(vd.real,vd.imag,vd.real,vd.imag)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## example 14.19 Page 332"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(a)\n",
      "load angle is 1.00\n",
      "\n",
      "real power is 0.933p.u \n",
      "reactive power 0.361p.u leading\n",
      "(b)\n",
      "load angle is 1.00\n",
      "\n",
      "real power is 0.981p.u \n",
      "reactive power 0.192p.u lagging\n"
     ]
    }
   ],
   "source": [
    "from math import atan, cos,acos,pi\n",
    "zaa=3 ;zbb=9  #impedence given between line\n",
    "pas=1   #power at two units are equal to 1p.u \n",
    "par=1    \n",
    "pbs=1.05  #power at sending end is 1.05 and power at receiving end is 1p.u\n",
    "pbr=1\n",
    "i=1 #assume current is 1p.u\n",
    "los=i*complex(zaa/100,zbb/100)\n",
    "csd=((abs(los)**2)-pas**2-par**2)/(2*pas*par)  #load angle between two stations\n",
    "csa=(pas**2+abs(los)**2-par**2)/(2*pas*abs(los))  #angle between source and loss\n",
    "ta=180-atan(zbb/zaa)*180/pi-acos(csa)*180/pi  #transfering power factor angle\n",
    "print \"(a)\"\n",
    "print \"load angle is %.2f\\n\"%(cos(csd*pi/180))\n",
    "if sin(ta*pi/180)<0:\n",
    "    print \"real power is %.3fp.u \\nreactive power %.3fp.u lagging\"%(cos(ta*pi/180),abs(sin(ta*pi/180)))\n",
    "else:\n",
    "    print \"real power is %.3fp.u \\nreactive power %.3fp.u leading\"%(cos(ta*pi/180),sin(ta*pi/180))\n",
    "\n",
    "csd2=(abs(los)**2-pbs**2-pbr**2)/(2*pbs*pbr)  #load angle between two stations\n",
    "csa2=(pbr**2-pbs**2+abs(los)**2)/(2*pbr*abs(los))  #angle between source and loss\n",
    "f=180-atan(zbb/zaa)*180/pi-acos(csa2)*180/pi  #transfering power factor angle\n",
    "print '(b)'\n",
    "\n",
    "print \"load angle is %.2f\\n\"%(cos(csd2*pi/180))\n",
    "if sin(f*pi/180)<0 :\n",
    "    print \"real power is %.3fp.u \\nreactive power %.3fp.u lagging\"%(cos(f*pi/180),abs(sin(f*pi/180)))\n",
    "else:\n",
    "    print \"real power is %.3fp.u \\nreactive power %.3fp.u leading\"%(cos(f*pi/180),sin(f*pi/180))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}