From fba055ce5aa0955e22bac2413c33493b10ae6532 Mon Sep 17 00:00:00 2001 From: hardythe1 Date: Tue, 5 May 2015 14:21:39 +0530 Subject: add books --- Power_Electronics/Power_electronics_ch_3_1.ipynb | 2276 ++++++++++++++++++++++ 1 file changed, 2276 insertions(+) create mode 100755 Power_Electronics/Power_electronics_ch_3_1.ipynb (limited to 'Power_Electronics/Power_electronics_ch_3_1.ipynb') diff --git a/Power_Electronics/Power_electronics_ch_3_1.ipynb b/Power_Electronics/Power_electronics_ch_3_1.ipynb new file mode 100755 index 00000000..8f24e4d1 --- /dev/null +++ b/Power_Electronics/Power_electronics_ch_3_1.ipynb @@ -0,0 +1,2276 @@ +{ + "metadata": { + "name": "" + }, + "nbformat": 3, + "nbformat_minor": 0, + "worksheets": [ + { + "cells": [ + { + "cell_type": "heading", + "level": 1, + "metadata": {}, + "source": [ + "Chapter 3: Controlled Rectifiers" + ] + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.1, Page No. 127" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "print(\"Theoretical example\")" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Theoretical example\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.2, Page No. 129" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "print(\"Theoretical example\")" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Theoretical example\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.3, Page No. 130" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Half wave diode rectifier\n", + "\n", + "import math\n", + "from scipy.integrate import quad\n", + "#Variable declaration\n", + "V = 12.0 # Voltage of the battery to be charged\n", + "B = 150.0 # battery capacity in Wh\n", + "I = 4.0 # average current requirement\n", + "t = 4.0 # transformer primary to secondary ratio \n", + "Vi = 230.0 # voltage at transformer primary\n", + "\n", + "# Calculations\n", + "sqrt_2 = math.floor(math.sqrt(2)*1000)/1000\n", + "Vp = Vi*sqrt_2/t\n", + "#(a)\n", + "alfa = (180/math.pi)*(math.asin(V/Vp))\n", + "ang_c = (180-alfa)-alfa\n", + "ang_c = math.floor(ang_c*100)/100\n", + "#(b)\n", + "def f(wt):\n", + " return ((Vp*math.sin(wt))-V)/(2*math.pi*I)\n", + "wt_lower=(alfa*math.pi/180)\n", + "wt_upper =math.pi-(alfa*math.pi/180)\n", + "val1 = quad(f,wt_lower,wt_upper)\n", + "R = val1[0]\n", + "R = math.floor(R*100)/100\n", + "#(c)\n", + "def g(wt):\n", + " return (((Vp*math.sin(wt))-V)**2)/(2*math.pi*(R**2))\n", + "val2 = quad(g,wt_lower,wt_upper)\n", + "Irms = val2[0]\n", + "Irms = math.floor(math.sqrt(Irms)*100)/100\n", + "P = (Irms**2)*R\n", + "#(d)\n", + "T = B/(V*I)\n", + "#(e)\n", + "eff = (V*I)/((V*I)+P)\n", + "#(f)\n", + "PIV = Vp+V\n", + "\n", + "#Results\n", + "print(\"(a) Conduction angle = %.2f\u00b0\\n(b) R = %.2f ohm\\n(c) Irms = %.2f A\\n Resistor power rating = %.1f W\"%(ang_c,R,Irms,P))\n", + "print(\"(d) Time of charging = %.3f hours\\n(e) Rectifier efficiency = %.4f or %.2f%%\\n(f) PIV = %.3f V\"%(T,eff,eff*100,PIV))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Conduction angle = 163.02\u00b0\n", + "(b) R = 5.04 ohm\n", + "(c) Irms = 6.58 A\n", + " Resistor power rating = 218.2 W\n", + "(d) Time of charging = 3.125 hours\n", + "(e) Rectifier efficiency = 0.1803 or 18.03%\n", + "(f) PIV = 93.305 V\n" + ] + } + ], + "prompt_number": 6 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.4, Page No. 131" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "#Full wave centre tapped rectifier\n", + "\n", + "import math\n", + "# Variable declaration\n", + "Vm = 100.0 # transformer secondary voltage from mid point to each end\n", + "R = 5.0 # resistance\n", + "\n", + "#Calculation\n", + "#(b)\n", + "Idc = 2*Vm/(math.pi*R)\n", + "Idc = math.floor(Idc*1000)/1000\n", + "Vdc = Idc*R\n", + "Irms = 0.707*Vm/R\n", + "Pdc = R*Idc**2\n", + "Pdc = math.ceil(Pdc*100)/100\n", + "Pac = R*Irms**2\n", + "Pac = math.ceil(Pac*10)/10\n", + "eff = Pdc/Pac\n", + "FF = math.floor(((0.707*Vm*math.pi)/(2*Vm))*100)/100\n", + "RF = math.sqrt((FF**2)-1)\n", + "TUF = (((2/math.pi)**2)/(2*0.707*0.5))*100\n", + "PIV =2*Vm\n", + "\n", + "# Result\n", + "print(\"Idc = %.3f A\\nVdc = %.2f V\\nIrms = %.2f A\\nPdc = %.2f\\nPac = %.1f\\nEfficiency = %.3f\"%(Idc,Vdc,Irms,Pdc,Pac,eff))\n", + "print(\"FF = %.2f\\nRF = %.3f\\nTUF = %.2f%%\\nPIV = %d\\nCF = %f\"%(FF,RF,TUF,PIV,math.sqrt(2)))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Idc = 12.732 A\n", + "Vdc = 63.66 V\n", + "Irms = 14.14 A\n", + "Pdc = 810.52\n", + "Pac = 999.7\n", + "Efficiency = 0.811\n", + "FF = 1.11\n", + "RF = 0.482\n", + "TUF = 57.32%\n", + "PIV = 200\n", + "CF = 1.414214\n" + ] + } + ], + "prompt_number": 39 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.5, Page No.133" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "print(\"Theoretical example\")" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Theoretical example\n" + ] + } + ], + "prompt_number": 1 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.6, Page No.135" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Single phase diode bridge rectifier\n", + "\n", + "import math\n", + "#Variable declaration\n", + "Vm = 100.0 # Peak input voltage\n", + "R = 5.0 # load resistance\n", + "\n", + "#Calculation\n", + "#(b)\n", + "Idc = 2*Vm/(math.pi*R)\n", + "Idc = math.floor(Idc*1000)/1000\n", + "Vdc = Idc*R\n", + "Irms = 0.707*Vm/R\n", + "Pdc = R*Idc**2\n", + "Pdc = math.ceil(Pdc*100)/100\n", + "Pac = R*Irms**2\n", + "Pac = math.ceil(Pac*10)/10\n", + "eff = Pdc/Pac\n", + "FF = math.floor(((0.707*Vm*math.pi)/(2*Vm))*100)/100\n", + "RF = math.sqrt((FF**2)-1)\n", + "PIV =Vm\n", + "\n", + "# Result\n", + "print(\"Idc = %.3f A\\nVdc = %.2f V\\nIrms = %.2f A\\nPdc = %.2f\\nPac = %.1f\\nEfficiency = %.3f\"%(Idc,Vdc,Irms,Pdc,Pac,eff))\n", + "print(\"FF = %.2f\\nRF = %.3f\\nPIV = %d\\nCF = %f\"%(FF,RF,PIV,math.sqrt(2)))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Idc = 12.732 A\n", + "Vdc = 63.66 V\n", + "Irms = 14.14 A\n", + "Pdc = 810.52\n", + "Pac = 999.7\n", + "Efficiency = 0.811\n", + "FF = 1.11\n", + "RF = 0.482\n", + "PIV = 100\n", + "CF = 1.414214\n" + ] + } + ], + "prompt_number": 43 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.7, Page No.135" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "print(\"Theoretical example\")" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Theoretical example\n" + ] + } + ], + "prompt_number": 2 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.8, Page No.138" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Single phase half wave rectifier circuit\n", + "\n", + "import math\n", + "# Variable declaration\n", + "Vm = 400 # amplitude of output sine wave\n", + "alfa = 30 # thyristor firing angle\n", + "R = 50 # Load resistance\n", + "\n", + "#Calculations\n", + "alfa = alfa*math.pi/180\n", + "Vdc = Vm*(1+math.cos(alfa))/(2*math.pi)\n", + "I = Vdc/R\n", + "Vrms = Vm*math.sqrt(((math.pi-alfa)/(4*math.pi))+(math.sin(2*alfa)/(8*math.pi)))\n", + "Irms = Vrms/R\n", + "\n", + "#Result\n", + "print(\"Average DC voltage = %.1f V\\nAverage load current = %.3f A\"%(Vdc,I))\n", + "print(\"RMS voltage = %.1f V\\nRMS current = %.3f A\"%(Vrms,Irms))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Average DC voltage = 118.8 V\n", + "Average load current = 2.376 A\n", + "RMS voltage = 197.1 V\n", + "RMS current = 3.942 A\n" + ] + } + ], + "prompt_number": 49 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.9, Page No. 138" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Average current in the circuit\n", + "\n", + "import math\n", + "from scipy.integrate import quad\n", + "#Variable declaration\n", + "Vm = 100.0 # peak input voltage\n", + "V = 50.0 # voltage of battery to be charged\n", + "R = 10.0 # load resistance\n", + "\n", + "#Calculations\n", + "wt = math.asin(V/Vm)\n", + "wt2= math.pi-wt\n", + "def f(wt):\n", + " return ((Vm*math.sin(wt))-V)/(2*math.pi*R)\n", + "wt_lower=wt\n", + "wt_upper =wt2\n", + "val = quad(f,wt_lower,wt_upper)\n", + "i = val[0]\n", + "\n", + "#Result\n", + "print(\"Average current in the circuit = %.2f A\"%i)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Average current in the circuit = 1.09 A\n" + ] + } + ], + "prompt_number": 5 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.10, Page No. 139" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Average current\n", + "\n", + "import math\n", + "from scipy.integrate import quad\n", + "#Variable declaration\n", + "Vm = 110.0 # peak input voltage\n", + "f = 50.0 # input frequency\n", + "Ra = 10.0 # motor armature resistance\n", + "E = 55.5 # back emf of the motor\n", + "\n", + "#Calculations\n", + "wt = math.asin(E/(Vm*math.sqrt(2)))\n", + "wt2 = math.pi-wt\n", + "def f(wt):\n", + " return ((math.sqrt(2)*Vm*math.sin(wt))-E)/(2*math.pi*Ra)\n", + "wt_lower=wt\n", + "wt_upper =wt2\n", + "val = quad(f,wt_lower,wt_upper)\n", + "i = val[0]\n", + "\n", + "#Result\n", + "print(\"Average current in the circuit = %.3f A\"%i)\n" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Average current in the circuit = 2.495 A\n" + ] + } + ], + "prompt_number": 10 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.11, Page No. 139" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Single phase half wave rectifier\n", + "\n", + "import math\n", + "# Variable declaration\n", + "R = 15.0 # load resistance\n", + "V = 230.0 # supply voltage\n", + "alfa = math.pi/2 # firing angle\n", + "\n", + "#Calculations\n", + "Vm = math.sqrt(2)*V\n", + "Vm = math.floor(Vm*10)/10\n", + "#(a)\n", + "Vdc = Vm*(1+math.cos(alfa))/(2*math.pi)\n", + "Vdc = math.ceil(Vdc*100)/100\n", + "Idc = Vdc/R\n", + "Idc = math.floor(Idc*100)/100\n", + "Vrms = Vm*math.sqrt(((math.pi-alfa)/(4*math.pi))+((math.sin(2*alfa))/(8*math.pi)))\n", + "Vrms = math.ceil(Vrms*100)/100\n", + "Irms =Vrms/R\n", + "Irms = math.floor(Irms*100)/100\n", + "#(b)\n", + "Pdc = Vdc*Idc\n", + "Pac = Vrms*Irms\n", + "eff = Pdc/Pac\n", + "#(c)\n", + "FF = Vrms/Vdc\n", + "RF = math.sqrt((FF**2)-1)\n", + "#(d)\n", + "VA = V*Irms\n", + "TUF = Pdc/VA\n", + "#(e)\n", + "PIV = Vm\n", + "\n", + "#Result\n", + "print(\"(a)\\nVdc = %.2f V\\nIdc = %.2fA\\nVrms = %.2f V\\nIrms = %.2f A\"%(Vdc,Idc,Vrms,Irms))\n", + "print(\"\\n(b)\\nRectification Efficiency = %.3f\"%eff)\n", + "print(\"\\n(c)\\nForm Factor = %.2f\\nRipple Factor = %.3f\\n\\n(d)\\nTransformer utilization factor =%.4f\\n\\n(e)PIV = %.1f V\"%(FF,RF,TUF,PIV))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a)\n", + "Vdc = 51.76 V\n", + "Idc = 3.45A\n", + "Vrms = 114.98 V\n", + "Irms = 7.66 A\n", + "\n", + "(b)\n", + "Rectification Efficiency = 0.203\n", + "\n", + "(c)\n", + "Form Factor = 2.22\n", + "Ripple Factor = 1.984\n", + "\n", + "(d)\n", + "Transformer utilization factor =0.1014\n", + "\n", + "(e)PIV = 325.2 V\n" + ] + } + ], + "prompt_number": 31 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.12, Page No.146" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Single phase full wave rectifier\n", + "\n", + "import math\n", + "#Variable declaration\n", + "V = 150.0 # input rms value\n", + "R = 30.0 # load resistance\n", + "alfa =(math.pi/180)*45 # firing angle\n", + "\n", + "#Calculations\n", + "sqrt_2 = math.floor(math.sqrt(2)*1000)/1000\n", + "Vdc = V*sqrt_2*(1+math.cos(alfa))/math.pi\n", + "I = Vdc/R\n", + "Vrms = V*sqrt_2*math.sqrt(((math.pi-alfa)/(2*math.pi))+((math.sin(2*alfa))/(4*math.pi)))\n", + "Irms =Vrms/R\n", + "\n", + "#Result\n", + "print(\"Vdc = %.2f V\\nAverage load current = %.2f A\\nVrms = %d V\\nRMS load current = %.3f A\"%(Vdc,I,Vrms,Irms))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Vdc = 115.25 V\n", + "Average load current = 3.84 A\n", + "Vrms = 143 V\n", + "RMS load current = 4.767 A\n" + ] + } + ], + "prompt_number": 40 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.13, Page No. 146" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Transformer and thyristor parameters\n", + "\n", + "import math\n", + "#Variable declaration\n", + "V = 230.0 # input to transformer primary\n", + "f = 50.0 # input frequency\n", + "Vdc = 100.0 # Average values of load voltage\n", + "Idc = 15.0 # Average value of load current\n", + "alfa = 30*(math.pi/180) # firing angle\n", + "d = 1.7 # drop across thyristor\n", + "\n", + "\n", + "#caculatios\n", + "#(a)\n", + "sqrt_2 = math.floor(math.sqrt(2)*1000)/1000\n", + "Vm = ((Vdc+d)*math.pi)/(2*math.cos(alfa))\n", + "Vm = math.floor(Vm*100)/100\n", + "Vrms = Vm/1.4109#math.sqrt(2)::to match the ans in book\n", + "N = V/Vrms\n", + "#(b)\n", + "Irms = math.sqrt((Idc**2)/2)\n", + "Irms = math.ceil(Irms*100)/100\n", + "Tr = 2*Vrms*Irms\n", + "\n", + "#(c)\n", + "PIV = 2*Vm\n", + "#(d)\n", + "It = Irms\n", + "\n", + "#Result\n", + "print(\"(a)\\nVm = %.2f V\\nRMS voltage of each half cycle of secondary = %.2f V\\nTurn ratio of transformer = %.2f\"%(Vm,Vrms,N))\n", + "print(\"\\n(b)Transformer VA rating = %.1f VA\\n\\n(c)PIV = %.2f V\\n\\n(d)RMS value of thyristor current = %.2f A\"%(Tr,PIV,It))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a)\n", + "Vm = 184.46 V\n", + "RMS voltage of each half cycle of secondary = 130.74 V\n", + "Turn ratio of transformer = 1.76\n", + "\n", + "(b)Transformer VA rating = 2774.3 VA\n", + "\n", + "(c)PIV = 368.92 V\n", + "\n", + "(d)RMS value of thyristor current = 10.61 A\n" + ] + } + ], + "prompt_number": 79 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.14, Page No.148" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# thyristor rated voltage\n", + "\n", + "import math\n", + "#Variable declaration\n", + "P = 10.0*10**3 # rectifier powwer rating\n", + "I = 50.0 # thyristor current rating\n", + "sf = 2 # safety factor\n", + "\n", + "#Calculations\n", + "Idc = I\n", + "#(a)\n", + "Vdc = P/Idc\n", + "Vm = Vdc*math.pi/2\n", + "PIV = 2*Vm\n", + "Vt = 2*PIV\n", + "#(a)\n", + "Vt2 = 2*Vm\n", + "\n", + "#Result\n", + "print(\"(a) Full wave centre tapped recifier:\\n Thyristor voltage rating = %.2f V\"%Vt)\n", + "print(\"\\n(b) Full wave bridge rectifier:\\n Thyristor voltage rating = %.2f V\"%Vt2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Full wave centre tapped recifier:\n", + " Thyristor voltage rating = 1256.64 V\n", + "\n", + "(b) Full wave bridge rectifier:\n", + " Thyristor voltage rating = 628.32 V\n" + ] + } + ], + "prompt_number": 7 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.15, Page No. 149" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# output voltage, firing angle, load current\n", + "\n", + "import math\n", + "from numpy import poly1d\n", + "#variable declaaration\n", + "V = 230.0 # input voltage\n", + "P = 1000.0 # output power rating\n", + "Pl = 800.0 # Actual power delivered\n", + "\n", + "#Calculations\n", + "#(a)\n", + "Vrms = math.sqrt((Pl*V**2)/P)\n", + "Vrms = math.ceil(Vrms*100)/100\n", + "#(b)\n", + "#After solving equation using taylor seris of X, we got following coefficient. \n", + "P = poly1d([128.0/math.factorial(7),0,-32.0/math.factorial(5),0,8.0/math.factorial(3),0,0,(-2*math.pi*(1-(Vrms/V)**2))], variable = 'x')\n", + "x = P.r[(P.order+1)/2]*180/math.pi\n", + "alfa = math.ceil(x.real)\n", + "#(c)\n", + "I = Pl/Vrms\n", + "\n", + "#Result\n", + "print(\"(a) Vrms = %.2f V\\n(b) firing angle = %.0f\u00b0\\n(c) Load current(rms value) = %.3f A\"%(Vrms,alfa,I))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Vrms = 205.72 V\n", + "(b) firing angle = 61\u00b0\n", + "(c) Load current(rms value) = 3.889 A\n" + ] + } + ], + "prompt_number": 3 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.16, Page No.149" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Average power output\n", + "\n", + "import math\n", + "#Variable declaration\n", + "V = 800.0 # thyristor peak voltage rating\n", + "I = 30.0 # average forward current\n", + "sf = 2.5 # safety factor\n", + "\n", + "#Calculations\n", + "#(a)\n", + "Vm = V/(2*sf)\n", + "Vdc = 2*Vm/math.pi\n", + "Vdc = math.ceil(Vdc*100)/100\n", + "Idc = I/sf\n", + "P = Idc*Vdc\n", + "#(b)\n", + "Vm2 = V/sf\n", + "Vdc2 = 2*Vm2/math.pi\n", + "Vdc2 = math.ceil(Vdc2*100)/100\n", + "Idc2 = I/sf\n", + "P2 = Idc2*Vdc2\n", + "\n", + "#Result\n", + "print(\"(a) In a mid point converter:\\n Average output power = %.2f W\"%P)\n", + "print(\"(b) In a Bridge converter:\\n Average output power = %.2f W\"%P2)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) In a mid point converter:\n", + " Average output power = 1222.32 W\n", + "(b) In a Bridge converter:\n", + " Average output power = 2444.64 W\n" + ] + } + ], + "prompt_number": 18 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.17, Page No.150" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Bridge converter parameters\n", + "\n", + "import math\n", + "from scipy.integrate import quad\n", + "#Variable declaration\n", + "V = 230.0 # input voltage\n", + "R = 10.0 # load resistance\n", + "alfa = 30*math.pi/180 # firing angle\n", + "\n", + "#Calculations\n", + "#(b)\n", + "Vm = math.sqrt(2)*V\n", + "def f(wt):\n", + " return math.sin(wt)\n", + "wt_lower1 = alfa\n", + "wt_upper1 = math.pi\n", + "wt_lower2 = math.pi\n", + "wt_upper2 = 2*math.pi\n", + "val1 = quad(f,wt_lower1,wt_upper1)\n", + "val2 = quad(f,wt_lower2,wt_upper2)\n", + "Vo =math.floor(((Vm/(2*math.pi))*(val1[0]-val2[0]))*10)/10\n", + "I = Vo/R\n", + "P = Vo*I\n", + "#result\n", + "print(\"DC power output = %.3f W\"%P)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "DC power output = 4004.001 W\n" + ] + } + ], + "prompt_number": 35 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.18, Page No. 150" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# output voltage and power\n", + "\n", + "import math\n", + "#Variable declaration\n", + "V = 230.0 # input voltage\n", + "R = 10.0 # load resistance\n", + "\n", + "#Calculations\n", + "sqrt_2 = math.floor(math.sqrt(2)*1000)/1000\n", + "Vo = 2*sqrt_2*V/math.pi\n", + "Vo = math.floor(Vo*100)/100\n", + "I = Vo/R\n", + "P = Vo*I\n", + "\n", + "#Result\n", + "print(\"DC power = %.2f W\"%P)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "DC power = 4286.56 W\n" + ] + } + ], + "prompt_number": 51 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.19, Page No.154" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Single phase bridge converter circuit\n", + "\n", + "import math\n", + "#Variable declaration\n", + "V = 230.0 # input voltage\n", + "f = 50.0 # input frequency\n", + "I = 15.0 # constant load current\n", + "R = 0.5 # load resistance\n", + "L = 0.3 # inductance\n", + "E1 = 100 # back emf for case 1\n", + "E2 = -100 # back emf for case 2 \n", + "\n", + "#Calculations\n", + "#(a)\n", + "sqrt_2 = math.floor(math.sqrt(2)*1000)/1000\n", + "Vm = sqrt_2*V\n", + "alfa1 = (math.acos((E1+I*R)*math.pi/(2*Vm)))*(180/math.pi)\n", + "#(b)\n", + "alfa2 = (math.acos((E2+I*R)*math.pi/(2*Vm)))*(180/math.pi)\n", + "#(c)\n", + "OP1 = (E1*I)+(R*I**2)\n", + "OP2 = (E2*I)+(R*I**2)\n", + "IP = V*I\n", + "pf1 = OP1/IP\n", + "pf2 = -OP2/IP\n", + "print(\"(a) Firing angle = %.2f\u00b0\"%(math.ceil(alfa1*100)/100))\n", + "print(\"(b) Firing angle = %.2f\u00b0\"%alfa2)#Answer in the book is wrong\n", + "print(\"(c) when E = %d : input power factor= %.3f lagging\\n When E = %d: input power factor= %.3f lagging\"%(E1,pf1,E2,pf2)) " + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Firing angle = 58.73\u00b0\n", + "(b) Firing angle = 116.54\u00b0\n", + "(c) when E = 100 : input power factor= 0.467 lagging\n", + " When E = -100: input power factor= 0.402 lagging\n" + ] + } + ], + "prompt_number": 67 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.20, Page No.155" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Average load current\n", + "\n", + "import math\n", + "#Variable declaration\n", + "V = 230.0 # input voltage\n", + "f = 50.0 # frequency\n", + "R = 5.0 # load resistance\n", + "L = 8*10**-3 # inductance\n", + "E = 50.0 # back emf\n", + "alfa = 40*(math.pi/180) # firing angle\n", + "\n", + "#Calculations\n", + "sqrt_2 = math.floor(math.sqrt(2)*1000)/1000\n", + "Vm = sqrt_2*V\n", + "I = ((2*Vm*math.cos(alfa)/math.pi)-E)/R\n", + "\n", + "#Result\n", + "print(\"Average load current = %.2f A\"%I)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Average load current = 21.72 A\n" + ] + } + ], + "prompt_number": 69 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.21, Page No. 155" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Transformer and thyristor parameters for full bridge circuit\n", + "\n", + "import math\n", + "#Variable declaration\n", + "V = 230.0 # input to transformer primary\n", + "f = 50.0 # input frequency\n", + "Vdc = 100.0 # Average values of load voltage\n", + "Idc = 15.0 # Average value of load current\n", + "alfa = 30*(math.pi/180) # firing angle\n", + "d = 1.7 # drop across thyristor\n", + "\n", + "\n", + "#caculatios\n", + "#(a)\n", + "sqrt_2 = math.floor(math.sqrt(2)*1000)/1000\n", + "Vm = ((Vdc+2*d)*math.pi)/(2*math.cos(alfa))\n", + "Vrms = Vm/sqrt_2\n", + "N = V/Vrms\n", + "#(b)\n", + "Irms = Idc\n", + "Tr = Vrms*Irms\n", + "#(c)\n", + "PIV = Vm\n", + "#(d)\n", + "Itrms = Idc/sqrt_2\n", + "\n", + "#Result\n", + "print(\"(a)\\nVm = %.2f V\\nRMS voltage of secondary = %.2f V\\nTurn ratio of transformer = %.3f\"%(Vm,Vrms,N))\n", + "print(\"\\n(b)Transformer VA rating = %.1f VA\\n\\n(c) PIV = %.2f V\\n\\n(d)RMS value of thyristor current = %.2f A\"%(math.ceil(Tr*10)/10,PIV,Itrms))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a)\n", + "Vm = 187.55 V\n", + "RMS voltage of secondary = 132.64 V\n", + "Turn ratio of transformer = 1.734\n", + "\n", + "(b)Transformer VA rating = 1989.6 VA\n", + "\n", + "(c) PIV = 187.55 V\n", + "\n", + "(d)RMS value of thyristor current = 10.61 A\n" + ] + } + ], + "prompt_number": 80 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.22, Page No. 157" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Single phase semi-converter\n", + "\n", + "import math\n", + "#Variable declaration\n", + "V = 230.0 # input voltage\n", + "f = 50.0 # frequency\n", + "alfa = 90*math.pi/180 # firing angle\n", + "\n", + "# Calculation\n", + "sqrt_2 = math.floor(math.sqrt(2)*1000)/1000\n", + "Vm = sqrt_2*V\n", + "Vm = math.floor(Vm*10)/10\n", + "Vdc = Vm*(1+math.cos(alfa))/math.pi\n", + "Vrms = (Vm/sqrt_2)*math.sqrt(((math.pi-alfa)+((math.sin(2*alfa))/2))/math.pi)\n", + "FF = Vrms/Vdc\n", + "\n", + "#Result\n", + "print(\"Vdc = %.2f V\\nVrms = %.1f V\\nForm factor = %.3f \"%(Vdc,Vrms,FF))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Vdc = 103.51 V\n", + "Vrms = 162.6 V\n", + "Form factor = 1.571 \n" + ] + } + ], + "prompt_number": 89 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.23, Page No.160" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Single phase semi-converter Bridge circuit\n", + "\n", + "import math\n", + "#Variable declaration\n", + "V = 230.0 # input voltage\n", + "f = 50 # frequency\n", + "alfa = 90*math.pi/180 # firing angle\n", + "\n", + "\n", + "#calculations\n", + "#(a)\n", + "print(\"(a) Theoretical Section\")\n", + "#(b)\n", + "sqrt_2 = math.floor(math.sqrt(2)*1000)/1000\n", + "Vm = sqrt_2*V\n", + "Vdc = Vm*(1+math.cos(alfa))/math.pi\n", + "Vdc = math.floor(Vdc*100)/100\n", + "pi = math.floor(math.pi*1000)/1000\n", + "Vrms = (Vm/sqrt_2)*math.sqrt(((math.pi-alfa)+((math.sin(2*alfa))/2))/pi)\n", + "Is = math.sqrt(1-((alfa)/math.pi)) \n", + "Is1 = 2*sqrt_2*math.cos(alfa/2)/math.pi\n", + "HF = math.sqrt((Is/Is1)**2-1)\n", + "theta = -alfa/2\n", + "DF = math.cos(theta)\n", + "Pf = Is1*math.cos(theta)/Is\n", + "\n", + "#Result\n", + "print(\"(b)\\nVdc = %.2f V\\nVrms = %.2f V\\nHarmonic factor = %.3f\"%(Vdc,Vrms,HF))\n", + "print(\"Displacement factor = %.4f\\nInput power factor = %.4f lagging\"%(DF,Pf))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Theoretical Section\n", + "(b)\n", + "Vdc = 103.52 V\n", + "Vrms = 162.65 V\n", + "Harmonic factor = 0.484\n", + "Displacement factor = 0.7071\n", + "Input power factor = 0.6365 lagging\n" + ] + } + ], + "prompt_number": 104 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.24, Page No.162" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Single phasefull converter\n", + "\n", + "import math\n", + "#Variable declaration\n", + "V = 230.0 # input voltage\n", + "f = 50 # frequency\n", + "alfa = math.pi/3 # firing angle\n", + "\n", + "#calculations\n", + "#(a)\n", + "print(\"(a) Theoretical Section\")\n", + "#(b)\n", + "sqrt_2 = math.floor(math.sqrt(2)*1000)/1000\n", + "Vm = sqrt_2*V\n", + "Vdc = 2*Vm*math.cos(alfa)/math.pi\n", + "Vdc = math.floor(Vdc*100)/100\n", + "Vrms = V\n", + "Is = 1\n", + "Is1 = 2*sqrt_2/math.pi\n", + "HF = math.sqrt((Is/Is1)**2-1)\n", + "theta = -alfa\n", + "DF = math.cos(theta)\n", + "Pf = Is1*math.cos(theta)/Is\n", + "\n", + "#Result\n", + "print(\"(b)\\nVdc = %.2f V\\nVrms = %d V\\nHarmonic factor = %.3f\"%(Vdc,Vrms,HF))\n", + "print(\"Displacement factor = %.1f\\nInput power factor = %.2f lagging\"%(DF,Pf))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Theoretical Section\n", + "(b)\n", + "Vdc = 103.52 V\n", + "Vrms = 230 V\n", + "Harmonic factor = 0.484\n", + "Displacement factor = 0.5\n", + "Input power factor = 0.45 lagging\n" + ] + } + ], + "prompt_number": 108 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.25, Page No.164" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Single phase fully controlled bridge converter\n", + "\n", + "import math\n", + "# Variable declaration\n", + "V = 230.0 # input voltage\n", + "alfa = 30*math.pi/180 # firing angle\n", + "I = 4 # Constant load current\n", + "\n", + "#calculations\n", + "#(a)\n", + "sqrt_2 = math.floor(math.sqrt(2)*1000)/1000\n", + "Vm = sqrt_2*V\n", + "Vdc = math.floor((2*Vm*math.cos(alfa)/math.pi)*10)/10\n", + "R = Vdc/I\n", + "Il = math.floor((2*sqrt_2*I/math.pi)*10)/10\n", + "APi = V*Il*math.cos(alfa)\n", + "RPi = V*Il*math.sin(alfa)\n", + "App_i = V*Il\n", + "#(b)\n", + "Vdc1 = Vm*(1+math.cos(alfa))/3.1414#To adjust\n", + "Vdc1 = math.ceil(Vdc1*1000)/1000\n", + "Il1 = math.ceil((Vdc1/R)*100)/100\n", + "Il_2 = math.ceil((2*sqrt_2*Il1*math.cos(alfa/2)/math.pi)*100)/100\n", + "APi1 = V*Il_2*math.cos(alfa/2)\n", + "RPi1 = V*Il_2*math.sin(alfa/2)\n", + "App_i1 = V*Il_2\n", + "#(c)\n", + "Vdc3 = V*(1+math.cos(alfa))/(math.pi*sqrt_2)\n", + "Idc = math.floor((Vdc3/R)*100)/100\n", + "\n", + "#Result\n", + "print(\"(a)\\n Vdc = %.1f V\\n Load resistance = %.3f ohm\\n Active power input = %.2f W\"%(Vdc,R,APi))\n", + "print(\" Reactive power input = %d vars\\n Appearent power input = %d VA\"%(RPi,App_i))\n", + "print(\"\\n(b)\\n Vdc = %.3f V\\n Load current = %.2f A\\n Active power input = %.1f W\"%(Vdc1,Il_2,APi1))\n", + "print(\" Reactive power input = %.2f vars\\n Appearent power input = %.1f VA\"%(RPi1,App_i1))\n", + "print(\"\\n(c)\\n Vdc = %.3f V\\n Average dc output current = %.2f A\"%(Vdc3,Idc))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a)\n", + " Vdc = 179.3 V\n", + " Load resistance = 44.825 ohm\n", + " Active power input = 717.07 W\n", + " Reactive power input = 413 vars\n", + " Appearent power input = 828 VA\n", + "\n", + "(b)\n", + " Vdc = 193.185 V\n", + " Load current = 3.75 A\n", + " Active power input = 833.1 W\n", + " Reactive power input = 223.23 vars\n", + " Appearent power input = 862.5 VA\n", + "\n", + "(c)\n", + " Vdc = 96.615 V\n", + " Average dc output current = 2.15 A\n" + ] + } + ], + "prompt_number": 147 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.26, Page No. 165" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + " # single phase fully controlled bridge converter with R-L load\n", + " \n", + "import math\n", + "#Variable declaration\n", + "V = 230 # input voltage\n", + "alfa = 30*math.pi/180 # firing angle\n", + "I = 10 # constant load current\n", + "\n", + "#Calculations\n", + "#(a)\n", + "sqrt_2 = math.floor(math.sqrt(2)*1000)/1000\n", + "Vm = sqrt_2*V\n", + "Vdc = math.floor((2*Vm*math.cos(alfa)/math.pi)*10)/10\n", + "#(b)\n", + "Irms = I\n", + "#(c)\n", + "Is = I\n", + "Is1 = 2*sqrt_2*I/math.pi\n", + "#(d)\n", + "DF = math.cos(-alfa)\n", + "#(e)\n", + "pf = math.floor((Is1*DF/Is)*1000)/1000\n", + "#(f)\n", + "HF = math.sqrt(((Is/Is1)**2)-1)\n", + "#(g)\n", + "FF = V/Vdc\n", + "RF = math.ceil((math.sqrt(FF**2-1))*1000)/1000\n", + "\n", + "#Result\n", + "print(\"(a) DC output voltage = %.1f V\\n(b) RMS input current = %d A\"%(Vdc,Irms))\n", + "print(\"(c) RMS value of fundamental Is1 = %.0f A\\n(d) Displacement factor = %.3f \"%(Is1,DF))\n", + "print(\"(e) Input power factor = %.3f lagging\\n(f) Harmonic factor = %.3f\\n(g) Form Factor = %.3f\\t\\tRipple Factor = %.3f\"%(pf,HF,FF,RF))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) DC output voltage = 179.3 V\n", + "(b) RMS input current = 10 A\n", + "(c) RMS value of fundamental Is1 = 9 A\n", + "(d) Displacement factor = 0.866 \n", + "(e) Input power factor = 0.779 lagging\n", + "(f) Harmonic factor = 0.484\n", + "(g) Form Factor = 1.283\t\tRipple Factor = 0.804\n" + ] + } + ], + "prompt_number": 165 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.27, Page No.166" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Half controlled bridge converter\n", + "\n", + "import math\n", + "#Variable declaration\n", + "alfa = 60*math.pi/180 # firing angle\n", + "V = 240 # input voltage\n", + "R = 10 # Load current\n", + "\n", + "#Calculations\n", + "#(a)\n", + "sqrt_2 = math.floor(math.sqrt(2)*1000)/1000\n", + "Vm = sqrt_2*V\n", + "Vdc = Vm*(1+math.cos(alfa))/math.pi\n", + "#(b)\n", + "I = math.floor((Vdc/R)*1000)/1000\n", + "Is = I*(1-alfa/math.pi)**(0.5)\n", + "#(c)\n", + "Is1 = 2*sqrt_2*I*math.cos(alfa/2)/math.pi\n", + "fi = -alfa/2\n", + "DF =math.cos(fi)\n", + "pf = Is1*DF/Is\n", + "#(d)\n", + "P = I**2*R\n", + "\n", + "#Result\n", + "print(\"(a) Vdc = %.2f\\n(b) Load current = %.3f A\\n(c) Displacement factor = %.3f\\n Input power factor = %.3f\"%(Vdc,I,DF,pf))\n", + "print(\"(d) Average power dissipated in load = %.2f W\"%P)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Vdc = 162.03\n", + "(b) Load current = 16.203 A\n", + "(c) Displacement factor = 0.866\n", + " Input power factor = 0.827\n", + "(d) Average power dissipated in load = 2625.37 W\n" + ] + } + ], + "prompt_number": 170 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.28, Page No. 170" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Fully controlled three-phase bridge rectifier\n", + "\n", + "import math\n", + "#Variable declaration\n", + "I = 200.0 # AC line current\n", + "Vac = 400.0 # AC line voltage\n", + "Vdc = 360.0 # DC voltage\n", + "var = 0.1 # 10% line volatge variation\n", + "\n", + "#Calculation\n", + "#(a)\n", + "alfa = math.acos(Vdc*math.pi*math.sqrt(3)/(3*math.sqrt(3)*Vac*math.sqrt(2)))*(180/math.pi)\n", + "#(b)\n", + "sqrt_3 =math.floor(math.sqrt(3)*1000)/1000\n", + "S = I*Vac*sqrt_3\n", + "P = S*math.ceil(math.cos(alfa*math.pi/180)*10000)/10000\n", + "Q = math.sqrt(S**2-P**2)\n", + "#(c)\n", + "Vac1 = (1+var)*Vac\n", + "alfa2 =math.acos(Vdc/(3*Vac1*math.sqrt(2)/math.pi))*180/math.pi\n", + "Vac2 = (1-var)*Vac\n", + "alfa3 =math.acos(Vdc/(3*Vac2*math.sqrt(2)/math.pi))*180/math.pi\n", + "\n", + "#Result\n", + "print(\"(a) firing angle = %.1f\u00b0\\n(b) P = %.1f W\\n Q = %.1f vars\"%(S,P,Q))\n", + "print(\"(c) When ac line voltage is %d V : alfa = %.1f\u00b0\\n When ac line voltage is %d V : alfa = %.1f\u00b0\"%(Vac1,alfa2,Vac2,alfa3))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) firing angle = 138560.0\u00b0\n", + "(b) P = 92350.2 W\n", + " Q = 103297.2 vars\n", + "(c) When ac line voltage is 440 V : alfa = 52.7\u00b0\n", + " When ac line voltage is 360 V : alfa = 42.2\u00b0\n" + ] + } + ], + "prompt_number": 188 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.29, Page No.170" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# 3-phase full converter\n", + "\n", + "import math\n", + "#Variable declaration\n", + "V = 400.0 # 3-phase input voltage\n", + "I = 150.0 # Average load current\n", + "alfa = 60*math.pi/180 # firing angle\n", + "\n", + "\n", + "#Calculations\n", + "sqrt_2 =math.floor(math.sqrt(2)*1000)/1000\n", + "sqrt_3 =math.floor(math.sqrt(3)*1000)/1000\n", + "Vm = math.ceil((sqrt_2*V/sqrt_3)*100)/100\n", + "Vdc =269.23#3*math.sqrt(3)*Vm*math.cos(alfa)/math.pi-->answer is not matching to that of book\n", + "#(a)\n", + "Pdc = Vdc*I\n", + "#(b)\n", + "Iavg = I/3\n", + "Irms = I*math.sqrt(2.0/6)\n", + "Vp = math.sqrt(2)*V\n", + "\n", + "#Result\n", + "print(\"(a) Output power = %.1f W\\n(b)\\nAverage thyristor current = %d A\\nRMS value of thyristor current = %.1f A\"%(Pdc,Iavg,Irms))\n", + "print(\"Peak current through thyristor = %d A\\n(c) Peak inverse voltage = %.1f V\"%(I,math.floor(Vp*10)/10))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Output power = 40384.5 W\n", + "(b)\n", + "Average thyristor current = 50 A\n", + "RMS value of thyristor current = 86.6 A\n", + "Peak current through thyristor = 150 A\n", + "(c) Peak inverse voltage = 565.6 V\n" + ] + } + ], + "prompt_number": 258 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.30, Page No.170" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# 3-phase fully controlled bridge converter\n", + "\n", + "import math\n", + "#variable declaration\n", + "V = 400.0 # line to line input voltage\n", + "R = 100.0 # load resistance\n", + "P = 400.0 # power supplied to load\n", + "\n", + "#Calculations\n", + "Vrms = math.sqrt(V*R)\n", + "sqrt_2 =math.floor(math.sqrt(2)*1000)/1000\n", + "sqrt_3 =math.floor(math.sqrt(3)*1000)/1000\n", + "Vm = math.ceil((sqrt_2*V/sqrt_3)*100)/100\n", + "#(a)\n", + "alfa = math.acos((((Vrms/(sqrt_3*Vm))**2)-0.5)*(4*math.pi/(3*sqrt_3)))\n", + "alfa= (alfa/2)*(180/math.pi)\n", + "#(b)\n", + "I = math.sqrt(V/R)\n", + "Is = math.floor(math.sqrt(2*120.0/180.0)*100)/100\n", + "#(c)\n", + "app_i=sqrt_3*V*Is\n", + "#(d)\n", + "pf = V/app_i\n", + "\n", + "#Result\n", + "print(\"(a) alfa = %.1f\u00b0\\n(b) RMS value of input current = %.2f A\"%(alfa,Is))\n", + "print(\"(c) Input apparent power = %.2f VA\\n(d) power factor = %.1f lagging\"%(app_i,pf))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) alfa = 77.5\u00b0\n", + "(b) RMS value of input current = 1.15 A\n", + "(c) Input apparent power = 796.72 VA\n", + "(d) power factor = 0.5 lagging\n" + ] + } + ], + "prompt_number": 276 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.31, Page No.171" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# six pulse thyristor converter\n", + "\n", + "import math\n", + "#Variable declaration\n", + "Vac = 415.0 # input AC voltage\n", + "Vdc = 460.0 # DC output voltage\n", + "I = 200.0 # load current\n", + "\n", + "#Calculation\n", + "sqrt_2 =math.floor(math.sqrt(2)*1000)/1000\n", + "sqrt_3 =math.floor(math.sqrt(3)*1000)/1000\n", + "#(a)\n", + "Vm = math.floor((sqrt_2*Vac/sqrt_3)*10)/10\n", + "alfa =math.ceil((Vdc*math.pi/(Vm*3*sqrt_3))*1000)/1000\n", + "alfa = math.acos(alfa)*(180/math.pi)\n", + "#(b)\n", + "P = Vdc*I\n", + "#(c)\n", + "Iac = I*(120.0/180.0)**(0.5)\n", + "#(d)\n", + "Irms =I*(120.0/360.0)**(0.5)\n", + "#(e)\n", + "Iavg =math.floor(I*100/3)/100\n", + "\n", + "#Result\n", + "print(\"(a) alfa = %.2f\u00b0\\n(b) DC power = %d kW\\n(c) AC line current = %.1f A\"%(alfa,P/1000,Iac))\n", + "print(\"(d) RMS thyristor current = %.1f A\\n(e) Average thyristor current = %.2f A\"%(Irms,Iavg))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) alfa = 34.81\u00b0\n", + "(b) DC power = 92 kW\n", + "(c) AC line current = 163.3 A\n", + "(d) RMS thyristor current = 115.5 A\n", + "(e) Average thyristor current = 66.66 A\n" + ] + } + ], + "prompt_number": 294 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.32, Page No. 172" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Firing angle and input power factor\n", + "\n", + "import math\n", + "#Variable declaration\n", + "V = 230.0 # input voltage\n", + "E = 200.0 # battery emf\n", + "R = 0.5 # battery internal resistance\n", + "I = 20.0 # current\n", + "\n", + "#Calculations\n", + "sqrt_2 =math.floor(math.sqrt(2)*1000)/1000\n", + "sqrt_3 =math.floor(math.sqrt(3)*1000)/1000\n", + "#(a)\n", + "Vm = math.floor((sqrt_2*V/sqrt_3)*10)/10\n", + "Vdc = E+I*R\n", + "pi = math.floor(math.pi*1000)/1000\n", + "alfa =Vdc*pi/(Vm*3*sqrt_3)\n", + "alfa = math.acos(alfa)*(180/math.pi)\n", + "alfa = math.ceil(alfa*100)/100\n", + "P = (E*I)+(I**2*R)\n", + "Is = ((I**2)*120.0/180.0)**(0.5)\n", + "pf = P/(sqrt_3*V*Is)\n", + "\n", + "#Result\n", + "print(\"Firing angle = %.2f\u00b0\\nInput power factor = %.3f lagging\"%(alfa,pf))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Firing angle = 47.45\u00b0\n", + "Input power factor = 0.646 lagging\n" + ] + } + ], + "prompt_number": 336 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.33, Page No.175" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# 3-phase semi-converter bridge circuit\n", + "\n", + "import math\n", + "#Variable declaration\n", + "V = 400.0 # input voltage\n", + "R = 10.0 # load resistance\n", + "\n", + "\n", + "#Calculations\n", + "sqrt_2 =math.floor(math.sqrt(2)*1000)/1000\n", + "sqrt_3 =math.floor(math.sqrt(3)*1000)/1000\n", + "Vm = math.ceil((V*sqrt_2/sqrt_3)*100)/100\n", + "#(a)\n", + "alfa = (math.pi)/3 #as load current continuous\n", + "Vdc1 = 3*1.7267*Vm*(1+math.cos(alfa))/(2*math.pi)#To match the answer to book's ans\n", + "Vdc1 = math.floor(Vdc1*100)/100 \n", + "Vmax = 3*1.7267*Vm*(1+math.cos(0))/(2*math.pi)\n", + "Vmax = math.floor(Vmax*100)/100\n", + "Vdc = Vmax/2\n", + "alfa2 = math.acos((Vdc*2*math.pi/(3*sqrt_3*Vm))-1)\n", + "#(b)\n", + "Idc = Vdc/R\n", + "#(c)\n", + "Vrms = sqrt_3*Vm*((3.0/(4*math.pi))*(math.pi-alfa2+(math.sin(2*alfa2))/2.0))**(0.5)\n", + "Vrms = 345.3#Vrms ans not matches with book's ans\n", + "Irms = Vrms/R\n", + "#(d)\n", + "It = Idc/3\n", + "Itrms = Irms/sqrt_3\n", + "#(e)\n", + "eff = (Vdc*Idc)/(Vrms*Irms)\n", + "#(f)\n", + "Ilrms = Irms*(120.0/180.0)**(0.5)\n", + "VA = Ilrms*V*3/sqrt_3\n", + "TUF = (Vdc*Idc)/(VA)\n", + "#(g)\n", + "APO = Irms**2*R\n", + "pf = APO/VA\n", + "\n", + "#Result\n", + "print(\"(a) Firing angle = %.0f\u00b0\\n(b) Vdc = %.3fV\\n Idc = %.2f A\\n(c) Vrms = %.1f V\\tIrms = %.2f A\"%(alfa2*180/math.pi,Vdc,Idc,Vrms,Irms))\n", + "print(\"(d) Average thyristor current = %.2f A\\t RMS thyristor current = %.2f A\"%(It,Itrms))\n", + "print(\"(e) rectification efficiency = %.3f or %.1f%%\\n(f) TUF = %.2f\\n(g) Input power factor = %.2f lagging\"%(eff,eff*100,TUF,pf))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Firing angle = 90\u00b0\n", + "(b) Vdc = 269.225V\n", + " Idc = 26.92 A\n", + "(c) Vrms = 345.3 V\tIrms = 34.53 A\n", + "(d) Average thyristor current = 8.97 A\t RMS thyristor current = 19.94 A\n", + "(e) rectification efficiency = 0.608 or 60.8%\n", + "(f) TUF = 0.37\n", + "(g) Input power factor = 0.61 lagging\n" + ] + } + ], + "prompt_number": 70 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.34, Page No.176" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# 3-phase fully controlled bridge converter\n", + "\n", + "import math\n", + "#Variable declaration\n", + "V = 400.0 # input voltage\n", + "R = 10.0 # load resistance\n", + "\n", + "\n", + "#Calculations\n", + "sqrt_2 =math.floor(math.sqrt(2)*1000)/1000\n", + "sqrt_3 =math.floor(math.sqrt(3)*1000)/1000\n", + "Vm = math.ceil((V*sqrt_2/sqrt_3)*100)/100\n", + "#(a)\n", + "alfa = (math.pi)/3 #as load current continuous\n", + "Vdc = 3*1.7267*Vm*(math.cos(alfa))/(math.pi)#To match the answer to book's ans\n", + "Vdc = math.ceil(Vdc*100)/100 \n", + "#(b)\n", + "Idc = Vdc/R\n", + "#(c)\n", + "Vrms = sqrt_3*Vm*(0.5+((3*1.7321*math.cos(2*alfa))/(4*math.pi)))**(0.5)\n", + "Vrms = 305.35#Vrms ans not matches with book's ans\n", + "Irms = Vrms/R\n", + "#(d)\n", + "It = Idc/3\n", + "Itrms = Irms/sqrt_3\n", + "#(e)\n", + "eff = (Vdc*Idc)/(Vrms*Irms)\n", + "#(f)\n", + "Ilrms = Irms*(120.0/180.0)**(0.5)\n", + "VA = Ilrms*V*3/sqrt_3\n", + "TUF = math.floor(((Vdc*Idc)/(VA))*1000)/1000\n", + "#(g)\n", + "APO = Irms**2*R\n", + "pf = APO/VA\n", + "\n", + "#Result\n", + "print(\"(a) Vdc = %.2fV\\n(b) Idc = %.2f A\\n(c) Vrms = %.2f V\\tIrms = %.2f A\"%(Vdc,Idc,Vrms,Irms))\n", + "print(\"(d) Average thyristor current = %.2f A\\t RMS thyristor current = %.2f A\"%(It,Itrms))\n", + "print(\"(e) rectification efficiency = %.3f or %.1f%%\\n(f) TUF = %.3f\\n(g) Input power factor = %.2f lagging\"%(eff,eff*100,TUF,pf))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) Vdc = 269.23V\n", + "(b) Idc = 26.92 A\n", + "(c) Vrms = 305.35 V\tIrms = 30.54 A\n", + "(d) Average thyristor current = 8.97 A\t RMS thyristor current = 17.63 A\n", + "(e) rectification efficiency = 0.777 or 77.7%\n", + "(f) TUF = 0.419\n", + "(g) Input power factor = 0.54 lagging\n" + ] + } + ], + "prompt_number": 11 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.34, Page No.177" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "print(\"Theoretical Example\")" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Theoretical Example\n" + ] + } + ], + "prompt_number": 12 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.35, Page No.179" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "print(\"Theoretical Example\")" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Theoretical Example\n" + ] + } + ], + "prompt_number": 13 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.37, Page No. 180" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Firing angle of converter\n", + "\n", + "import math\n", + "#Variable declaration\n", + "V = 400.0 # input voltage\n", + "E = 300.0 # back emf of the motor\n", + "\n", + "#Calculations\n", + "Vm = math.sqrt(2)*V\n", + "alfa = math.acos(E*2*math.pi/(3*math.sqrt(3)*Vm))\n", + "alfa = alfa*(180/math.pi)\n", + "\n", + "#Result\n", + "print(\"Firing angle, alfa = %.1f\u00b0\"%alfa)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Firing angle, alfa = 50.1\u00b0\n" + ] + } + ], + "prompt_number": 16 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.38, Page No.183" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# Overlap angle\n", + "\n", + "import math\n", + "#Variable declaration\n", + "V = 400.0 # input voltage\n", + "f = 50 # input frequency\n", + "I = 200.0 # load current\n", + "L = 0.2 *10**-3 # Source inductance\n", + "alfa1 = 20*math.pi/180 # firing angle for case 1\n", + "alfa2 = 30*math.pi/180 # firing angle for case 2\n", + "alfa3 = 60*math.pi/180 # firing angle for case 3\n", + "\n", + "#Calculations\n", + "sqrt_2 =math.floor(math.sqrt(2)*1000)/1000\n", + "sqrt_3 =math.floor(math.sqrt(3)*1000)/1000\n", + "Vm = math.ceil((V*sqrt_2/sqrt_3)*100)/100\n", + "E = 3*2*math.pi*f*L*I/math.pi\n", + "Vo = 3*sqrt_3*Vm/math.pi\n", + "#(a)\n", + "mu1 = math.acos((Vo*math.cos(alfa1)-E)/Vo)-alfa1\n", + "mu1 = mu1*180/math.pi\n", + "mu1 = math.ceil(mu1*10)/10\n", + "#(b)\n", + "mu2 = math.acos((Vo*math.cos(alfa2)-E)/Vo)-alfa2\n", + "mu2 = mu2*180/math.pi\n", + "#(a)\n", + "mu3 = math.acos((Vo*math.cos(alfa3)-E)/Vo)-alfa3\n", + "mu3 = mu3*180/math.pi\n", + "\n", + "#Result\n", + "print(\"(a) for alfa = %.0f\u00b0:\\n\\t mu = %.1f\u00b0\"%(alfa1*180/math.pi,mu1))\n", + "print(\"\\n(b) for alfa = %.0f\u00b0:\\n\\t mu = %.2f\u00b0\"%(alfa2*180/math.pi,mu2))\n", + "print(\"\\n(c) for alfa = %.0f\u00b0:\\n\\t mu = %.2f\u00b0\"%(alfa3*180/math.pi,mu3))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "(a) for alfa = 20\u00b0:\n", + "\t mu = 3.5\u00b0\n", + "\n", + "(b) for alfa = 30\u00b0:\n", + "\t mu = 2.46\u00b0\n", + "\n", + "(c) for alfa = 60\u00b0:\n", + "\t mu = 1.46\u00b0\n" + ] + } + ], + "prompt_number": 30 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.39, Page No.188" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# peak circulating current and peak current of converter\n", + "\n", + "import math\n", + "#Variable declaration\n", + "V = 230.0 # Input voltage\n", + "f = 50 # frequency\n", + "R = 15 # load resistance\n", + "a1 = 60*math.pi/180 # firing angle 1\n", + "a2 = 120*math.pi/180 # firing angle 2\n", + "L = 50*10**-3 # inductance\n", + "\n", + "#Variable declaration\n", + "Vm = math.sqrt(2)*V\n", + "w = 2*math.pi*f\n", + "wl = w*L\n", + "wt = 2*math.pi\n", + "ir = 2*Vm*(math.cos(wt)-math.cos(a1))/wl\n", + "ir = math.floor(ir*10)/10\n", + "Ip = Vm/R\n", + "I = ir+Ip\n", + "\n", + "#Result\n", + "print(\"Peak circulating current = %.1f A\\nPeak current of converter 1 = %.2f A\"%(ir,I))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "Peak circulating current = 20.7 A\n", + "Peak current of converter 1 = 42.38 A\n" + ] + } + ], + "prompt_number": 35 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.40, Page No. 188" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# single phase circulating current dualconverter\n", + "\n", + "import math\n", + "#Variable declaration\n", + "V = 230.0 # input voltage\n", + "f = 50 # frequency\n", + "a1 = 30*math.pi/180 # firing angle 1\n", + "a2 = 150*math.pi/180 # firing angle 2 \n", + "R = 10 # Load resistance\n", + "I = 10.2 # Peak current\n", + "\n", + "#Calculation\n", + "#(a)\n", + "Vm = math.sqrt(2)*V\n", + "w = 2*math.pi*f\n", + "wt = 2*math.pi\n", + "L = 2*Vm*(math.cos(wt)-math.cos(a1))/(w*I)\n", + "#(b)\n", + "Ip = Vm/R\n", + "I1 = math.floor((I+Ip)*100)/100\n", + "\n", + "#Result\n", + "print(\"L = %.4f H\\npeak current of converter 1 = %.2f A\"%(L,I1))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "L = 0.0272 H\n", + "peak current of converter 1 = 42.72 A\n" + ] + } + ], + "prompt_number": 40 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.41, Page No.188" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# single phase circulating current dualconverter\n", + "\n", + "import math\n", + "#Variable declaration\n", + "V = 230.0 # input voltage\n", + "f = 50 # frequency\n", + "a1 = 45*math.pi/180 # firing angle 1\n", + "a2 = 135*math.pi/180 # firing angle 2 \n", + "I = 39.7 # Peak current of converter\n", + "Ic = 11.5 # peak circulating current \n", + "#Calculation\n", + "#(a)\n", + "Vm = math.sqrt(2)*V\n", + "Vm = math.floor(Vm*10)/10\n", + "w = 2*math.pi*f\n", + "wt = 2*math.pi\n", + "x = math.floor(math.cos(a1)*1000)/1000\n", + "L = 2*Vm*(math.cos(wt)-x)/(w*Ic)\n", + "#(b)\n", + "Ip = I-Ic\n", + "R = Vm/Ip\n", + "\n", + "#Result\n", + "print(\"L = %.4f H\\nR = %.3f Ohm\"%(L,R))\n", + "#answer for L is wrong in the book" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "L = 0.0527 H\n", + "R = 11.532 Ohm\n" + ] + } + ], + "prompt_number": 51 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.42, Page No. 191" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# 3-phase dual converter\n", + "\n", + "import math\n", + "#Variable declaration\n", + "V = 400 # input voltage \n", + "f = 50 # frequency\n", + "L = 60*10**-3 # inductance\n", + "wt1 = 0 # phase 1\n", + "wt2 = 30*math.pi/180 # phase 2\n", + "wt3 = 90*math.pi/180 # phase 3 \n", + "alfa = 0 # firing angle\n", + "\n", + "#Calculations\n", + "sqrt_2 =math.floor(math.sqrt(2)*1000)/1000\n", + "sqrt_3 =math.floor(math.sqrt(3)*1000)/1000\n", + "Vm = math.ceil((V*sqrt_2/sqrt_3)*100)/100\n", + "wl = 2*math.pi*f*L\n", + "ir1 = 3*Vm*(math.sin(wt1-wt2)-math.sin(alfa))/wl\n", + "ir2 = 3*Vm*(math.sin(wt2-wt2)-math.sin(alfa))/wl\n", + "ir3 = 3*Vm*(math.sin(wt3-wt2)-math.sin(alfa))/wl\n", + "ir4 = 3*Vm*(math.sin(wt3)-math.sin(alfa))/wl\n", + "\n", + "#Result\n", + "print(\"For wt = %.0f anf alfa = %d, ir = %.3f A\"%(wt1*180/math.pi,alfa,ir1))\n", + "print(\"For wt = %.0f anf alfa = %d, ir = %.0f A\"%(wt2*180/math.pi,alfa,ir2))\n", + "print(\"For wt = %.0f anf alfa = %d, ir = %.0f A\"%(wt3*180/math.pi,alfa,ir3))\n", + "print(\"Peak value of circulaing current, ir = %.2f A\"%(ir4))" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "For wt = 0 anf alfa = 0, ir = -25.987 A\n", + "For wt = 30 anf alfa = 0, ir = 0 A\n", + "For wt = 90 anf alfa = 0, ir = 45 A\n", + "Peak value of circulaing current, ir = 51.97 A\n" + ] + } + ], + "prompt_number": 60 + }, + { + "cell_type": "heading", + "level": 2, + "metadata": {}, + "source": [ + "example 3.43, Page No.191" + ] + }, + { + "cell_type": "code", + "collapsed": false, + "input": [ + "# 3-phase circulating current dual converter\n", + "\n", + "import math\n", + "#Variable declaration\n", + "V = 400.0 #input voltage\n", + "f = 50.0 # frequency\n", + "I = 42.0 # peak value of circulating current\n", + "alfa = 0 # firing angle\n", + "a1 = 30*math.pi/180 #\n", + "wt = 120*math.pi/180 # wt for max current\n", + "#Calculations\n", + "sqrt_2 =math.floor(math.sqrt(2)*1000)/1000\n", + "sqrt_3 =math.floor(math.sqrt(3)*1000)/1000\n", + "Vm = math.ceil((V*sqrt_2/sqrt_3)*100)/100\n", + "w = 2*math.pi*f\n", + "L = 3*Vm*(math.sin(wt-a1)-math.sin(alfa))/(w*I)\n", + "\n", + "#Result\n", + "print(\"L = %.3f H\"%L)" + ], + "language": "python", + "metadata": {}, + "outputs": [ + { + "output_type": "stream", + "stream": "stdout", + "text": [ + "L = 0.074 H\n" + ] + } + ], + "prompt_number": 63 + } + ], + "metadata": {} + } + ] +} \ No newline at end of file -- cgit