{
 "metadata": {
  "name": "",
  "signature": "sha256:1c5f89ed0470787a153a235132b85821455bc93d217ca226b9eba94372c90683"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Chapter 9: Electrical Design of Overhead\n",
      "Lines"
     ]
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Example 9.1, Page Number: 214"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from __future__ import division\n",
      "import math\n",
      "\n",
      "#Variable declaration:\n",
      "d = 200                     #Spacing of conductors(cm)\n",
      "r = 1.2/2                   #Radius of conductor(cm)\n",
      "\n",
      "\n",
      "#Calculation:\n",
      "L = 10**-7*(1+4*math.log(d/r))*10**3  #Loop inductance per m length of the line(H)\n",
      "\n",
      "\n",
      "#Result:\n",
      "print \" The loop inductance per km of the line is\",round(L*1000,3),\"mH\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " The loop inductance per km of the line is 2.424 mH\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Example 9.2, Page Number: 214"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from __future__ import division\n",
      "import math\n",
      "\n",
      "#Variable declaration:\n",
      "d = 300                     #Spacing of conductors(cm)\n",
      "r = 1                      #Radius of conductor(cm)\n",
      "u1 = 1                     #relative permeability of copper\n",
      "u2 = 100                    #relative permeability of steel\n",
      "\n",
      "#Calculation:\n",
      "#(i) With copper conductors,\n",
      "Lc = 10**-7*(u1+4*math.log(d/r))*10**3     #Loop inductance/km\n",
      "\n",
      "#(ii) With steel conductors,\n",
      "Ls = 10**-7*(u2+4*math.log(d/r))*10**3      ##Loop inductance/km\n",
      "\n",
      "\n",
      "#Result:\n",
      "print \"The loop inductance per km length of the line are:\"\n",
      "print \"(i) for copper, Lc\",round(Lc*1000,2),\"mH and\"\n",
      "print \"(ii) for steel line, Ls =\",round(Ls*1000,2),\"mH\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "The loop inductance per km length of the line are:\n",
        "(i) for copper, Lc 2.38 mH and\n",
        "(ii) for steel line, Ls = 12.28 mH\n"
       ]
      }
     ],
     "prompt_number": 2
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Example 9.3, Page Number: 214"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from __future__ import division\n",
      "import math\n",
      "\n",
      "#Variable declaration:\n",
      "d = 200                   #cm\n",
      "r = 0.62                   #conductor radius(cm)\n",
      "\n",
      "\n",
      "#Calculation:\n",
      "L = 10**-7*(0.5+2*math.log(d/r))*10**3             #Inductance/phase/km\n",
      "\n",
      "#Result:\n",
      "print \"The inductance per km of a 3-ph transmission line is\",round(L*10**3,1),\"mH\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "The inductance per km of a 3-ph transmission line is 1.2 mH\n"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Example 9.4, Page Number: 214"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from __future__ import division\n",
      "import math\n",
      "\n",
      "#Variable declaration:\n",
      "D12 = 2                   #m\n",
      "D23 = 2.5                 #m\n",
      "D13 = 4.5                  #m\n",
      "r = 0.62                  #m\n",
      "\n",
      "#Calculation:\n",
      "Deq = (D12*D23*D13)**(1/3)*100         #Equivalent equilateral spacing(cm)\n",
      "L = 10**-7*(0.5+2*math.log(Deq/r))*10**3\n",
      "\n",
      "\n",
      "#Result:\n",
      "print \"The inductance per km of the line is\",round(L*1000,3),\"mH\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "The inductance per km of the line is 1.274 mH\n"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Example 9.5, Page Number: 214"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from __future__ import division\n",
      "import math\n",
      "\n",
      "#Variable declaration:\n",
      "r = 1.25                     #cm\n",
      "D12 = 2                       #m\n",
      "D23 = 2                       #m\n",
      "D13 = 4                       #m\n",
      "\n",
      "\n",
      "#Calculation:\n",
      "Deq = (D12*D23*D13)**(1/3)*100         #Equivalent equilateral spacing(m)\n",
      "L = 10**-7*(0.5+2*math.log(Deq/r))*10**3\n",
      "\n",
      "\n",
      "#Result:\n",
      "print \"The inductance per km of the line is\",round(L*1000,2),\"mH\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "The inductance per km of the line is 1.11 mH\n"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Example 9.6, Page Number: 214"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from __future__ import division\n",
      "import math\n",
      "\n",
      "#Variable declaration:\n",
      "r = 0.5                          #radius of conductor(m)\n",
      "Dab = 25                          #cm\n",
      "Daa1 = 100                        #cm\n",
      "Dbb1 = 100                        #cm\n",
      "Dab1 = 103                        #cm\n",
      "Da1b = 103                        #cm\n",
      "Da1b1 = 25                        #cm\n",
      "\n",
      "#Calculation:\n",
      "GMR = 0.7788*r                    #G.M.R. of conductor(cm)\n",
      "Ds = (GMR*Daa1)**(1/2)               #Self G.M.D. of aa1 combination(cm)\n",
      "Dm = (Dab*Dab1*Da1b*Da1b1)**(1/4)   #Mutual G.M.D. between a and b(cm)\n",
      "L1 = 2*10**-7*math.log(Dm/Ds)       #Loop inductance per conductor per m(H)\n",
      "L = 2*L1*1000\n",
      "\n",
      "#Result:\n",
      "print \"The inductance per km of the line is\",round(L*1000,2),\"mH\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "The inductance per km of the line is 0.84 mH\n"
       ]
      }
     ],
     "prompt_number": 6
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Example 9.7, Page Number: 216"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from __future__ import division\n",
      "import math\n",
      "\n",
      "\n",
      "#Variable declaration:\n",
      "r = 1.3                            #conuctor radius(cm)\n",
      "Dab = 3                            #m\n",
      "Dab1  = 6.7                        #m\n",
      "Da1b = 6.7                         #m\n",
      "Da1b1 = 3                          #m\n",
      "Daa1 = 8.48                        #m\n",
      "Da1a = 8.48                        #m\n",
      "Dbb1 = 6                           #m\n",
      "Db1b = 6                           #m\n",
      "Dca = 6                            #m\n",
      "Dc1a = 6                           #m\n",
      "Dca1 = 6                           #m\n",
      "Dc1a1 = 6                          #m\n",
      "\n",
      "#Calculation:\n",
      "GMR = 1.3*0.7788/100                   #m\n",
      "Daa = GMR\n",
      "Da1a1 = GMR\n",
      "Dbb = GMR\n",
      "Db1b1 = GMR\n",
      "Ds1 = (Daa*Daa1*Da1a1*Da1a)**(1/4)             #m\n",
      "Ds2 = (Dbb*Dbb1*Db1b1*Db1b)**(1/4)             #m\n",
      "Ds = (Ds1*Ds2*Ds1)**(1/3)                       #m\n",
      "DAB = (Dab*Dab1*Da1b*Da1b1)**(1/4)             #m\n",
      "DBC = DAB\n",
      "DCA = (Dca*Dc1a*Dca1*Dc1a1)**(1/4)             #m\n",
      "Dm = (DAB*DBC*DCA)**(1/3)            #Equivalent mutual G.M.D(m)\n",
      "\n",
      "L1 = 2*10**-7*math.log(Dm/Ds)       #Loop inductance per conductor per m(H)\n",
      "L = L1*1000\n",
      "\n",
      "#Result:\n",
      "print \"The inductance per km of the line is\",round(L*1000,2),\"mH\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "The inductance per km of the line is 0.58 mH\n"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Example 9.8, Page Number: 217"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from __future__ import division\n",
      "import math\n",
      "\n",
      "#Variable Declaration:\n",
      "r = 0.75                            #conductor radius(cm)\n",
      "Db1b = 5.5                       #m\n",
      "Dca = 6                         #m\n",
      "Dca1 = 4                         #m\n",
      "Dc1a = 4                          #m\n",
      "Dc1a1 = 6                        #m\n",
      "\n",
      "\n",
      "#Calculation:\n",
      "GMR = 0.7788*r                     #m\n",
      "Dab = (3**2+0.75**2)**0.5         #m\n",
      "Dab1 = (3**2+4.75**2)**0.5         #m\n",
      "Daa1 = (6**2+4**2)**0.5            #m\n",
      "Daa = GMR/100                      #m\n",
      "Da1a1 = Daa                       #m\n",
      "Da1a = Daa1                      #m\n",
      "Dbb = GMR/100                      #m\n",
      "Dbb1 = 5.5                       #m\n",
      "Db1b1 = Dbb                      #m\n",
      "\n",
      "Ds1 = (Daa*Daa1*Da1a1*Da1a)**(1/4)          #m\n",
      "Ds2 = (Dbb*Dbb1*Db1b1*Db1b)**(1/4)          #m\n",
      "Ds3 = Ds1\n",
      "Ds = (Ds1*Ds2*Ds3)**(1/3)       #Equivalent self G.M.D. of one phase(m)\n",
      "DAB = (Dab*Dab1*Da1b*Da1b1)**(1/4)   #m\n",
      "DCA = (Dca*Dca1*Dc1a*Dc1a1)**(1/4)    #m\n",
      "DBC = DAB                             #m\n",
      "Dm = (DAB*DBC*DCA)**(1/3)             #Equivalent mutual G.M.D.(m)\n",
      "\n",
      "\n",
      "L1 = 2*10**-7*math.log(Dm/Ds)       #Loop inductance per conductor per m(H)\n",
      "L = L1*1000\n",
      "\n",
      "#Result:\n",
      "print \"The inductance per km of the line is\",round(L*1000,3),\"mH\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "The inductance per km of the line is 0.627 mH\n"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Example 9.9, Page Number: 218"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from __future__ import division\n",
      "import math\n",
      "\n",
      "#Variable Declaration:\n",
      "r = 5.3/100                   #conductor radius(m)\n",
      "\n",
      "#Calculation:\n",
      "GMR = 0.7788*r                          #m\n",
      "DAA = GMR                                #m\n",
      "DAA1 = 24                                #m\n",
      "DA1A1 = DAA                              #m\n",
      "DA1A = 24                                #m\n",
      "\n",
      "DBB = GMR                                #m\n",
      "DBB1 = 24                                #m\n",
      "DB1B1 = DBB                              #m\n",
      "DB1B = 24                                #m\n",
      "Ds1 = (DAA*DAA1*DA1A1*DA1A)**(1/4)        #m\n",
      "Ds2 = (DBB*DBB1*DB1B1*DB1B)**(1/4)        #m\n",
      "#Similarly:\n",
      "Ds3 = 0.995                              #m\n",
      "Ds = (Ds1*Ds2*Ds3)**(1/3)   #Equivalent self-G.M.D. of one phase(m)\n",
      "#DAB = (DAB \u00d7 DAB\u2032 \u00d7 DA\u2032\u0392 \u00d7 DA\u2032B\u2032)**1/4\n",
      "DAB = (8*32*16*8)**(1/4)                 #m\n",
      "DBC = DAB                               #m\n",
      "#DCA = (DCA \u00d7 DCA\u2032 \u00d7 DC\u2032A \u00d7DC\u2032A\u2032)1/4    #m\n",
      "DCA = (16*8*40*16)**(1/4)                 #m\n",
      "\n",
      "Dm = (DAB*DBC*DCA)**(1/3)                   #m\n",
      "\n",
      "L = 2*10**-7*math.log(Dm/Ds)       #Loop inductance per conductor per m(H)\n",
      "\n",
      "\n",
      "#Result:\n",
      "print \"The inductance per m of the line is\",round(L*10**7,2),\"* 10**-7  H/m\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "The inductance per m of the line is 5.36 * 10**-7  H/m\n"
       ]
      }
     ],
     "prompt_number": 9
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Example 9.10, Page Number: 219"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from __future__ import division\n",
      "import math\n",
      "\n",
      "#Variable Declaration:\n",
      "r = 1                            #consuctor radius(cm)\n",
      "\n",
      "#Calculation:\n",
      "#Mutual G.M.D., Dm = (Dab*Dab'*Da'b*Da'b')**(1/4)\n",
      "Dm = (120*140*100*120)**(1/4)          #m\n",
      "\n",
      "#Self G.M.D., Ds = (Daa*Daa'*Da'a'*Da'a)**(1/4)\n",
      "#Daa = Da'a' = 0.7788 cm; Daa' = Da'a = 20 cm\n",
      "Ds = (0.7788*20*0.7788*20)**(1/4)         #cm\n",
      "L = 4*10**-4*math.log(Dm/Ds)              #H/km\n",
      "\n",
      "#Result:\n",
      "print \"The total inductance of the line per km is\",round(L*1000,2),\"mH/km\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "The total inductance of the line per km is 1.36 mH/km\n"
       ]
      }
     ],
     "prompt_number": 10
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Example 9.11, Page Number: 224"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from __future__ import division\n",
      "import math\n",
      "\n",
      "#Variable declaration:\n",
      "r = 1                         #conductor radius(cm)\n",
      "d = 300                       #conductor spacing(cm)\n",
      "e = 8.854*10**-12             #permitivity of free space(F/m)\n",
      "\n",
      "\n",
      "#Calculation:\n",
      "C = math.pi*e/math.log(d/r)         #F/m\n",
      "\n",
      "#Result:\n",
      "print \"Capacitance of the line per km is\",round(C*10**11,4),\"* 10**-2  uF/km\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Capacitance of the line per km is 0.4877 * 10**-2  uF/km\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Example 9.12, Page Number: 225"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from __future__ import division\n",
      "import math\n",
      "\n",
      "#Variable declaration:\n",
      "r = 0.625                         #conductor radius(cm)\n",
      "d = 200                       #conductor spacing(cm)\n",
      "e = 8.854*10**-12             #permitivity of free space(F/m)\n",
      "\n",
      "\n",
      "#Calculation:\n",
      "C = 2*math.pi*e/math.log(d/r)         #F/m\n",
      "\n",
      "#Result:\n",
      "print \"Capacitance of the line per km is\",round(C*10**9,4),\"  uF/km\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Capacitance of the line per km is 0.0096   uF/km\n"
       ]
      }
     ],
     "prompt_number": 2
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Example 9.13, Page Number: 225"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from __future__ import division\n",
      "import math\n",
      "\n",
      "#Variable Declaration:\n",
      "d1 = 2                       #m\n",
      "d2 = 2.5                     #m\n",
      "d3 = 4.5                     #m\n",
      "r = 0.625                    #conductor raius(cm)\n",
      "l = 100                      #line length(km)\n",
      "Vl = 66000                  #line voltage(V)\n",
      "f = 50                       #frequency of current(Hz)\n",
      "e = 8.854*10**-12             #permitivity of free space(F/m)\n",
      "\n",
      "#Calculation:\n",
      "d = (d1*d2*d3)**(1/3)*100          #cm\n",
      "\n",
      "#(i)Line to neutral capacitance,\n",
      "C1 = 2*math.pi*e/math.log(d/r)*10**9     #uF/km\n",
      "C11 = C1*100                           #uF\n",
      "\n",
      "#(ii)Charging current per phase,\n",
      "Ic = Vl*2*math.pi*f*C11*10**-6/(3**0.5)      #A\n",
      "\n",
      "\n",
      "#Result:\n",
      "print \"Capacitance per phase is\",round(C11,2),\"uF\"\n",
      "print \"Charging current per phase is\",round(Ic,1),\"A\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Capacitance per phase is 0.91 uF\n",
        "Charging current per phase is 10.9 A\n"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Example 9.14, Page Number: 225"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from __future__ import division\n",
      "import math\n",
      "\n",
      "#Variable declaration:\n",
      "r = 1                        #conductor radius(cm)\n",
      "d = 250                      #equilateral conductor spacing(cm)\n",
      "e = 8.854*10**-12             #permitivity of free space(F/m)\n",
      "\n",
      "\n",
      "#Calculation:\n",
      "C = 2*math.pi*e/math.log(d/r)*10**9         #uF/km\n",
      "C1 = C*100                       #F\n",
      "\n",
      "#Result:\n",
      "print \"Capacitance of the line per km is\",round(C1,4),\"uF/phase\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Capacitance of the line per km is 1.0075 uF/phase\n"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "heading",
     "level": 3,
     "metadata": {},
     "source": [
      "Example 9.15, Page Number: 226"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from __future__ import division\n",
      "import math\n",
      "\n",
      "#Variable Declaration:\n",
      "d1 = 4                        #m\n",
      "d2 = 4                        #m\n",
      "d3 = 8                        #m\n",
      "r = 1                         #conductor raius(cm)\n",
      "l = 100                       #line length(km)\n",
      "Vl = 132000                    #line voltage(V)\n",
      "f = 50                        #frequency of current(Hz)\n",
      "e = 8.854*10**-12             #permitivity of free space(F/m)\n",
      "\n",
      "#Calculation:\n",
      "Deq = (d1*d2*d3)**(1/3)*100          #cm\n",
      "C = 2*math.pi*e/math.log(Deq/r)*10**9     #uF/km\n",
      "C1 = C*100                           #uF\n",
      "Ic = Vl*2*math.pi*f*C1*10**-6/(3**0.5)      #A\n",
      "\n",
      "\n",
      "#Result:\n",
      "print \"Charging current per phase is\",round(Ic,2),\"A\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Charging current per phase is 21.41 A\n"
       ]
      }
     ],
     "prompt_number": 1
    }
   ],
   "metadata": {}
  }
 ]
}