{
 "metadata": {
  "name": ""
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Chapter 2: Thyristors"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.1, Page No.39 "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Anode current\n",
      "\n",
      "import math\n",
      "#Variable declaration\n",
      "alfa_1 = 0.35         # Gain of PNP transistor of two transistor model\n",
      "alfa_2 = 0.40         # Gain of NPN transistor of two transistor model\n",
      "Ig = 40*10**-3        # Gate current\n",
      "\n",
      "\n",
      "#Calculations\n",
      "Ia = (alfa_2*Ig)/(1-(alfa_1+alfa_2))\n",
      "\n",
      "#Result\n",
      "print(\"Anode current = %d * 10^-3 A\"%(Ia*1000))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Anode current = 64 * 10^-3 A\n"
       ]
      }
     ],
     "prompt_number": 2
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.2, Page No.41"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Equivalent capacitor\n",
      "\n",
      "import math\n",
      "# Variable declaration\n",
      "dv_by_dt = 190                # in Volt per micro-sec\n",
      "Ic= 8 *10**-3                 # Capacitive current\n",
      "\n",
      "#Calculation\n",
      "C = Ic/(dv_by_dt*10**6)\n",
      "\n",
      "#Result\n",
      "print(\"C = %.1f * 10^12 F\"%(C*10**12))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "C = 42.1 * 10^12 F\n"
       ]
      }
     ],
     "prompt_number": 6
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.3, Page No. 42"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Thyristor\n",
      "\n",
      "import math\n",
      "# Variable declaration\n",
      "Vt = 0.75               # Thyristor trigger voltage\n",
      "It = 7*10**-3           # Thyristor trigger current\n",
      "Vcc = 20                # Suppy voltage, given data\n",
      "Rg = 2000               # gate resistor, given data\n",
      "R = 200                 # input resistor\n",
      "\n",
      "#Calculations\n",
      "#(a)\n",
      "V0 = 20                 # when thyristor is not conducting, there is no current through it.\n",
      "#(b)\n",
      "Vs = Vt+It*Rg\n",
      "#(c)\n",
      "i= 5*10**-3              #to have holding curernt\n",
      "v1= i*R\n",
      "#(d)\n",
      "drop =0.7                # voltage drop across thyristor\n",
      "v2=v1+drop\n",
      "\n",
      "#Result\n",
      "print(\"(a) V0 = %d\\n(b) Vs = %.2f\\n(c) Vcc should be reduced to less than %d V if thyristor is ideal.\\n(d) Vcc should be reduced to less than %.1f V\"%(V0,Vs,v1,v2))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(a) V0 = 20\n",
        "(b) Vs = 14.75\n",
        "(c) Vcc should be reduced to less than 1 V if thyristor is ideal.\n",
        "(d) Vcc should be reduced to less than 1.7 V\n"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.4, Page No.42"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# calculation of Vg,Ig and Rg\n",
      "\n",
      "import math\n",
      "#variable declaration\n",
      "Vs = 25                      # gate signal amplitude\n",
      "Pavg_loss = 0.6              # Avg power loss\n",
      "\n",
      "#Calculations\n",
      "P_loss = Pavg_loss*2*math.pi/math.pi\n",
      "Ig =(-1+(math.sqrt(1**2-4*9*(-1.2))))/(2*9) #alfa=(-b+sqrt(b^2-4ac))/2a-->solution for quadratic equation\n",
      "Ig = math.ceil(Ig*1000)/1000\n",
      "Vg = 1+9*Ig                                 #given data\n",
      "Rg = (24-9*Ig)/Ig\n",
      "\n",
      "#Calculations\n",
      "print(\"Vg = %.3f \\nIg = %.3f\\nRg = %.2f\"%(Vg,Ig,Rg))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Vg = 3.826 \n",
        "Ig = 0.314\n",
        "Rg = 67.43\n"
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.5, Page No.42"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Minimum width of gate pulse\n",
      "\n",
      "import math\n",
      "#Variable declaration\n",
      "V = 100                   # DC supply voltage\n",
      "L = 10                    # Inductance\n",
      "i = 80*10**-3             # latching current of thyristor\n",
      "\n",
      "#Calculations\n",
      "t = L*i/V\n",
      "\n",
      "#Result\n",
      "print(\"Width of pulse should be more than %d milli-second.\"%(t*10**3))\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Width of pulse should be more than 8 milli-second.\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.6, Page No. 43"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Minimum width of gate pulse\n",
      "\n",
      "import math\n",
      "#Variable declaration\n",
      "V = 100                   # DC supply voltage\n",
      "R = 10                    # Resistance\n",
      "L = 5                     # Inductance\n",
      "i = 50*10**-3             # latching current of thyristor\n",
      "\n",
      "#Calculation\n",
      "t = math.log((1-(i*R)/V))/((-R/L)*math.log(math.e))        # i = (V/R)*(1-e^(-R*t/L))\n",
      "\n",
      "#Result\n",
      "print(\"Minimum width of gate pulse is %.1f milli-second.\"%(t*10**3))\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Minimum width of gate pulse is 2.5 milli-second.\n"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.7, Page No. 43"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# resistor value\n",
      "\n",
      "import math\n",
      "#Variable declaration\n",
      "V = 90.0                # DC supply voltage\n",
      "i = 40*10**-3           # latching current of thyristor\n",
      "t = 40* 10**-6          # pulse width\n",
      "R = 25.0                # load Resistance\n",
      "L = 0.5                 # Inductance\n",
      "#Calculation\n",
      "#(a)\n",
      "i2 = (V/R)*(1-math.e**(-R*t/L))\n",
      "\n",
      "#(b)\n",
      "R = V/(i-i2)\n",
      "\n",
      "#Result\n",
      "print(\"(a)\\nAt the end of the gate pulse, i = %.4f A\"%i2)\n",
      "print(\"Since the current is less than latching current, thyristor will not turn on.\")\n",
      "print(\"\\n(b)\\nR should be less than %d ohm.\"%math.ceil(R))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(a)\n",
        "At the end of the gate pulse, i = 0.0072 A\n",
        "Since the current is less than latching current, thyristor will not turn on.\n",
        "\n",
        "(b)\n",
        "R should be less than 2744 ohm.\n"
       ]
      }
     ],
     "prompt_number": 18
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.8, Page No.44"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Resistor value\n",
      "\n",
      "import math\n",
      "#Variable declaration\n",
      "V = 100.0                # DC supply voltage\n",
      "i = 50*10**-3            # holding current of thyristor\n",
      "t = 50* 10**-6           # pulse width\n",
      "R = 20.0                 # load Resistance\n",
      "L = 0.5                  # Inductance\n",
      "\n",
      "#Calculations\n",
      "i2 = (V/R)*(1-math.e**(-R*t/L))\n",
      "Rmax = V/(i-i2)\n",
      "\n",
      "#Result\n",
      "print(\"When firing pulse ends, i = %.2f mA\"%(i2*10**3))\n",
      "print(\"Since this current is less than holding current, the thyristor will not remain on and return to off state.\")\n",
      "print(\"Maximum value of R = %.3f ohm\"%(math.floor(Rmax*1000)/1000))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "When firing pulse ends, i = 9.99 mA\n",
        "Since this current is less than holding current, the thyristor will not remain on and return to off state.\n",
        "Maximum value of R = 2499.375 ohm\n"
       ]
      }
     ],
     "prompt_number": 26
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.9, Page No.44"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# triggering angle \n",
      "\n",
      "import math\n",
      "#Variable declaration\n",
      "V = 240                  # AC supply voltage\n",
      "f = 50                   # supply frequency\n",
      "R = 5                    # load resistance\n",
      "L = 0.05                 # inductance\n",
      "\n",
      "#Calculation\n",
      "theta = math.atan(2*math.pi*f*L/R)\n",
      "theta = theta*180/math.pi\n",
      "fi = theta+90\n",
      "print(\"theta = %.2f\u00b0\"%(theta))\n",
      "print(\"\\nCurrent transient is maximun(worst) if\\nsin(fi-theta) = 1\")\n",
      "print(\"therefore, fi-%.2f\u00b0 = 90\u00b0\"%theta)\n",
      "print(\"fi = %.2f\u00b0\"%fi)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "theta = 72.34\u00b0)\n",
        "\n",
        "Current transient is maximun(worst) if\n",
        "sin(fi-theta) = 1\n",
        "therefore, fi-72.34\u00b0 = 90\u00b0\n",
        "fi = 162.34\u00b0\n"
       ]
      }
     ],
     "prompt_number": 37
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.10, Page No.47"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(\"Theoretical example \")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Theoretical example \n"
       ]
      }
     ],
     "prompt_number": 38
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.11, Page No.50"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(\"Theoretical example \")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Theoretical example \n"
       ]
      }
     ],
     "prompt_number": 39
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.12, Page No. 53"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# rms current and form factor\n",
      "\n",
      "import math\n",
      "# variable declaration\n",
      "I = 120                 # Current in Ampere\n",
      "gamma = 180.0           # in degrees, thyristor conducts between alfa and alfa+gamma in each 360\u00b0 \n",
      "\n",
      "# calculations\n",
      "#(a)-- formulas\n",
      "#(b)\n",
      "Irms = I*math.sqrt(gamma/360)\n",
      "Iavg = I*(gamma/360)\n",
      "ff = Irms/Iavg\n",
      "\n",
      "#result\n",
      "print(\"RMS curent = %.2f A\\nAverage Current = %.0f A\\nForm factor = %.3f\"%(Irms,Iavg,ff))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "RMS curent = 84.85 A\n",
        "Average Current = 60 A\n",
        "Form factor = 1.414\n"
       ]
      }
     ],
     "prompt_number": 40
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.13, Page No.53"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Power supplied to the load and average load current\n",
      "\n",
      "import math\n",
      "from scipy.integrate import quad\n",
      "# variable declaration\n",
      "R = 100.0                       # load resistance\n",
      "V = 230.0                       # Supply Voltage\n",
      "\n",
      "#Calculations\n",
      "#(a)\n",
      "def f(x):\n",
      "    return math.sin(x)**2\n",
      "wt_lower=math.pi/3\n",
      "wt_upper =math.pi\n",
      "val = quad(f,wt_lower,wt_upper)\n",
      "I = ((math.sqrt(2)*V/R)**2)*val[0]/(2*math.pi)\n",
      "Irms = math.sqrt(I)\n",
      "P =(Irms**2)*R\n",
      "\n",
      "#(b)\n",
      "def f(x):\n",
      "    return math.sin(x)**2\n",
      "wt_lower2=math.pi/4\n",
      "wt_upper2 =math.pi\n",
      "val2 = quad(f,wt_lower2,wt_upper2)\n",
      "x = (math.sqrt(2)*V/R)\n",
      "x = math.floor(x*100)/100\n",
      "I2 = (x**2)*val2[0]/(2*math.pi)\n",
      "Irms2 = math.sqrt(I2)\n",
      "P2 =(Irms2**2)*R\n",
      "\n",
      "#(c)\n",
      "def f(x):\n",
      "    return (3.25/(2*math.pi))*math.sin(x)\n",
      "wt_lower3=math.pi/3\n",
      "wt_upper3 =math.pi\n",
      "val3 = quad(f,wt_lower3,wt_upper3)\n",
      "wt_lower4=math.pi/4\n",
      "wt_upper4 =math.pi\n",
      "val4 = quad(f,wt_lower4,wt_upper4)\n",
      "\n",
      "\n",
      "print(\"(a)\\nRMS current = %.2f A\\nPower supplied to load = %d W\"%(Irms,math.ceil(P)))\n",
      "print(\"\\n\\n(b)\\nRMS current = %f A\\nPower supplied to load = %f W\"%(Irms2,P2))\n",
      "print(\"\\n(c)\\nWhen firing angle is 60\u00b0, Average current = %.3f A\" %val3[0])\n",
      "print(\"When firing angle is 45\u00b0, Average current = %.3f A\" %val4[0])\n",
      "# for (b) answer matches to the book if val2[0] = 1.4255"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(a)\n",
        "RMS current = 1.46 A\n",
        "Power supplied to load = 213 W\n",
        "\n",
        "\n",
        "(b)\n",
        "RMS current = 1.549431 A\n",
        "Power supplied to load = 240.073727 W\n",
        "\n",
        "(c)\n",
        "When firing angle is 60\u00b0, Average current = 0.776 A\n",
        "When firing angle is 45\u00b0, Average current = 0.883 A\n"
       ]
      }
     ],
     "prompt_number": 81
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.14, Page No.54"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# average power loss in thyristor\n",
      "\n",
      "import math\n",
      "# Variable declaration\n",
      "Iavg = 200                  # Average current\n",
      "v1 = 1.8                    # voltage drop across thyristor for 200A current\n",
      "v2 = 1.9                    # voltage drop across thyristor for 400A current\n",
      "\n",
      "#Calculations\n",
      "#(a)\n",
      "A1 = Iavg                   # amplitude of rectangular current wave\n",
      "P1 = A1*v1\n",
      "#(b)\n",
      "A2 = 2*Iavg\n",
      "P2 = A2*v2*math.pi/(2*math.pi)\n",
      "\n",
      "#Result\n",
      "print(\"(a) Average power loss = %d W\"%P1)\n",
      "print(\"(b) Average power loss = %d W\"%P2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(a) Average power loss = 360 W\n",
        "(b) Average power loss = 380 W\n"
       ]
      }
     ],
     "prompt_number": 83
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.15, Page No.55"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# average on state current\n",
      "\n",
      "import math\n",
      "#Variable declaration\n",
      "I = 40                # rms on state current\n",
      "f = 50                # frequency\n",
      "cp_a =170             # conduction period\n",
      "cp_b =100             # conduction period\n",
      "cp_c =40              # conduction period\n",
      "\n",
      "#Calculations\n",
      "alfa_a = 180-cp_a\n",
      "alfa_b = 180-cp_b\n",
      "alfa_c = 180-cp_c\n",
      "Im_a = math.sqrt(((I**2)*2*math.pi)/(((math.pi-alfa_a*math.pi/180)/2)+math.sin(2*alfa_a*math.pi/180)/4))\n",
      "Iv_a = 0.316*Im_a\n",
      "Im_b = math.sqrt(((I**2)*2*math.pi)/(((math.pi-alfa_b*math.pi/180)/2)+math.sin(2*alfa_b*math.pi/180)/4))\n",
      "Iv_b = 0.1868*Im_b\n",
      "Im_c = math.sqrt(((I**2)*2*math.pi)/(((math.pi-alfa_c*math.pi/180)/2)+math.sin(2*alfa_c*math.pi/180)/4))\n",
      "Iv_c = 0.0372*Im_c\n",
      "\n",
      "#Result\n",
      "print(\"(a) Iavg = %.3f A\"%(math.ceil(Iv_a*1000)/1000))\n",
      "print(\"(b) Iavg = %.2f A\"%Iv_b)\n",
      "print(\"(c) Iavg = %.2f A\"%(math.floor(Iv_c*100)/100))\n",
      "#answer for(b) is not matching with the answer given in the book."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(a) Iavg = 25.295 A\n",
        "(b) Iavg = 19.13 A\n",
        "(c) Iavg = 11.62 A\n"
       ]
      }
     ],
     "prompt_number": 105
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.16, page No. 56"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# power dissiopation\n",
      "\n",
      "import math\n",
      "from scipy.integrate import quad\n",
      "#variable declaration\n",
      "It = 20                     # constant current\n",
      "\n",
      "#Calculations\n",
      "#(a)\n",
      "Vt = 0.9+ 0.02*It\n",
      "P1 = Vt*It\n",
      "#(b)\n",
      "def f(x):\n",
      "    return (0.9+0.02*(20*math.pi*math.sin(x)))*(20*math.pi*math.sin(x))/(2*math.pi)\n",
      "# if denominator math.pi value is taken as 3.14, then answer for P2 =37.75\n",
      "theta_lower = 0\n",
      "theta_upper = math.pi\n",
      "val = quad(f,theta_lower,theta_upper)\n",
      "P2 = val[0]\n",
      "#(c)\n",
      "P3 = P1/2\n",
      "#(d)\n",
      "P4 = P1/3\n",
      "\n",
      "#result\n",
      "print(\"(a) Power dissipation = %d W\"%P1)\n",
      "print(\"(b) Mean Power dissipation = %.2f W\"%P2)\n",
      "print(\"(c) Mean Power dissipation = %d W\"%P3)\n",
      "print(\"(d) Mean Power dissipation = %.2f W\"%P4)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(a) Power dissipation = 26 W\n",
        "(b) Mean Power dissipation = 37.74 W\n",
        "(c) Mean Power dissipation = 13 W\n",
        "(d) Mean Power dissipation = 8.67 W\n"
       ]
      }
     ],
     "prompt_number": 115
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.17, Page No. 57"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# I^2t rating \n",
      "\n",
      "import math\n",
      "# Variable declaration\n",
      "Is = 2000.0              # half cycle surge current rating for SCR\n",
      "f = 50.0                 # operating AC frequency\n",
      "\n",
      "#Calculation\n",
      "T = 1/f\n",
      "t_half = T/2\n",
      "t = t_half/2\n",
      "I = math.sqrt((Is**2)*t/t_half)\n",
      "rating = (I**2)*t_half\n",
      "\n",
      "#Result\n",
      "print(\"I^2t rating = %d A^2 secs\"%rating)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "I^2t rating = 20000 A^2 secs\n"
       ]
      }
     ],
     "prompt_number": 138
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.18, Page No. 59"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Resistance and average power loss\n",
      "\n",
      "import math\n",
      "#variable declaration\n",
      "P = 6                #peak power loss\n",
      "d = 0.3              # duty cylce   \n",
      "\n",
      "#calculations\n",
      "#(a)\n",
      "#solution of equation 9Ig^2+Ig-6 = 0\n",
      "Ig =(-1+(math.sqrt(1**2-4*9*(-6))))/(2*9)    #alfa=(-b+sqrt(b^2-4ac))/2a-->solution for quadratic equation\n",
      "Ig = math.ceil(Ig*1000)/1000\n",
      "Rg = (11/Ig)-9                               #from KVL equation of gate circuit\n",
      "#(b)\n",
      "Pavg = P*d\n",
      "\n",
      "#Result\n",
      "print(\"(a)\\nIg = %.3f A \\nRg = %.3f ohm\"%(Ig,Rg))\n",
      "print(\"\\n(b) Average power loss = %.1f W \"%Pavg)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(a)\n",
        "Ig = 0.763 A \n",
        "Rg = 5.417 ohm\n",
        "\n",
        "(b) Average power loss = 1.8 W \n"
       ]
      }
     ],
     "prompt_number": 144
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.19, Page No. 59"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# trigger current and voltage for gate power dissipation\n",
      "\n",
      "import math\n",
      "#variable declaration\n",
      "Vs = 12                  # supply voltage\n",
      "P = 0.3                  # Power dissipation\n",
      "Rs  = 100                # load line slope i.e. source resistance\n",
      "\n",
      "#Calculation\n",
      "#solution for equation 100Ig^2-12Ig+0.3 = 0\n",
      "Ig =(-(-Vs)-(math.sqrt((-Vs)**2-4*Rs*(P))))/(2*Rs)    #alfa=(-b(+/-)sqrt(b^2-4ac))/2a-->solution for quadratic equation\n",
      "Vg = P/Ig\n",
      "print(\"Ig = %.1f mA\\nVg = %.2f V\"%(Ig*1000,Vg))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Ig = 35.5 mA\n",
        "Vg = 8.45 V\n"
       ]
      }
     ],
     "prompt_number": 150
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.20, Page No. 59"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Finding values of resistors\n",
      "\n",
      "import math\n",
      "#Variable declaration\n",
      "Es = 12.0             # Supply voltage\n",
      "V = 800.0             # SCR voltage rating\n",
      "I = 110.0             # SCR currert rating\n",
      "imax = 250*10**-3     # Maximum permissible current through battery\n",
      "isc = 600*10**-3      # short circuit current of the battery\n",
      "Vg = 2.4              # required gate voltage\n",
      "Ig = 50*10**-3        # required gate current\n",
      "Vgmax = 3             # maximum gate voltage\n",
      "Igmax = 100*10**-3    # maximum gate current\n",
      "\n",
      "\n",
      "#Calculations\n",
      "Rs = Es/isc\n",
      "#considering R2 is not connected\n",
      "R1 =(Es/imax)-Rs\n",
      "#R1 must be 28 or more so that battery curenrt doesnot exceeds 250mA\n",
      "R1min = Es/Igmax-Rs\n",
      "R1max = ((Es-Vg)/Ig)-Rs\n",
      "R1 = 125  #selected \n",
      "R2 = Vgmax*(Rs+R1)/(Es-Vgmax)\n",
      "\n",
      "# Result\n",
      "print(\"Rs = %d ohm \\n\\nR1 must be more than %.0f ohm and must be less than %.0f ohm.\\nTherefore, select R1 = %.0f \"%(Rs,R1min,R1max,R1))\n",
      "print(\"\\nR2 should be less than %.3f ohm.\\nTherefore, select R2 = %.0f ohm\"%(R2,math.floor(R2)))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Rs = 20 ohm \n",
        "\n",
        "R1 must be more than 100 ohm and must be less than 172 ohm.\n",
        "Therefore, select R1 = 125 \n",
        "\n",
        "R2 should be less than 48.333 ohm.\n",
        "Therefore, select R2 = 48 ohm\n"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.21, Page No. 68"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Surface temperature\n",
      "\n",
      "import math\n",
      "#Variable declaration\n",
      "l = 0.2                 # length of aluminium rod\n",
      "w = 0.01                # width of aluminium rod\n",
      "d = 0.01                # depth of aluminium rod\n",
      "tc = 220                # thermal conductivity\n",
      "T1 = 30                 # temperature at far end\n",
      "P = 3                   # injected heat\n",
      "\n",
      "#Calculation\n",
      "theta = l/(tc*w*d)\n",
      "T2 = P*theta+T1\n",
      "\n",
      "#Result\n",
      "print(\"Temperature of the surface where heat is injected is %.2f\u00b0C\"%T2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Temperature of the surface where heat is injected is 57.27\u00b0C\n"
       ]
      }
     ],
     "prompt_number": 13
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.22, Page No. 68"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Power losses\n",
      "\n",
      "import math\n",
      "#variable declaration\n",
      "l = 2*10**-3            # lengthh of aluminium plate\n",
      "a = 12*10**-4           # cross-section area\n",
      "tc = 220                # thermal conductivity\n",
      "td = 4                  # desired thermal drop along length\n",
      "\n",
      "#Calculations\n",
      "theta = l/(a*tc)\n",
      "theta = math.floor(theta*10**6)/10**6\n",
      "P_loss = td/theta\n",
      "\n",
      "#Result\n",
      "print(\"power losses = %.2f W\"%P_loss)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "power losses = 528.05 W\n"
       ]
      }
     ],
     "prompt_number": 18
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.23, Page No. 68"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#thermal resistance of heat sink\n",
      "\n",
      "import math\n",
      "#Variable declaration\n",
      "P = 30.0              # power dissipation\n",
      "T1 =125.0             # max junction temperature\n",
      "T2 = 50.0             # max ambient temperature\n",
      "tr1 =1.0              # thermal resistance of thyristor\n",
      "tr2 = 0.3             # therrmal resistance of insuulator\n",
      "\n",
      "#calculations\n",
      "Tr = (T1-T2)/P\n",
      "Tr_hs = Tr-tr1-tr2\n",
      "\n",
      "#Result\n",
      "print(\"Thermal resistance of heat sink = %.1f\u00b0C/W\"%Tr_hs)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Thermal resistance of heat sink = 1.2\u00b0C/W\n"
       ]
      }
     ],
     "prompt_number": 23
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.24, Page No.68"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Junction temperature\n",
      "\n",
      "\n",
      "import math\n",
      "#variable declaration\n",
      "tr = 0.627              # thermal resistance of device\n",
      "T = 93                  # heat sink temperature\n",
      "V = 3                   # voltage at junction\n",
      "I = 25                  # current at junction\n",
      "\n",
      "#calculation\n",
      "T_junction = tr*V*I+T\n",
      "\n",
      "#Result\n",
      "print(\"Junction Temperature = %d\u00b0C\"%T_junction)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Junction Temperature = 140\u00b0C\n"
       ]
      }
     ],
     "prompt_number": 25
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.25, Page No. 68"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Thermal resistance\n",
      "\n",
      "import math\n",
      "#Variable declaration\n",
      "P = 40.0                #steady power loss in an SCR\n",
      "Tr_hs = 0.8             # heat sink resistance\n",
      "T1 = 120.0              # Maximumm junction temperature\n",
      "T2 = 35.0               # ambient temperature\n",
      "\n",
      "#calculation\n",
      "Tr = (T1-T2)/P\n",
      "Rsh = Tr - Tr_hs\n",
      "\n",
      "#Result\n",
      "print(\"Resistance of heat sink = %.3f\u00b0C/W\"%Rsh)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Resistance of heat sink = 1.325\u00b0C/W\n"
       ]
      }
     ],
     "prompt_number": 28
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.26, Page No. 69"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# power loss and % increase in rating\n",
      "\n",
      "import math\n",
      "# variable declaration\n",
      "Tj = 125                # maximum junction temperature\n",
      "Ts1 = 80                # max heat sink temperature\n",
      "tr_jc = 0.7             # thermal resistance from junction to case  \n",
      "tr_cs = 0.4             # thermal resistance from case to sink\n",
      "Ts2 = 50                # decreased heat sink temperature  \n",
      "#calculations\n",
      "#(a)\n",
      "Pav1 = (Tj-Ts1)/(tr_jc+tr_cs)\n",
      "#(b)\n",
      "Pav2 =(Tj-Ts2)/(tr_jc+tr_cs)\n",
      "rating = 100*(math.sqrt(Pav2)-math.sqrt(Pav1))/math.sqrt(Pav1)\n",
      "rating = math.floor(rating*100)/100\n",
      "# result\n",
      "print(\"(a)\\nAverage power loss = %.2fW\"%Pav1)\n",
      "print(\"\\n(b)\\nAverage power loss = %.2fW\\n%% increase in rating = %.2f%%\"%(Pav2,rating))\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(a)\n",
        "Average power loss = 40.91W\n",
        "\n",
        "(b)\n",
        "Average power loss = 68.18W\n",
        "% increase in rating = 29.09%\n"
       ]
      }
     ],
     "prompt_number": 34
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.27, Page No. 75"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Minnimum and maximum firing angle of triac\n",
      "\n",
      "import math\n",
      "#Variable declaration\n",
      "Vs = 230.0                 # Supply voltage\n",
      "f = 50.0                   # supply frequency\n",
      "Vc = 25.0                  # breakdown voltage\n",
      "C = 0.6*10**-6             # capacitance\n",
      "Rmin = 2000                # minimum resistance  \n",
      "Rmax = 20000                # maximum resistance\n",
      "\n",
      "#Calculations\n",
      "#(a)\n",
      "pi = math.ceil(math.pi*10**4)/10**4\n",
      "Xc = 1/(2*pi*f*C)\n",
      "Xc = math.floor(Xc*100)/100\n",
      "Z1_m = math.sqrt(Rmin**2+Xc**2)\n",
      "Z1_angle=math.atan(Xc/Rmin)\n",
      "I1_m = Vs/Z1_m\n",
      "I1_m = math.ceil(I1_m*10**5)/10**5\n",
      "I1_angle = Z1_angle\n",
      "Vc_m = I1_m*Xc\n",
      "Vc_m = math.ceil(Vc_m*100)/100\n",
      "Vc_angle = I1_angle*(180/math.pi)-90\n",
      "alfa1 = (180/math.pi)*math.asin(Vc/(math.sqrt(2)*Vc_m))+(-Vc_angle)\n",
      "\n",
      "#(b)\n",
      "Z2_m = math.sqrt(Rmax**2+Xc**2)\n",
      "Z2_m = math.floor(Z2_m*10)/10\n",
      "Z2_angle=math.atan(Xc/Rmax)\n",
      "I2_m = Vs/Z2_m\n",
      "I2_m = math.floor(I2_m*10**6)/10**6\n",
      "I2_angle = Z2_angle\n",
      "V2c_m = I2_m*Xc\n",
      "V2c_m = math.ceil(V2c_m*100)/100\n",
      "V2c_angle = I2_angle*(180/math.pi)-90\n",
      "alfa2 = (180/math.pi)*math.asin(Vc/(math.sqrt(2)*V2c_m))+(-V2c_angle)\n",
      "\n",
      "#Result\n",
      "print(\"Xc = %.2f ohms\"%Xc)\n",
      "print(\"\\n(a) When R = %d ohms\\n Z(magnitude) = %.2f\\t\\tZ(angle) = %.2f\u00b0\"%(Rmin,Z1_m,-Z1_angle*(180/math.pi)))\n",
      "print(\" I(magnitude) = %.5f\\t\\tI(angle) = %.2f\u00b0\"%(I1_m,I1_angle*(180/math.pi)))\n",
      "print(\"\\nVoltage across capacitor,\\nV(magnitude) = %.2f\\t\\tV(angle) = %.2f\u00b0\"%(Vc_m,Vc_angle))\n",
      "print(\"\\nMinimum firing angle = %.2f\u00b0\"%alfa1)\n",
      "\n",
      "print(\"\\n(b) When R = %d ohms\\n Z(magnitude) = %.2f\\t\\tZ(angle) = %.2f\u00b0\"%(Rmax,Z2_m,-Z2_angle*(180/math.pi)))\n",
      "print(\" I(magnitude) = %f\\t\\tI(angle) = %.2f\u00b0\"%(I2_m,I2_angle*(180/math.pi)))\n",
      "print(\"\\nVoltage across capacitor,\\nV(magnitude) = %.2f\\t\\tV(angle) = %.2f\u00b0\"%(V2c_m,V2c_angle))\n",
      "print(\"\\nMaximum firing angle = %.2f\u00b0\"%(math.ceil(alfa2*10)/10))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Xc = 5305.15 ohms\n",
        "\n",
        "(a) When R = 2000 ohms\n",
        " Z(magnitude) = 5669.62\t\tZ(angle) = -69.34\u00b0\n",
        " I(magnitude) = 0.04057\t\tI(angle) = 69.34\u00b0\n",
        "\n",
        "Voltage across capacitor,\n",
        "V(magnitude) = 215.23\t\tV(angle) = -20.66\u00b0\n",
        "\n",
        "Minimum firing angle = 25.37\u00b0\n",
        "\n",
        "(b) When R = 20000 ohms\n",
        " Z(magnitude) = 20691.60\t\tZ(angle) = -14.86\u00b0\n",
        " I(magnitude) = 0.011115\t\tI(angle) = 14.86\u00b0\n",
        "\n",
        "Voltage across capacitor,\n",
        "V(magnitude) = 58.97\t\tV(angle) = -75.14\u00b0\n",
        "\n",
        "Maximum firing angle = 92.60\u00b0\n"
       ]
      }
     ],
     "prompt_number": 88
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.28, Page no. 80"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# UJT relaxation circuit\n",
      "\n",
      "import math\n",
      "#Variable declaration\n",
      "V = 32.0                 #voltage\n",
      "h = 0.63                 # voltage gain\n",
      "Ip = 10*10**-6           # current \n",
      "Vv = 3.5                 # voltage drop\n",
      "Iv = 10*10**-3           # current through the circuit\n",
      "Vf = 0.5                 # forward voltage drop across p-n junction\n",
      "f = 50.0                 # frequency of ascillation \n",
      "t = 50.0*10**-6          # width of triggering pulse(given value is 50ms but used value is 50 micro-sec) \n",
      "C = 0.4*10**-6           # Capacitance(assumed)\n",
      "\n",
      "#Calculations\n",
      "T = 1/f\n",
      "Vp = V*h+Vf\n",
      "Rmax = (V-Vp)/Ip         # R should be less than the given value\n",
      "Rmin = (V-Vv)/Iv         # R should be more than the given value\n",
      "R = T/(C*math.log(1/(1-h)))\n",
      "R4 = t/C\n",
      "R3 = 10**4/(h*V)\n",
      "\n",
      "#Result\n",
      "print(\"The value of R = %.2f*10^3 ohm is within the Rmax = %.3f*10^6 ohm and Rmin = %.2f*10^3 ohm\"%(R*10**-3,Rmax*10**-6,Rmin*10**-3))\n",
      "print(\"Hence the value is suitable.\\n\\nR4 = %d ohm \\nR3 = %d ohm\"%(R4,R3))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "The value of R = 50.29*10^3 ohm is within the Rmax = 1.134*10^6 ohm and Rmin = 2.85*10^3 ohm\n",
        "Hence the value is suitable.\n",
        "\n",
        "R4 = 125 ohm \n",
        "R3 = 496 ohm\n"
       ]
      }
     ],
     "prompt_number": 101
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.29, Page No. 81"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#values of various components of circuit(referring to fig.2.36(a))\n",
      "\n",
      "import math\n",
      "# variable declaration\n",
      "f = 2.0*10**3               # ouutput frequency\n",
      "Vdc = 10                    # input voltage\n",
      "h = 0.6                     # voltage gain\n",
      "I = 0.005                   # peak discharge current\n",
      "v = 0.5                     # voltage drop across p-n junction(assumed)\n",
      "\n",
      "#Calculation\n",
      "Vp = (Vdc*h)+v\n",
      "R = (Vdc-Vp)/I              # R should be less than this value\n",
      "T = 1.0/f\n",
      "C1 = 0.5*10**-6             # capacitance(assumed)\n",
      "R1 = (T)/(C1*math.log(1/(1-h)))\n",
      "\n",
      "C2 = 1.0*10**-6             # capacitance(assumed)\n",
      "R2 = (T)/(C2*math.log(1/(1-h)))\n",
      "\n",
      "#Result\n",
      "print(\"for C = %.1f micro-F, R = %d Ohm. \\nThis value of R is not suitable because R must be less than %d ohm.\"%(C1*10**6,R1,R))\n",
      "print(\"\\nfor C = %.1f micro-F, R = %.1f Ohm.\\nThis value is suitable because R is less than %d ohm\"%(C2*10**6,R2,R))\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "for C = 0.5 micro-F, R = 1091 Ohm. \n",
        "This value of R is not suitable because R must be less than 700 ohm.\n",
        "\n",
        "for C = 1.0 micro-F, R = 545.7 Ohm.\n",
        "This value is suitable because R is less than 700 ohm\n"
       ]
      }
     ],
     "prompt_number": 112
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.30, Page No. 82"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Range of firing angle\n",
      "\n",
      "import math\n",
      "#Variable declaration\n",
      "Vs = 230.0             # supply voltage\n",
      "Rmin= 1000.0           # minimum value of R1 resistor\n",
      "Rmax = 22*10**3        # maximum value of R1 resistor\n",
      "Vg = 2.0               # gate triggering voltage\n",
      "C = 0.47*10**-6        # capacitor value\n",
      "f = 50.0               # frequency\n",
      "#Calculations\n",
      "# For Rmin\n",
      "theta = (180/math.pi)*math.atan(2*math.pi*f*C*Rmin)\n",
      "theta = math.ceil(theta*10)/10\n",
      "Vc = Vs*math.cos(theta*math.pi/180)\n",
      "Vc = math.floor(Vc*100)/100\n",
      "alfa = ((180/math.pi)*math.asin(Vg/(math.sqrt(2)*Vc)))+theta\n",
      "alfa = math.floor(alfa*10)/10\n",
      "\n",
      "# for Rmax\n",
      "theta2 = (180/math.pi)*math.atan(2*math.pi*f*C*Rmax)\n",
      "theta2 = math.ceil(theta2*10)/10\n",
      "Vc2 = Vs*math.cos(theta2*math.pi/180)\n",
      "Vc2 = math.floor(Vc2*100)/100\n",
      "alfa2 = ((180/math.pi)*math.asin(Vg/(math.sqrt(2)*Vc2)))+theta2\n",
      "alfa2 = math.ceil(alfa2*10)/10\n",
      "\n",
      "#Result\n",
      "print(\"Minimum firing angle = %.1f\u00b0\"%alfa)\n",
      "print(\"Maximum firing angle = %.1f\u00b0\"%alfa2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Minimum firing angle = 8.7\u00b0\n",
        "Maximum firing angle = 74.1\u00b0\n"
       ]
      }
     ],
     "prompt_number": 137
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.31, Page No. 83"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# UJT relaxation oscillator design(reffering to fig.2.40)\n",
      "\n",
      "import math\n",
      "#variable declaration\n",
      "f = 50.0                   # frequency of supply\n",
      "Vbb = 12.0                 # typical input vpltage\n",
      "P = 300*10**3              # maximumm average power dissipation\n",
      "Rbb = 5.6*10**3            # base resistor\n",
      "Iv = 4*10**-3              # Valley point voltage\n",
      "h = 0.63                   # intrinsic stand off ratio\n",
      "Vd = 0.5                   # drop across p-n junction\n",
      "Vv = 2.0                   # Valley point voltage\n",
      "Ip = 5*10**-6              # peak point current\n",
      "v = 0.18                   # minimum voltage for which SCR will not trigger\n",
      "\n",
      "#calculation\n",
      "T = 1/f\n",
      "#operating point should be on the left of valley point\n",
      "R_1 = (Vbb-Vv)/Iv             # R should be greater than this value\n",
      "Vp = (h*Vbb)+Vd\n",
      "#operation point should lie in the negative resistance region of characteristics of UJT\n",
      "R_2 = (Vbb-Vp)/Ip              # R should be less than this value\n",
      "C = 0.02*10**-6               # assumed\n",
      "R_3 = T/(C*math.log(1/(1-h)))\n",
      "\n",
      "C2 = 0.04*10**-6               # assumed\n",
      "R_4 = T/(C2*math.log(1/(1-h)))\n",
      "R = 500*10**3                  # assumed\n",
      "Rmax = R+R_1\n",
      "R3_1 = (10**4)/(h*Vbb)\n",
      "R3 = 1200                      # assumed\n",
      "R4_1 = v*(R3+Rbb)/(Vbb-v)      # R4 value should be less than this value\n",
      "R4 = 100                       # assumed  \n",
      "tw = R4*C2\n",
      "tow_min = R_1*C2*math.log(1/(1-h))\n",
      "alfa_min = tow_min*(360/T)\n",
      "tow_max = Rmax*C2*math.log(1/(1-h))\n",
      "alfa_max = tow_max*(360/T)\n",
      "\n",
      "#Result\n",
      "print(\"For C = %.2f micro F, R = %.2f k-ohm\\nThis value of R is more than maximum of %d k-ohm.\"%(C*10**6,R_3/1000,R_2/1000) )\n",
      "print(\"Hence not suitable.\")\n",
      "print(\"\\nFor C = %.2f micro F, R = %.2f K-ohm.\"%(C2*10**6,R_4/1000))\n",
      "print(\"As this is less than max value. It is suitable. \\nLets assume R = %d k-ohm\"%(R/1000))\n",
      "print(\"Rmax = %.1f k-ohm\"%(Rmax/1000))\n",
      "print(\"\\nR3 = %.2f k-ohm. so take nearest value R3 = %.1f k-ohm\"%(R3_1/1000,R3/1000.0))\n",
      "print(\"\\nR4 = %.2f ohm. so take nearest value R4 = %.1f ohm\"%(R4_1,R4))\n",
      "print(\"\\nMinimum firing angle = %.2f\u00b0\"%alfa_min)\n",
      "print(\"Maximum firing angle = %.1f\u00b0\"%alfa_max)\n",
      "print(\"\\nThough maximum firing angle available is %.1f\u00b0, it will not be needed\"%alfa_max)\n",
      "print(\"because in a single phase full wave converter the maximum firing angle is 180\u00b0\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "For C = 0.02 micro F, R = 1005.78 k-ohm\n",
        "This value of R is more than maximum of 788 k-ohm.\n",
        "Hence not suitable.\n",
        "\n",
        "For C = 0.04 micro F, R = 502.89 K-ohm.\n",
        "As this is less than max value. It is suitable. \n",
        "Lets assume R = 500 k-ohm\n",
        "Rmax = 502.5 k-ohm\n",
        "\n",
        "R3 = 1.32 k-ohm. so take nearest value R3 = 1.2 k-ohm\n",
        "\n",
        "R4 = 103.55 ohm. so take nearest value R4 = 100.0 ohm\n",
        "\n",
        "Minimum firing angle = 1.79\u00b0\n",
        "Maximum firing angle = 359.7\u00b0\n",
        "\n",
        "Though maximum firing angle available is 359.7\u00b0, it will not be needed\n",
        "because in a single phase full wave converter the maximum firing angle is 180\u00b0\n"
       ]
      }
     ],
     "prompt_number": 166
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.32, Page No.92"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# conduction time of thyristor\n",
      "\n",
      "import math\n",
      "#variable declaratrion\n",
      "R =0.8                   # load resistance\n",
      "L = 10*10**-6            # inductance\n",
      "C = 50*10**-6            # capacitance\n",
      "\n",
      "#calculations\n",
      "R1 = math.sqrt(4*L/C)      # R should be less than this value\n",
      "t = math.pi/(math.sqrt((1/(L*C))-((R**2)/(4*L**2))))\n",
      "\n",
      "#Result\n",
      "print(\"Value of sqrt(4L/C)  is %.4f and give R = %.1f\\nTherefore, the circuit is underdamped.\"%(R1,R))\n",
      "print(\"\\nt0 = %.2f*10**-6 seconds\"%(t*10**6))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Value of sqrt(4L/C)  is 0.8944 and give R = 0.8\n",
        "Therefore, the circuit is underdamped.\n",
        "\n",
        "t0 = 157.08*10**-6 seconds\n"
       ]
      }
     ],
     "prompt_number": 169
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.33, Page No. 92"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Values of L and C\n",
      "\n",
      "import math\n",
      "#variable declaration\n",
      "I = 8.0                  # load current\n",
      "V = 90.0                 # Supply voltage\n",
      "t = 40.0*10**-6          # turn off time\n",
      "\n",
      "#calculation\n",
      "#print(\"Assume peak value of capacitor current to be twice the load cuuren.\")\n",
      "C_by_L = (2*I/V)**2         # using eq 2.33\n",
      "#print(\"Assume that thyristor is reverse biased for one-fourth period of resonant circuit.\")\n",
      "CL = (t*2/math.pi)**2\n",
      "# (2*I/V)^2*L^2 =(t*2/math.pi)^2\n",
      "\n",
      "L = math.sqrt(CL/C_by_L)\n",
      "C =C_by_L*L\n",
      "\n",
      "print(\"L = %.2f*10**-6 H\\nC = %.3f*10**-6 F\"%(L*10**6,C*10**6))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "L = 143.24*10**-6 H\n",
        "C = 4.527*10**-6 F\n"
       ]
      }
     ],
     "prompt_number": 173
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.34, Page No. 92"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Value of C for commutation\n",
      "\n",
      "import math\n",
      "#variable declaration\n",
      "R = 10                    # load resistace\n",
      "V = 100                   # supply voltage \n",
      "t = 50 * 10**-6           # turn off time\n",
      "\n",
      "#Calculations\n",
      "C = t/(R*math.log(2))\n",
      "\n",
      "#Result\n",
      "print(\"C = %.2f*10^-6 F\"%(C*10**6))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "C = 7.21*10^-6 F\n"
       ]
      }
     ],
     "prompt_number": 176
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.35, Page No. 93"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# L and C of commutation circuit\n",
      "\n",
      "import math\n",
      "# variable declaration\n",
      "V = 100                    # supply voltage\n",
      "I = 40                     # maximumm load current\n",
      "T = 40*10**-6              # turn off time\n",
      "t = 1.5                    # extra 50% tolerance\n",
      "\n",
      "#Calculation\n",
      "T = T*t\n",
      "C = I*T/V\n",
      "L = (V**2)*C/(I**2)\n",
      "Ip = V*math.sqrt(C/L)\n",
      "L2 = 2* 10**-4             # assume\n",
      "Ip2 = V*math.sqrt(C/L2)\n",
      "print(\"C = %.0f*10^-6 F\\nL = %.1f*10^-4 H\\nPeak capacitor current = %d A\"%(C*10**6,L*10**4,Ip))\n",
      "print(\"\\nPeak capacitor current should be less than maximum load currentof %d A. If L is selected as %d *10^-4 H,\"%(I,L2*10**4))\n",
      "print(\"the peak capacitor current will be %.1f A. Since this is less than %d A, this value of L is satisfactory.\"%(Ip2,I))\n",
      "print(\"\\nHence,\\nC = %.0f*10^-6 F\\nL = %.1f*10^-4 H\"%(C*10**6,L2*10**4))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "C = 24*10^-6 F\n",
        "L = 1.5*10^-4 H\n",
        "Peak capacitor current = 40 A\n",
        "\n",
        "Peak capacitor current should be less than maximum load currentof 40 A. If L is selected as 2 *10^-4 H,\n",
        "the peak capacitor current will be 34.6 A. Since this is less than 40 A, this value of L is satisfactory.\n",
        "\n",
        "Hence,\n",
        "C = 24*10^-6 F\n",
        "L = 2.0*10^-4 H\n"
       ]
      }
     ],
     "prompt_number": 187
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.36, Page No. 93"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# current rating of the thyristor\n",
      "\n",
      "import math\n",
      "#Variable declaration\n",
      "Vdc = 100.0               # input voltage\n",
      "L = 0.1 *10**-3           # Inductance\n",
      "C = 10*10**-6             # capacitance\n",
      "Vc = 100.0                # iinitial voltage on capacitor\n",
      "t = 25.0*10**-6           # thyristor turn offf time\n",
      "I = 10.0                  # Thyristor load current\n",
      "\n",
      "#Calculations\n",
      "t_off = Vc*C/I\n",
      "Ic = Vdc*math.sqrt(C/L)\n",
      "\n",
      "# Result\n",
      "print(\"t_off = %d *10^-6 S\\nt_off is more than thyristor turn off time and is thus sufficient to commutate the main circuit.\"%(t_off*10**6))\n",
      "print(\"\\nPeak capacitor current = %.2fA \"%Ic)\n",
      "print(\"Maximum current rating of thyristor should be more than %.2fA\"%Ic)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "t_off = 100 *10^-6 S\n",
        "t_off is more than thyristor turn off time and is thus sufficient to commutate the main circuit.\n",
        "\n",
        "Peak capacitor current = 31.62A \n",
        "Maximum current rating of thyristor should be more than 31.62A\n"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.37, Page No. 97"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# value of R and C for snubber circuit\n",
      "\n",
      "import math\n",
      "#variable declaration\n",
      "dv_by_dt = 25*10**6                 # Thyristor's dv/dt rating\n",
      "L = 0.2 *10**-3                     # source inductance\n",
      "V = 230                             # Supply voltage\n",
      "df = 0.65                           # damping factor\n",
      "\n",
      "#Calculation\n",
      "Vm = V*math.sqrt(2) \n",
      "C = (1/(2*L))*(0.564*Vm/dv_by_dt)**2\n",
      "R = 2*df*math.sqrt(L/C)\n",
      "\n",
      "#Result\n",
      "print(\"C = %.2f*10^-9 F\\n\\nR = %.1f ohm\"%(C*10**9,R))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "C = 134.62*10^-9 F\n",
        "\n",
        "R = 50.1 ohm\n"
       ]
      }
     ],
     "prompt_number": 11
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.38, Page No.97"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# snuubber circuit parameters\n",
      "\n",
      "import math\n",
      "#variable declaration\n",
      "V = 300.0                      # input voltage\n",
      "Rl = 10.0                      # load resistance\n",
      "f = 2000.0                     # operating frequency otf the circuit\n",
      "dv_by_dt = 100.0*10**6         # required dv/dt  rating of the circuit\n",
      "I = 100.0                      # discharge current\n",
      "\n",
      "#calculations\n",
      "#(a)\n",
      "R = V/I\n",
      "C = (1-(1/math.e))*Rl*V/(dv_by_dt*((R+Rl)**2))\n",
      "C = math.floor(C*10**9)/10**9\n",
      "#(b)\n",
      "P = (C*V**2*f)/2\n",
      "\n",
      "#Result\n",
      "print(\"(a)\\nR = %f ohm\\nC = %.3f*10^-6 F\"%(R,C*10**6))\n",
      "print(\"\\n(b)\\nSnubber power loss = %.2f W\"%P)\n",
      "print(\"\\nAll the energy stored in capacitor C is dissipated in resistance R. Hence power rating of R is %.2f W.\"%P)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(a)\n",
        "R = 3.000000 ohm\n",
        "C = 0.112*10^-6 F\n",
        "\n",
        "(b)\n",
        "Snubber power loss = 10.08 W\n",
        "\n",
        "All the energy stored in capacitor C is dissipated in resistance R. Hence power rating of R is 10.08 W.\n"
       ]
      }
     ],
     "prompt_number": 37
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.39, Page No.98"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# maximum permissiible values of dv/dt and di/dt\n",
      "\n",
      "import math\n",
      "#variable declaration\n",
      "R = 4.0              # resistance\n",
      "L = 6.0*10**-6       # inductance\n",
      "C = 6.0*10**-6       # capacitance\n",
      "V = 300.0            # Supply voltage\n",
      "\n",
      "#calculations\n",
      "di_dt = V/L\n",
      "Isc = V/R\n",
      "dv_dt =(R* di_dt)+(Isc/C)\n",
      "\n",
      "#Result\n",
      "print(\"Maximum di/dt = %.0f*10^6 A/s\\n\\nmaximum permissible dv/dt = %.1f*10^6 V/s\"%(di_dt*10**-6,dv_dt*10**-6))\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Maximum di/dt = 50*10^6 A/s\n",
        "\n",
        "maximum permissible dv/dt = 212.5*10^6 V/s\n"
       ]
      }
     ],
     "prompt_number": 39
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.40, Page No.98"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# snubber circuit designe\n",
      "\n",
      "import math\n",
      "#variable declaration\n",
      "\n",
      "Rl = 8.0                 # load resistance\n",
      "V = 230.0                # supply voltage\n",
      "I = 200.0                # repititive peak current \n",
      "di_dt = 40.0*10**6       # max. di/di rating\n",
      "dv_dt = 150.0*10**6      # max. dv/dv rating\n",
      "sf = 2.0                 # safety factor for thyristor\n",
      "\n",
      "#Calculation\n",
      "\n",
      "I1 = I/2.0\n",
      "di_dt2 = di_dt/2.0\n",
      "dv_dt2 = dv_dt/2\n",
      "Vp = V*math.sqrt(2)\n",
      "#Vp = math.floor((Vp*10)/10)\n",
      "L2 = Vp/di_dt2\n",
      "L2 = math.floor(L2*10**8)/10**8\n",
      "R2 = L2*dv_dt2/Vp\n",
      "Ip = Vp/Rl\n",
      "Ic = (math.floor(Vp*10)/10)/R2\n",
      "It = math.floor(Ip*100)/100+Ic\n",
      "Ic_max = I1 - Ip\n",
      "Ic_max = math.ceil(Ic_max*100)/100\n",
      "R = Vp /Ic_max\n",
      "R = math.ceil(R)\n",
      "h = 0.65                  #assumed       \n",
      "C = 4*(h**2)*L2/R**2\n",
      "dv_dt3 = Vp/((R+Rl)*C)\n",
      "\n",
      "#Result\n",
      "print(\"when safety factor is 2 ,maximum permisible ratings are:\")\n",
      "print(\"max. di/dt = %.0f*10^6 A/s\\nmax. dv/dt = %.0f*10^6 V/s\"%(di_dt2*10**-6,dv_dt2*10**-6))\n",
      "print(\"\\nPeak value of input voltage = %.1f V\"%(math.floor(Vp*10)/10))\n",
      "print(\"L = %.2f*10^-6 H \\nR = %.2f ohm\"%(L2*10**6,R2))\n",
      "print(\"Peak load current = %.2fA\\nPeak capacitor discharge current = %.2f A\"%(math.floor(Ip*100)/100,Ic))\n",
      "print(\"Total current through capacitor = %.2f\"%It)\n",
      "print(\"\\nSince total current through capacitor is more than permissible vale. Hence max capacitor discharge current = %.2fA\"%Ic_max)\n",
      "print(\"R = %.0f ohm\\nC = %.4f*10^-6F\"%(R,C*10**6))\n",
      "print(\"dv/dt = %.2f*10^6 V/s\\nSince this value is within specified limit the design is safe. \"%(math.floor(dv_dt3*10**-4)/100))\n",
      "print(\"Hence, R = %d ohm, C = %.4f micro-F and L = %.2f micro-H\"%(R,C*10**6,L2*10**6))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "when safety factor is 2 ,maximum permisible ratings are:\n",
        "max. di/dt = 20*10^6 A/s\n",
        "max. dv/dt = 75*10^6 V/s\n",
        "\n",
        "Peak value of input voltage = 325.2 V\n",
        "L = 16.26*10^-6 H \n",
        "R = 3.75 ohm\n",
        "Peak load current = 40.65A\n",
        "Peak capacitor discharge current = 86.74 A\n",
        "Total current through capacitor = 127.39\n",
        "\n",
        "Since total current through capacitor is more than permissible vale. Hence max capacitor discharge current = 59.35A\n",
        "R = 6 ohm\n",
        "C = 0.7633*10^-6F\n",
        "dv/dt = 30.43*10^6 V/s\n",
        "Since this value is within specified limit the design is safe. \n",
        "Hence, R = 6 ohm, C = 0.7633 micro-F and L = 16.26 micro-H\n"
       ]
      }
     ],
     "prompt_number": 83
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.41, Page No. 100"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Fault clearing time(referring to fig.2.59)\n",
      "\n",
      "import math\n",
      "#variable declaration\n",
      "I2t = 30                # I2t rating of thyristor\n",
      "V = 230                 # supply voltage\n",
      "#For resistor values refer to fig 2.59\n",
      "R1 = 2.0\n",
      "R2 = 1.0\n",
      "R3 = 5.0\n",
      "R4 = 6.0\n",
      "R5 = 5.0 \n",
      "#calculation\n",
      "Rnet = R1+(R3*R2)/R4\n",
      "If = math.sqrt(2)*V/Rnet\n",
      "tc = I2t/(If**2)\n",
      "\n",
      "#Result\n",
      "print(\"tc = %.3f*10^-3 seconds \"%(math.ceil(tc*1000*1000)/1000))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "tc = 2.277*10^-3 seconds \n"
       ]
      }
     ],
     "prompt_number": 90
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.42, Page No.103"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# number of thyristors in series and parallel\n",
      "\n",
      "import math\n",
      "#variable declaration\n",
      "V = 3*10**3                   # supply voltage\n",
      "I = 750.0                     # supply current\n",
      "V1 = 800.0                    # Thyristor voltage rating\n",
      "I1 = 175.0                    # Thyristor current rating\n",
      "d = 0.25                      # derating\n",
      "\n",
      "\n",
      "# Calculation\n",
      "np = I/((1-d)*I1)\n",
      "ns = V/((1-d)*V1)\n",
      "print(\"np = %.2f or %d\"%(np,math.ceil(np)))\n",
      "print(\"ns = %d\"%(math.ceil(ns)))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "np = 5.71 or 6\n",
        "ns = 5\n"
       ]
      }
     ],
     "prompt_number": 97
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.43, Page No. 104"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Value of R and C\n",
      "\n",
      "import math\n",
      "#variable declaration(referring to example 2.42)\n",
      "V = 3*10**3                   # supply voltage\n",
      "I = 750.0                     # supply current\n",
      "V1 = 800.0                    # Thyristor voltage rating\n",
      "I1 = 175.0                    # Thyristor current rating\n",
      "d = 0.25                      # derating\n",
      "Ib = 8*10**-3                 # maximum forward leakage current\n",
      "del_Q = 30*10**-6             # recovery charge difference\n",
      "ns = 5                        # number of series thyristors \n",
      "\n",
      "#Calculations\n",
      "R = ((ns*V1)-V)/((ns-1)*Ib)\n",
      "C = (ns-1)*del_Q/(ns*V1-V)\n",
      "\n",
      "#Result\n",
      "print(\"R = %.2f*10^3 ohm\\nC = %.2f*10^-6 F\"%(R/1000,C*10**6))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "R = 31.25*10^3 ohm\n",
        "C = 0.12*10^-6 F\n"
       ]
      }
     ],
     "prompt_number": 99
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.44, Page No. 104"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# series resistance\n",
      "\n",
      "import math\n",
      "# variabe declaration\n",
      "I1 = 200               # thyristor1 current rating\n",
      "I2 = 300               # thyristor2 current rating\n",
      "V1 = 1.5               # on state voltage drop of thyristor1 \n",
      "V2 = 1.2               # on state voltage drop of thyristor2\n",
      "\n",
      "#Calculations\n",
      "R = (V1-V2)/(I2-I1)\n",
      "\n",
      "#Result\n",
      "print(\"R = %.3f ohm\"%R)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "R = 0.003 ohm\n"
       ]
      }
     ],
     "prompt_number": 100
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.45, Page No.104"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Thyristor parameters\n",
      "\n",
      "import math\n",
      "#variable declaration\n",
      "ns = 12                 # no of series thyristors\n",
      "V = 16*10**3            # maximum DC voltage rating\n",
      "Ib = 10*10**-3          # maximum leakage current of thyristor\n",
      "del_Q = 150 *10**-6     # recovery charge differences of thyristors\n",
      "R = 56*10**3            # resistance\n",
      "C = 0.5 *10**-6         # Capacitance\n",
      "\n",
      "#Calculations\n",
      "Vd1 = (V+(ns-1)*R*Ib)/ns\n",
      "ssvd = 1-(V/(ns*Vd1))\n",
      "Vd2 = (V+((ns-1)*del_Q/C))/ns\n",
      "tsvd = 1-(V/(ns*Vd2))\n",
      "\n",
      "#Result\n",
      "print(\"(a) Maximum steady state voltage rating = %.2f V\"%Vd1)\n",
      "print(\"(b) Steady state voltage derating = %.3f or %.1f%%\"%(ssvd,ssvd*100))\n",
      "print(\"(c) Maximum transient state voltage rating = %.2f V\"%Vd2)\n",
      "print(\"(d) Transient state voltage derating = %.3f or %.1f%%\"%(tsvd,tsvd*100))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "(a) Maximum steady state voltage rating = 1846.67 V\n",
        "(b) Steady state voltage derating = 0.278 or 27.8%\n",
        "(c) Maximum transient state voltage rating = 1608.33 V\n",
        "(d) Transient state voltage derating = 0.171 or 17.1%\n"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.46, Page No.104"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# No of Thyristor\n",
      "\n",
      "import math\n",
      "#variable declaration\n",
      "V = 500.0                # single thyristor voltage rating\n",
      "I = 75.0                 # single thyristor current rating\n",
      "Vmax = 7.5*10**3         # overall voltage rating of the circuit\n",
      "Imax = 1.0*10**3         # overall current rating of the circuit\n",
      "df = 0.14                # derating factor\n",
      "\n",
      "#Calcaulations\n",
      "ns = Vmax/((1-df)*V)\n",
      "np = Imax/((1-df)*I)\n",
      "\n",
      "#Result\n",
      "print(\"No of thyristors in series, ns = %.2f say %d\"%(ns,math.ceil(ns)))\n",
      "print(\"No of thyristors in parallel, np = %.2f say %d\"%(np,math.ceil(np)))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "No of thyristors in series, ns = 17.44 say 18\n",
        "No of thyristors in parallel, np = 15.50 say 16\n"
       ]
      }
     ],
     "prompt_number": 10
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "example 2.47, Page No. 105"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Turn off voltage and discharge current through SCR\n",
      "\n",
      "import math\n",
      "#variable declaration\n",
      "Vmax = 8.0*10**3             # max voltage rating of the circuit\n",
      "R = 20.0*10**3               # static equalising resistance \n",
      "Rc = 25.0                    # Resistace of dynamic equalising circuit\n",
      "C = 0.1*10**-6               # Capacitance of dynamic equalising circuit\n",
      "Ib1 = 22.0*10**-3            # leakage current of thyristor1\n",
      "Ib2 = 20.0*10**-3            # leakage current of thyristor2\n",
      "Ib3 = 18.0*10**-3            # leakage current of thyristor3\n",
      "\n",
      "\n",
      "#Calculations \n",
      "#(a)\n",
      "I = ((Vmax/R)+(Ib1+Ib2+Ib3))/3\n",
      "V1 = (I-Ib1)*R\n",
      "V2 = (I-Ib2)*R\n",
      "V3 = (I-Ib3)*R\n",
      "#(b)\n",
      "I1 = V1/Rc\n",
      "I2 = V2/Rc\n",
      "I3 = V3/Rc\n",
      "\n",
      "#Result\n",
      "print(\"Voltage across SCR 1 = %.1fV\"%(math.floor(V1*10)/10))\n",
      "print(\"Voltage across SCR 2 = %.1fV\"%(math.floor(V2*10)/10))\n",
      "print(\"Voltage across SCR 3 = %.1fV\"%(math.floor(V3*10)/10))\n",
      "print(\"Discharge current through SCR 1 = %.2fA\"%(math.floor(I1*100)/100))\n",
      "print(\"Discharge current through SCR 2 = %.2fA\"%(math.floor(I2*100)/100))\n",
      "print(\"Discharge current through SCR 3 = %.2fA\"%(math.floor(I3*100)/100))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Voltage across SCR 1 = 2626.6V\n",
        "Voltage across SCR 2 = 2666.6V\n",
        "Voltage across SCR 3 = 2706.6V\n",
        "Discharge current through SCR 1 = 105.06A\n",
        "Discharge current through SCR 2 = 106.66A\n",
        "Discharge current through SCR 3 = 108.26A\n"
       ]
      }
     ],
     "prompt_number": 23
    }
   ],
   "metadata": {}
  }
 ]
}