summaryrefslogtreecommitdiff
path: root/Power_Electronics/Power_electronics_ch_2_1.ipynb
diff options
context:
space:
mode:
authorhardythe12015-05-05 14:21:39 +0530
committerhardythe12015-05-05 14:21:39 +0530
commit435840cef00c596d9e608f9eb2d96f522ea8505a (patch)
tree4c783890c984c67022977ca98432e5e4bab30678 /Power_Electronics/Power_electronics_ch_2_1.ipynb
parentaa1863f344766ca7f7c20a395e58d0fb23c52130 (diff)
downloadPython-Textbook-Companions-435840cef00c596d9e608f9eb2d96f522ea8505a.tar.gz
Python-Textbook-Companions-435840cef00c596d9e608f9eb2d96f522ea8505a.tar.bz2
Python-Textbook-Companions-435840cef00c596d9e608f9eb2d96f522ea8505a.zip
add books
Diffstat (limited to 'Power_Electronics/Power_electronics_ch_2_1.ipynb')
-rwxr-xr-xPower_Electronics/Power_electronics_ch_2_1.ipynb2357
1 files changed, 2357 insertions, 0 deletions
diff --git a/Power_Electronics/Power_electronics_ch_2_1.ipynb b/Power_Electronics/Power_electronics_ch_2_1.ipynb
new file mode 100755
index 00000000..6e52e316
--- /dev/null
+++ b/Power_Electronics/Power_electronics_ch_2_1.ipynb
@@ -0,0 +1,2357 @@
+{
+ "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": {}
+ }
+ ]
+} \ No newline at end of file
generated by cgit (git 2.34.1) at 2024-12-20 21:53:10 +0000