{
 "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": {}
  }
 ]
}