diff options
Diffstat (limited to 'Electric_Machinery_and_Transformers/CHAP_14.ipynb')
| -rwxr-xr-x | Electric_Machinery_and_Transformers/CHAP_14.ipynb | 2601 |
1 files changed, 2601 insertions, 0 deletions
diff --git a/Electric_Machinery_and_Transformers/CHAP_14.ipynb b/Electric_Machinery_and_Transformers/CHAP_14.ipynb new file mode 100755 index 00000000..2f2f7423 --- /dev/null +++ b/Electric_Machinery_and_Transformers/CHAP_14.ipynb @@ -0,0 +1,2601 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "CHAPTER 14: TRANSFORMERS"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.1, Page number 487"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "N_1 = 500.0 #Number of turns in the hv side i.e primary\n",
+ "N_2 = 100.0 #Number of turns in the lv side i.e secondary\n",
+ "I_2 = 12.0 #Load current i.e secondary(A)\n",
+ "\n",
+ "#Calculation\n",
+ "#For step-down transformer\n",
+ "alpha = N_1/N_2 #Transformation ratio\n",
+ "I_1 = I_2/alpha #Load component of primary current(A)\n",
+ "#For step-up transformer\n",
+ "N1 = 100.0 #Number of turns in the lv side i.e primary\n",
+ "N2 = 500.0 #Number of turns in the hv side i.e secondary\n",
+ "alpha_c = N1/N2 #Transformation ratio\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Transformation ratio , \u03b1 = %.f ' %alpha)\n",
+ "print('Case(b): Load component of primary current , I_1 = %.1f A' %I_1)\n",
+ "print('Case(c): Transformation ratio if transformer is used as step-up , \u03b1 = %.1f ' %alpha_c)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Transformation ratio , \u03b1 = 5 \n",
+ "Case(b): Load component of primary current , I_1 = 2.4 A\n",
+ "Case(c): Transformation ratio if transformer is used as step-up , \u03b1 = 0.2 \n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.2, Page number 488"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V_h = 2300.0 #Primary voltage i.e hv(V)\n",
+ "V_l = 115.0 #Secondary voltage i.e lv(V)\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "S = 4.6 #Rating of the step-down transformer(kVA)\n",
+ "V_per_turn = 2.5 #Induced EMF per turn(V/turn)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "N_h = V_h/V_per_turn #Number of high-side turns\n",
+ "N_l = V_l/V_per_turn #Number of low-side turns\n",
+ "N_1 = N_h\n",
+ "N_2 = N_l\n",
+ "#Case(b)\n",
+ "V_1 = V_h\n",
+ "V_2 = V_l\n",
+ "S_1 = S\n",
+ "S_2 = S\n",
+ "I_1 = S_1*1000/V_1 #Rated primary current(A)\n",
+ "I_2 = S_2*1000/V_2 #Rated secondary current(A)\n",
+ "I_h = I_1\n",
+ "I_l = I_2\n",
+ "#Case(c)\n",
+ "alpha_stepdown_c = N_1/N_2 #Step-down transformation ratio\n",
+ "alpha_stepup_c = N_l/N_h #Step-up transformation ratio\n",
+ "#Case(d)\n",
+ "alpha_stepdown_d = I_2/I_1 #Step-down transformation ratio\n",
+ "alpha_stepup_d = I_h/I_l #Step-up transformation ratio\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Number of high-side turns , N_h = %.f t = N_1 ' %N_h)\n",
+ "print(' Number of low-side turns , N_l = %.f t = N_2 ' %N_l)\n",
+ "print('Case(b): Rated primary current , I_h = I_1 = %.f A' %I_h)\n",
+ "print(' Rated secondary current , I_l = I_2 = %.f A' %I_l)\n",
+ "print('Case(c): Step-down transformation ratio , \u03b1 = %.f ' %alpha_stepdown_c);\n",
+ "print(' Step-up transformation ratio , \u03b1 = %.2f ' %alpha_stepup_c);\n",
+ "print('Case(d): Step-down transformation ratio , \u03b1 = %.f ' %alpha_stepdown_d);\n",
+ "print(' Step-up transformation ratio , \u03b1 = %.2f ' %alpha_stepup_d);"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Number of high-side turns , N_h = 920 t = N_1 \n",
+ " Number of low-side turns , N_l = 46 t = N_2 \n",
+ "Case(b): Rated primary current , I_h = I_1 = 2 A\n",
+ " Rated secondary current , I_l = I_2 = 40 A\n",
+ "Case(c): Step-down transformation ratio , \u03b1 = 20 \n",
+ " Step-up transformation ratio , \u03b1 = 0.05 \n",
+ "Case(d): Step-down transformation ratio , \u03b1 = 20 \n",
+ " Step-up transformation ratio , \u03b1 = 0.05 \n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.3, Page number 489"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "N_1 = 500.0 #Number of primary turns\n",
+ "N_2 = 25.0 #Number of secondary turns\n",
+ "Z_L = 8.0 #Impedance(ohm)\n",
+ "V_1 = 10.0 #Output voltage of the amplifier(V)\n",
+ "\n",
+ "#Calculation\n",
+ "alpha = N_1/N_2 #Step-down transformation ratio\n",
+ "Z_1 = alpha**2*Z_L #Impedance reflected to the transformer primary at the output of the amplifier(ohm)\n",
+ "I_1 = V_1/Z_1*1000 #Matching transformer primary current(mA)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Impedance reflected to the transformer primary at the output of the amplifier , Z_1 = %.f \u03a9' %Z_1)\n",
+ "print('Case(b): Matching transformer primary current , I_1 = %.3f mA' %I_1)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Impedance reflected to the transformer primary at the output of the amplifier , Z_1 = 3200 \u03a9\n",
+ "Case(b): Matching transformer primary current , I_1 = 3.125 mA\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.4, Page number 490"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "N_1 = 600.0 #Number of primary turns \n",
+ "N_2 = 150.0 #Some number of secondary turns \n",
+ "N_3 = 300.0 #Some number of secondary turns \n",
+ "Z_2 = 30.0 #Resistive load across N_2(ohm)\n",
+ "Z_3 = 15.0 #Resistive load across N_3(ohm)\n",
+ "V_p = 16.0 #Primary applied voltage(V)\n",
+ "cos_theta = 1.0 #Unity PF\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "Z_2_prime = Z_2*(N_1/N_2)**2 #Impedance reflected to the primary by load Z_2(ohm)\n",
+ "#Case(b)\n",
+ "Z_3_prime = Z_3*(N_1/N_3)**2 #Impedance reflected to the primary by load Z_3(ohm)\n",
+ "#Case(c)\n",
+ "Z_1 = (Z_2_prime*Z_3_prime)/(Z_2_prime+Z_3_prime) #Total impedance reflected to primary(ohm)\n",
+ "#Case(d)\n",
+ "I_1 = V_p/Z_1 #Total current drawn from the supply(A)\n",
+ "#Case(e)\n",
+ "P_t = V_p*I_1*cos_theta #Total power drawn from the supply at unity PF(W)\n",
+ "#Case(f)\n",
+ "R_2 = Z_2\n",
+ "V_2 = V_p*(N_2/N_1) #Voltage across load Z_2(V)\n",
+ "P_2 = V_2**2/R_2 #Power dissipated in load Z_2(W)\n",
+ "#Case(g)\n",
+ "R_3 = Z_3\n",
+ "V_3 = V_p*(N_3/N_1) #Voltage across Z_3 in volt\n",
+ "P_3 = V_3**2 / R_3 #Power dissipated in load Z_3(W)\n",
+ "#Case(h)\n",
+ "P_total = P_2+P_3 #Total power dissipated in both loads(W)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Impedance reflected to the primary by load Z_2 = %.f \u03a9' %Z_2_prime)\n",
+ "print('Case(b): Impedance reflected to the primary by load Z_3 = %.f \u03a9' %Z_3_prime)\n",
+ "print('Case(c): Total impedance reflected to the primary , Z_1 = %.1f \u03a9' %Z_1)\n",
+ "print('Case(d): Total current drawn from the supply , I_1 = %.1f A' %I_1)\n",
+ "print('Case(e): Total power drawn from the supply at unity power factor , P_t = %.1f W' %P_t)\n",
+ "print('Case(f): Voltage across load Z_2 , V_2 = %.f V' %V_2)\n",
+ "print(' Power dissipated in load Z_2 , P_2 = %.2f W' %P_2)\n",
+ "print('Case(g): Voltage across load Z_3 , V_3 = %.f V' %V_3)\n",
+ "print(' Power dissipated in load Z_3 , P_3 = %.2f W' %P_3)\n",
+ "print('Case(h): Total power dissipated in both loads , P_t = %.1f W ' %P_total)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Impedance reflected to the primary by load Z_2 = 480 \u03a9\n",
+ "Case(b): Impedance reflected to the primary by load Z_3 = 60 \u03a9\n",
+ "Case(c): Total impedance reflected to the primary , Z_1 = 53.3 \u03a9\n",
+ "Case(d): Total current drawn from the supply , I_1 = 0.3 A\n",
+ "Case(e): Total power drawn from the supply at unity power factor , P_t = 4.8 W\n",
+ "Case(f): Voltage across load Z_2 , V_2 = 4 V\n",
+ " Power dissipated in load Z_2 , P_2 = 0.53 W\n",
+ "Case(g): Voltage across load Z_3 , V_3 = 8 V\n",
+ " Power dissipated in load Z_3 , P_3 = 4.27 W\n",
+ "Case(h): Total power dissipated in both loads , P_t = 4.8 W \n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.5, Page number 491"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P = 100.0 #Power rating of the single channel power amplifier(W)\n",
+ "Z_p = 3200.0 #Output impedance ohm of the single channel power amplifier(ohm)\n",
+ "N_p = 1500.0 #Number of primary turns in a tapped impedance-matching transformer\n",
+ "Z_L1 = 8.0 #Amplifier output using a tapped impedance-matching transformer(ohm)\n",
+ "Z_L2 = 4.0 #Amplifier output using a tapped impedance-matching transformer(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "alpha = (Z_p/Z_L1)**0.5 #Transformation ratio\n",
+ "N_2 = N_p/alpha #Total number of secondary turns to match 8 ohm speaker\n",
+ "#Case(b)\n",
+ "alpha_b = (Z_p/Z_L2)**0.5 #Transformation ratio\n",
+ "N_1 = N_p/alpha_b #Number of primary turns to match 4 ohm speaker\n",
+ "#Case(c)\n",
+ "turns_difference = N_2-N_1 #Difference in secondary and primary turns\n",
+ "alpha_c = (N_p/turns_difference) #Transformation ratio\n",
+ "Z_L = Z_p/alpha_c**2 #Impedance that must be connected(ohm)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Total number of secondary turns to match 8 \u03a9 impedance speaker , N_2 = %.f t' %N_2)\n",
+ "print('Case(b): Number of turns to match 4 \u03a9 impedance speaker , N_1 = %.f t' %N_1)\n",
+ "print('Case(c): Impedance that must be connected , Z_L = %.2f \u03a9' %Z_L)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Total number of secondary turns to match 8 \u03a9 impedance speaker , N_2 = 75 t\n",
+ "Case(b): Number of turns to match 4 \u03a9 impedance speaker , N_1 = 53 t\n",
+ "Case(c): Impedance that must be connected , Z_L = 0.69 \u03a9\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.6, Page number 492"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "P = 100.0 #Power rating of the single channel power amplifier(W)\n",
+ "Z_L1 = 8.0 #Amplifier output using a tapped impedance-matching transformer(ohm)\n",
+ "Z_L2 = 4.0 #Amplifier output using a tapped impedance-matching transformer(ohm)\n",
+ "P_servo = 10.0 #Power rating of the servo motor(W)\n",
+ "Z_servo = 0.7 #Impedance of the servo motor(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "root_Z_AB = 8**0.5-4**0.5\n",
+ "Z_AB = (root_Z_AB)**2\n",
+ "\n",
+ "#Result\n",
+ "print('Impedance between terminals A and B , Z_AB = %.2f \u03a9' %Z_AB)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Impedance between terminals A and B , Z_AB = 0.69 \u03a9\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.7, Page number 494"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "V_s = 10.0*cmath.exp(1j*0*math.pi/180) #Supply voltage of the source(V)\n",
+ "R_s = 1000.0 #Resistance of the source(ohm)\n",
+ "R_L = 10.0 #Load resistance(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "alpha = (R_s/R_L)**0.5 #Transformation ratio of the matching transformer for MPT\n",
+ "#Case(b)\n",
+ "V = abs(V_s) #Considering only absolute value of Supply voltage for easy simplification\n",
+ "V_1 = V/2 #Terminal voltage of the source at MPT(V)\n",
+ "#Case(c)\n",
+ "V_2 = V_1/alpha #Terminal voltage across the load at MPT(V)\n",
+ "#Case(d)\n",
+ "Z_L = R_L\n",
+ "I_2 = V_2/Z_L #Secondary load current(A). Method 1\n",
+ "I2 = V/(2*alpha*R_L) #Secondary load current(A). Method 2\n",
+ "#Case(e)\n",
+ "I_1 = I_2/alpha #Primary load current drawn from the source(A). Method 1\n",
+ "I1 = V/(2*R_s) #Primary load current drawn from the source(A). Method 2\n",
+ "#Case(f)\n",
+ "P_L = (I_2)**2*R_L #Maximum power dissipated in the load(W)\n",
+ "#Case(g)\n",
+ "P_s = (I_1)**2*R_s #Power dissipated internally within the source(W)\n",
+ "#Case(h)\n",
+ "theta = 0\n",
+ "P_T1 = abs(V)*I_1*math.cos(theta) #Total power supplied by the source(W). Method 1\n",
+ "P_T2 = P_L+P_s #Total power supplied by the source(W). Method 2\n",
+ "#Case(i)\n",
+ "P_T = P_T1\n",
+ "n = P_L/P_T*100 #Power transfer efficiency(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Transformation ratio of the matching transformer for MPT , \u03b1 = %.f ' %alpha)\n",
+ "print('Case(b): Terminal voltage of the source at MPT , V_1 = %.1f V' %V_1)\n",
+ "print('Case(c): Terminal voltage across the load at MPT , V_2 = %.1f V' %V_2)\n",
+ "print('Case(d): Secondary load current , I_2 = %.f mA (Method 1)' %(1000*I_2))\n",
+ "print(' Secondary load current , I_2 = %.f mA (Method 2)' %(1000*I2))\n",
+ "print('Case(e): Primary load current drawn from the source , I_1 = %.f mA (Method 1)' %(1000*I_1))\n",
+ "print(' Primary load current drawn from the source , I_1 = %.f mA (Method 2)' %(1000*I1))\n",
+ "print('Case(f): Maximum power dissipated in the load , P_L = %.f mW' %(1000*P_L))\n",
+ "print('Case(g): Power dissipated internally within the source , P_s = %.f mW' %(1000*P_s))\n",
+ "print('Case(h): Total power supplied by the source , P_T = %.f mW (Method 1)' %(1000*P_T1))\n",
+ "print(' Total power supplied by the source , P_T = %.f mW (Method 2)' %(1000*P_T2))\n",
+ "print('Case(i): Power transfer efficiency , \u03b7 = %.f percent' %n)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Transformation ratio of the matching transformer for MPT , \u03b1 = 10 \n",
+ "Case(b): Terminal voltage of the source at MPT , V_1 = 5.0 V\n",
+ "Case(c): Terminal voltage across the load at MPT , V_2 = 0.5 V\n",
+ "Case(d): Secondary load current , I_2 = 50 mA (Method 1)\n",
+ " Secondary load current , I_2 = 50 mA (Method 2)\n",
+ "Case(e): Primary load current drawn from the source , I_1 = 5 mA (Method 1)\n",
+ " Primary load current drawn from the source , I_1 = 5 mA (Method 2)\n",
+ "Case(f): Maximum power dissipated in the load , P_L = 25 mW\n",
+ "Case(g): Power dissipated internally within the source , P_s = 25 mW\n",
+ "Case(h): Total power supplied by the source , P_T = 50 mW (Method 1)\n",
+ " Total power supplied by the source , P_T = 50 mW (Method 2)\n",
+ "Case(i): Power transfer efficiency , \u03b7 = 50 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.8, Page number 495"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V = 20.0 #No-load voltage(V)\n",
+ "R_s = 18.0 #Internal resistance of the power amplifier(ohm)\n",
+ "R_L = 8.0 #Load resistance(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "V_L = (R_L/(R_L+R_s))* V #Load voltage(V)\n",
+ "P_L = (V_L)**2/R_L #Power delivered to the speaker when connected directly to the amplifier(W)\n",
+ "alpha = (R_s/R_L)**0.5 #Turns ratio of the transformer to maximize speaker power\n",
+ "V_2 = V/(2*alpha) #Secondary voltage(V)\n",
+ "P_L2 = (V_2)**2/R_L #Maximum power delivered to the speaker(W)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Power delivered to the speaker when connected directly to the amplifier , P_L = %.2f W' %P_L)\n",
+ "print('Case(b): Turns ratio of the transformer to maximize speaker power , \u03b1 = %.1f ' %alpha)\n",
+ "print('Case(c): Maximum power delivered to the speaker using matching transformer of part(b) , P_L = %.1f W' %P_L2)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Power delivered to the speaker when connected directly to the amplifier , P_L = 4.73 W\n",
+ "Case(b): Turns ratio of the transformer to maximize speaker power , \u03b1 = 1.5 \n",
+ "Case(c): Maximum power delivered to the speaker using matching transformer of part(b) , P_L = 5.6 W\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.9, Page number 500"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "kVA = 1.0 #Rating of the transformer(kVA)\n",
+ "V_1 = 220.0 #Primary voltage(V)\n",
+ "V_2 = 110.0 #Secondary voltage(V)\n",
+ "f_o = 400.0 #Original frequency(Hz)\n",
+ "f_f = 60.0 #Frequency for which the transformer is to be used(Hz)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "alpha = V_1/V_2 #Transformation ratio\n",
+ "E_h = V_1*(f_f/f_o) #Maximum rms voltage applied to HV side(V)\n",
+ "E_1 = E_h\n",
+ "E_l = E_1/alpha #Maximum voltage output of LV side(V)\n",
+ "#Case(b)\n",
+ "V_h = V_1 #High voltage(V)\n",
+ "I_h = kVA*1000/V_h #High current(A)\n",
+ "Vh = E_h\n",
+ "kVA_new = Vh*I_h/1000 #kVA rating of transformer under reduced frequency\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Maximum rms voltage that may be applied to high-voltage side , E_h = %.f V' %E_h)\n",
+ "print(' Maximum voltage output of the low-voltage side , E_l = %.1f V' %E_l)\n",
+ "print('Case(b): kVA rating of transformer under conditions of reduced frequency , V_h*I_h = %.2f kVA' %kVA_new)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Maximum rms voltage that may be applied to high-voltage side , E_h = 33 V\n",
+ " Maximum voltage output of the low-voltage side , E_l = 16.5 V\n",
+ "Case(b): kVA rating of transformer under conditions of reduced frequency , V_h*I_h = 0.15 kVA\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.10, Page number 501"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "kVA = 1.0 #kVA rating of the transformer\n",
+ "V_1 = 220.0 #Primary voltage(V)\n",
+ "V_2 = 110.0 #Secondary voltage(V)\n",
+ "f_o = 400.0 #Frequency(Hz)\n",
+ "f_f = 60.0 #Frequency for which the transformer is to be used(Hz)\n",
+ "P_orig = 10.0 #Original iron losses of the transformer(W)\n",
+ "\n",
+ "#Calculation \n",
+ "B = f_o/f_f #Flux density\n",
+ "P_iron = P_orig*B**2 #Iron losses(W)\n",
+ "\n",
+ "#Result\n",
+ "print('Iron losses if is operated at reduced frequency of 60 Hz , P_iron = %.f W' %P_iron)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Iron losses if is operated at reduced frequency of 60 Hz , P_iron = 444 W\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.11, Page number 504"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "kVA = 500.0 #Rating of the step-down transformer(kVA)\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 230.0 #Secondary voltage(V)\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "r_1 = 0.1 #Primary winding resistance(ohm)\n",
+ "x_1 = 0.3 #Primary winding reactance(ohm)\n",
+ "r_2 = 0.001 #Secondary winding resistance(ohm)\n",
+ "x_2 = 0.003 #Secondary winding reactance(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "alpha = V_1/V_2 #Transformation ratio\n",
+ "#Case(a)\n",
+ "I_2 = kVA*1000/V_2 #Secondary current(A)\n",
+ "I_1 = I_2/alpha #Primary current(A)\n",
+ "#Case(b)\n",
+ "Z_2 = complex(r_2,x_2) #Secondary internal impedance(ohm)\n",
+ "Z_2_m = abs(Z_2) #Magnitude of Z_2(ohm)\n",
+ "Z_1 = complex(r_1,x_1) #Primary internal impedance(ohm)\n",
+ "Z_1_m = abs(Z_1) #Magnitude of Z_1(ohm)\n",
+ "#Case(c)\n",
+ "I_2_Z_2 = I_2*Z_2_m #Secondary internal voltage drop(V)\n",
+ "I_1_Z_1 = I_1*Z_1_m #Primary internal voltage drop(V)\n",
+ "#Case(d)\n",
+ "E_2 = V_2+I_2_Z_2 #Secondary induced voltage(V)\n",
+ "E_1 = V_1-I_1_Z_1 #Primary induced voltage(V)\n",
+ "#Case(e)\n",
+ "ratio_E = E_1/E_2 #Ratio of primary to secondary induced voltage\n",
+ "ratio_V = V_1/V_2 #Ratio of primary to secondary terminal voltage\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Secondary current , I_2 = %.f A' %I_2)\n",
+ "print(' Primary current , I_1 = %.1f A' %I_1)\n",
+ "print('Case(b): Secondary internal impedance , Z_2 = %.5f \u03a9' %Z_2_m)\n",
+ "print(' Primary internal impedance , Z_1 = %.3f \u03a9' %Z_1_m)\n",
+ "print('Case(c): Secondary internal voltage drop , I_2*Z_2 = %.2f V' %I_2_Z_2)\n",
+ "print(' Primary internal voltage drop , I_1*Z_1 = %.1f V' %I_1_Z_1)\n",
+ "print('Case(d): Secondary induced voltage , E_2 = %.2f V' %E_2)\n",
+ "print(' Primary induced voltage , E_1 = %.1f V' %E_1)\n",
+ "print('Case(e): Ratio of primary to secondary induced voltages , E_1/E_2 = %.2f ' %ratio_E)\n",
+ "print(' Ratio of primary to secondary iterminal voltages , V_1/V_2 = %.1f ' %ratio_V)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Secondary current , I_2 = 2174 A\n",
+ " Primary current , I_1 = 217.4 A\n",
+ "Case(b): Secondary internal impedance , Z_2 = 0.00316 \u03a9\n",
+ " Primary internal impedance , Z_1 = 0.316 \u03a9\n",
+ "Case(c): Secondary internal voltage drop , I_2*Z_2 = 6.87 V\n",
+ " Primary internal voltage drop , I_1*Z_1 = 68.7 V\n",
+ "Case(d): Secondary induced voltage , E_2 = 236.87 V\n",
+ " Primary induced voltage , E_1 = 2231.3 V\n",
+ "Case(e): Ratio of primary to secondary induced voltages , E_1/E_2 = 9.42 \n",
+ " Ratio of primary to secondary iterminal voltages , V_1/V_2 = 10.0 \n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.12, Page number 505"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 230.0 #Secondary voltage(V)\n",
+ "I_2 = 2174.0 #Secondary current(A)\n",
+ "I_1 = 217.4 #Primary current(A)\n",
+ "Z_2 = 0.00316 #Secondary internal impedance(ohm)\n",
+ "Z_1 = 0.316 #Primary internal impedance(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "alpha = V_1/V_2 #Transformation ratio\n",
+ "#Case(a)\n",
+ "Z_L = V_2/I_2 #Load impedance(ohm)\n",
+ "#Case(b)\n",
+ "Z_p = V_1/I_1 #Primary input impedance(ohm)\n",
+ "Zp = alpha**2*Z_L #Primary input impedance(ohm)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Load impedance , Z_L = %.4f \u03a9' %Z_L)\n",
+ "print('Case(b): Primary input impedance , Z_p = %.2f \u03a9 (Method 1)' %Z_p)\n",
+ "print(' Primary input impedance , Z_p = %.2f \u03a9 (Method 2)' %Zp)\n",
+ "print('Case(c): Impedance of load Z_L = %.4f \u03a9, is much greater than internal secondary impedance Z_2 = %.5f \u03a9' %(Z_L,Z_2))\n",
+ "print(' Primary input impedance Z_p = %.2f \u03a9, is much greater than the internal primary impedance Z_1 = %.3f \u03a9' %(Z_p,Z_1))\n",
+ "print('Case(d): Z_L must be much greater than Z_2 so that major part of the voltage produced by E_2 is dropped across Z_L')\n",
+ "print(' As Z_L is reduced in proportion to Z_2, the load current increases and more voltage is dropped internally across Z_2')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Load impedance , Z_L = 0.1058 \u03a9\n",
+ "Case(b): Primary input impedance , Z_p = 10.58 \u03a9 (Method 1)\n",
+ " Primary input impedance , Z_p = 10.58 \u03a9 (Method 2)\n",
+ "Case(c): Impedance of load Z_L = 0.1058 \u03a9, is much greater than internal secondary impedance Z_2 = 0.00316 \u03a9\n",
+ " Primary input impedance Z_p = 10.58 \u03a9, is much greater than the internal primary impedance Z_1 = 0.316 \u03a9\n",
+ "Case(d): Z_L must be much greater than Z_2 so that major part of the voltage produced by E_2 is dropped across Z_L\n",
+ " As Z_L is reduced in proportion to Z_2, the load current increases and more voltage is dropped internally across Z_2\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.13, Page number 505"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "kVA = 500.0 #Rating of the step-down transformer(kVA)\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 230.0 #Secondary voltage(V)\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "r_1 = 0.1 #Primary winding resistance(ohm)\n",
+ "x_1 = 0.3 #Primary winding reactance(ohm)\n",
+ "r_2 = 0.001 #Secondary winding resistance(ohm)\n",
+ "x_2 = 0.003 #Secondary winding reactance(ohm)\n",
+ "Z_L = 0.1058 #Load impedance(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "alpha = V_1/V_2 #Transformation ratio\n",
+ "R_c1 = r_1+alpha**2*r_2 #Equivalent internal resistance referred to the primary side(ohm)\n",
+ "X_c1 = x_1+alpha**2*x_2 #Equivalent internal reactance referred to the primary side(ohm)\n",
+ "Z_c1 = complex(R_c1,X_c1) #Equivalent internal impedance referred to the primary side(ohm)\n",
+ "Z_c1_m = abs(Z_c1) #Magnitude of Z_e1(ohm)\n",
+ "Z_L_prime = alpha**2*Z_L #Equivalent secondary load impedance referred to the primary side(ohm)\n",
+ "R_L = Z_L #Load resistance(ohm)\n",
+ "X_L = 0 #Load reactance(ohm)\n",
+ "I_1 = V_1/complex((R_c1+alpha**2*R_L),(X_c1+alpha**2*X_L)) #Primary load current(A)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Equivalent internal resistance referred to the primary side , R_c1 = %.1f \u03a9' %R_c1)\n",
+ "print('Case(b): Equivalent internal reactance referred to the primary side , X_c1 = %.1f \u03a9' %X_c1)\n",
+ "print('Case(c): Equivalent internal impedance referred to the primary side , Z_c1 = %.3f \u03a9' %Z_c1_m)\n",
+ "print('Case(d): Equivalent secondary load impedance referred to the primary side , \u03b1^2*Z_L = %.2f \u03a9' %Z_L_prime)\n",
+ "print('Case(e): Primary load current , I_1 = %.f A' %abs(I_1))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Equivalent internal resistance referred to the primary side , R_c1 = 0.2 \u03a9\n",
+ "Case(b): Equivalent internal reactance referred to the primary side , X_c1 = 0.6 \u03a9\n",
+ "Case(c): Equivalent internal impedance referred to the primary side , Z_c1 = 0.632 \u03a9\n",
+ "Case(d): Equivalent secondary load impedance referred to the primary side , \u03b1^2*Z_L = 10.58 \u03a9\n",
+ "Case(e): Primary load current , I_1 = 213 A\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.14, Page number 508"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "kVA = 500.0 #Rating of the step-down transformer(kVA)\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 230.0 #Secondary voltage(V)\n",
+ "R_e2 = 2.0 #Equivalent resistance referred to the primary side(m\u03a9)\n",
+ "X_e2 = 6.0 #Equivalent reactance referred to the primary side(m\u03a9)\n",
+ "cos_theta2 = 1.0 #Unity PF\n",
+ "\n",
+ "#Calculation\n",
+ "I_2 = kVA/V_2 #Rated secondary current(kA)\n",
+ "R_e2_drop = I_2*R_e2 #Full-load equivalent resistance voltage drop(V)\n",
+ "X_e2_drop = I_2*X_e2 #Full-load equivalent reactance voltage drop(V) \n",
+ "sin_theta2 = (1-cos_theta2**2)**0.5\n",
+ "E_2 = complex((V_2*cos_theta2+I_2*R_e2),(V_2*sin_theta2+I_2*X_e2)) #Induced voltage(V)\n",
+ "E_2_m = abs(E_2) #Magnitude of E_2(V)\n",
+ "VR = (E_2_m-V_2)/V_2*100 #Percent voltage regulation at unity PF(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Rated secondary current , I_2 = %.3f kA' %I_2)\n",
+ "print('Case(b): Full-load equivalent resistance voltage drop , I_2*R_e2 = %.2f V' %R_e2_drop)\n",
+ "print('Case(c): Full-load equivalent reactance voltage drop , I_2*X_e2 = %.2f V' %X_e2_drop)\n",
+ "print('Case(d): Induced voltage when the transformer is delivering rated current at unity PF , E_2 = %.2f V' %E_2_m)\n",
+ "print('Case(e): Voltage regulation at unity PF , VR = %.2f percent' %VR)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Rated secondary current , I_2 = 2.174 kA\n",
+ "Case(b): Full-load equivalent resistance voltage drop , I_2*R_e2 = 4.35 V\n",
+ "Case(c): Full-load equivalent reactance voltage drop , I_2*X_e2 = 13.04 V\n",
+ "Case(d): Induced voltage when the transformer is delivering rated current at unity PF , E_2 = 234.71 V\n",
+ "Case(e): Voltage regulation at unity PF , VR = 2.05 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.15, Page number 508"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "kVA = 500.0 #Rating of the step-down transformer(kVA)\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 230.0 #Secondary voltage(V)\n",
+ "R_e2 = 2.0 #Equivalent resistance referred to the primary side(m\u03a9)\n",
+ "X_e2 = 6.0 #Equivalent reactance referred to the primary side(m\u03a9)\n",
+ "cos_theta2 = 0.8 #Lagging PF\n",
+ "\n",
+ "#Calculation\n",
+ "I_2 = kVA/V_2 #Rated secondary current(kA)\n",
+ "R_e2_drop = I_2*R_e2 #Full-load equivalent resistance voltage drop(V)\n",
+ "X_e2_drop = I_2*X_e2 #Full-load equivalent reactance voltage drop(V) \n",
+ "sin_theta2 = (1-cos_theta2**2)**0.5\n",
+ "E_2 = complex((V_2*cos_theta2+I_2*R_e2),(V_2*sin_theta2+I_2*X_e2)) #Induced voltage(V)\n",
+ "E_2_m = abs(E_2) #Magnitude of E_2(V)\n",
+ "VR = (E_2_m-V_2)/V_2*100 #Percent voltage regulation(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(d): Induced voltage when the transformer is delivering rated current at 0.8 PF lagging , E_2 = %.2f V' %E_2_m)\n",
+ "print('Case(e): Voltage regulation at 0.8 PF lagging , VR = %.2f percent' %VR)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(d): Induced voltage when the transformer is delivering rated current at 0.8 PF lagging , E_2 = 241.43 V\n",
+ "Case(e): Voltage regulation at 0.8 PF lagging , VR = 4.97 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.16, Page number 508"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "kVA = 500.0 #Rating of the step-down transformer(kVA)\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 230.0 #Secondary voltage(V)\n",
+ "R_e2 = 2.0 #Equivalent resistance referred to the primary side(m\u03a9)\n",
+ "X_e2 = 6.0 #Equivalent reactance referred to the primary side(m\u03a9)\n",
+ "cos_theta2 = 0.6 #Leading PF\n",
+ "\n",
+ "#Calculation\n",
+ "I_2 = kVA/V_2 #Rated secondary current(kA)\n",
+ "R_e2_drop = I_2*R_e2 #Full-load equivalent resistance voltage drop(V)\n",
+ "X_e2_drop = I_2*X_e2 #Full-load equivalent reactance voltage drop(V) \n",
+ "sin_theta2 = (1-cos_theta2**2)**0.5\n",
+ "E_2 = complex((V_2*cos_theta2+I_2*R_e2),(V_2*sin_theta2-I_2*X_e2)) #Induced voltage(V)\n",
+ "E_2_m = abs(E_2) #Magnitude of E_2(V)\n",
+ "VR = (E_2_m-V_2)/V_2*100 #Percent voltage regulation(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(d): Induced voltage when the transformer is delivering rated current at 0.6 PF leading , E_2 = %.1f V' %E_2_m)\n",
+ "print('Case(e): Voltage regulation at 0.6 PF leading , VR = %.2f percent' %VR)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(d): Induced voltage when the transformer is delivering rated current at 0.6 PF leading , E_2 = 222.5 V\n",
+ "Case(e): Voltage regulation at 0.6 PF leading , VR = -3.28 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.17, Page number 511"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Variable declaration\n",
+ "kVA = 20.0 #kVA rating of the step-down transformer\n",
+ "S = 20000.0 #Power rating of the step-down transformer in VA\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 230.0 #Secondary voltage(V)\n",
+ "P1 = 250.0 #Wattmeter reading(W)\n",
+ "I1 = 8.7 #Input current(A)\n",
+ "V1 = 50.0 #Input voltage(V)\n",
+ "\n",
+ "#Calculation\n",
+ "alpha = V_1/V_2 #Transformation ratio\n",
+ "#Case(a)\n",
+ "Z_e1 = V1/I1 #Equivalent impedance w.r.t HV side(ohm)\n",
+ "R_e1 = P1/I1**2 #Equivalent resistance w.r.t HV side(ohm)\n",
+ "theta = math.acos(R_e1/Z_e1) #PF angle(radians)\n",
+ "theta_a = theta*180/math.pi #PF angle(degree)\n",
+ "X_e1 = Z_e1*math.sin(theta) #Equivalent reactance w.r.t HV side(ohm)\n",
+ "#Case(b)\n",
+ "Z_e2 = Z_e1/alpha**2 #Equivalent impedance w.r.t LV side(ohm)\n",
+ "R_e2 = R_e1/alpha**2 #Equivalent resistance w.r.t LV side(ohm)\n",
+ "X_e2 = Z_e2*math.sin(theta) #Equivalent reactance w.r.t LV side(ohm)\n",
+ "#Case(c)\n",
+ "I_2 = S/V_2 #Rated secondary load current(A)\n",
+ "R_e2_drop = I_2*R_e2 #Full-load equivalent resistance voltage drop(V)\n",
+ "X_e2_drop = I_2*X_e2 #Full-load equivalent reactance voltage drop(V)\n",
+ "cos_theta2 = 1.0 #Unity PF\n",
+ "sin_theta2 = (1-cos_theta2**2)**0.5\n",
+ "E_2 = complex((V_2*cos_theta2+I_2*R_e2),(V_2*sin_theta2+I_2*X_e2)) #Induced voltage(V)\n",
+ "E_2_m = abs(E_2) #Magnitude of E_2(V)\n",
+ "VR_unity_PF = (E_2_m-V_2)/V_2*100 #Transformer voltage regulation(%)\n",
+ "#Case(d)\n",
+ "cos_theta_2 = 0.7 #Lagging PF\n",
+ "sin_theta_2 = (1-(cos_theta_2)**2)**0.5\n",
+ "E2 = complex((V_2*cos_theta_2+I_2*R_e2),(V_2*sin_theta_2+I_2*X_e2)) #Induced voltage(V)\n",
+ "E2_m = abs(E2) #Magnitude of E2(V)\n",
+ "VR_lag_PF = (E2_m-V_2)/V_2*100 #Transformer voltage regulation(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Equivalent impedance referred to HV side , Z_e1 = %.2f \u03a9' %Z_e1)\n",
+ "print(' Equivalent resistance referred to HV side , R_e1 = %.1f \u03a9' %R_e1)\n",
+ "print(' Equivalent reactance referred to HV side , X_e1 = %.2f \u03a9' %X_e1)\n",
+ "print('Case(b): Equivalent impedance referred to LV side , Z_e2 = %.1f m\u03a9' %(1000*Z_e2))\n",
+ "print(' Equivalent resistance referred to LV side , R_e2 = %.f m\u03a9' %(1000*R_e2))\n",
+ "print(' Equivalent reactance referred to LV side , X_e2 = %.1f m\u03a9' %(1000*X_e2))\n",
+ "print('Case(c): Transformer voltage regulation , VR = %.2f percent' %VR_unity_PF)\n",
+ "print('Case(c): Transformer voltage regulation , VR = %.2f percent' %VR_lag_PF)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Equivalent impedance referred to HV side , Z_e1 = 5.75 \u03a9\n",
+ " Equivalent resistance referred to HV side , R_e1 = 3.3 \u03a9\n",
+ " Equivalent reactance referred to HV side , X_e1 = 4.70 \u03a9\n",
+ "Case(b): Equivalent impedance referred to LV side , Z_e2 = 57.5 m\u03a9\n",
+ " Equivalent resistance referred to LV side , R_e2 = 33 m\u03a9\n",
+ " Equivalent reactance referred to LV side , X_e2 = 47.0 m\u03a9\n",
+ "Case(c): Transformer voltage regulation , VR = 1.26 percent\n",
+ "Case(c): Transformer voltage regulation , VR = 2.14 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.18, Page number 511"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V1_rated = 2300.0 #Primary voltage(V)\n",
+ "V_sc = 50.0 #Short circuit test voltage(V)\n",
+ "\n",
+ "#Calculation\n",
+ "Pc_sc_Pc = (V_sc/V1_rated)**2 #Fraction of rated core loss\n",
+ "\n",
+ "#Result\n",
+ "print('Fraction of P_c measured by wattmeter , P_c(sc) = %.6f*P_c ' %Pc_sc_Pc)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Fraction of P_c measured by wattmeter , P_c(sc) = 0.000473*P_c \n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.19, Page number 512"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Variable declaration\n",
+ "kVA = 20.0 #kVA rating of the step-down transformer\n",
+ "S = 20000.0 #Power rating of the step-down transformer in VA\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 230.0 #Secondary voltage(V)\n",
+ "P1 = 250.0 #Wattmeter reading(W)\n",
+ "I1 = 8.7 #Input current(A)\n",
+ "V1 = 50.0 #Input voltage(V)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "I1_Ze1 = V1 #HV impedance drop(V)\n",
+ "#Case(b)\n",
+ "theta = math.acos(P1/(V1*I1)) #PF angle(radian)\n",
+ "theta_a = theta*180/math.pi #PF angle(degree)\n",
+ "I1_Re1 = I1_Ze1*math.cos(theta) #HV side resistance volt drop(V)\n",
+ "#Case(c)\n",
+ "I1_Xe1 = I1_Ze1*math.sin(theta) #HV side resistance volt drop(V)\n",
+ "#Case(d)\n",
+ "cos_theta1 = 1.0 #Unity PF\n",
+ "sin_theta1 = (1-cos_theta1**2)**0.5\n",
+ "E1 = complex((V_1*cos_theta1+I1_Re1),(V_1*sin_theta1+I1_Xe1)) #Induced voltage(V)\n",
+ "E1_m = abs(E1) #Magnitude of E1(V)\n",
+ "VR = (E1_m-V_1)/V_1*100 #Transformer voltage regulation at unity PF(%)\n",
+ "#Case(e)\n",
+ "cos_theta_1 = 0.7 #Lagging PF\n",
+ "sin_theta_1 = (1-cos_theta_1**2)**0.5\n",
+ "E_1 = complex((V_1*cos_theta_1+I1_Re1),(V_1*sin_theta_1+I1_Xe1)) #Induced voltage(V)\n",
+ "E_1_m = abs(E_1) #Magnitude of E_1(V)\n",
+ "VR_1 = (E_1_m-V_1)/V_1*100 #Transformer voltage regulation at 0.7 PF lagging(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): High voltage impedance drop , I_1*Z_e1 = %.f V' %I1_Ze1)\n",
+ "print('Case(b): HV side resistance volt drop , I_1*R_e1 = %.2f V' %I1_Re1)\n",
+ "print('Case(c): HV side reactance volt drop , I_1*X_e1 = %.2f V' %I1_Xe1)\n",
+ "print('Case(d): Transformer voltage regulation at unity PF , VR = %.2f percent' %VR)\n",
+ "print('Case(e): Transformer voltage regulation at 0.7 PF lagging , VR = %.2f percent' %VR_1)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): High voltage impedance drop , I_1*Z_e1 = 50 V\n",
+ "Case(b): HV side resistance volt drop , I_1*R_e1 = 28.74 V\n",
+ "Case(c): HV side reactance volt drop , I_1*X_e1 = 40.92 V\n",
+ "Case(d): Transformer voltage regulation at unity PF , VR = 1.27 percent\n",
+ "Case(e): Transformer voltage regulation at 0.7 PF lagging , VR = 2.15 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.20, Page number 515"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "kVA = 500.0 #kVA rating of the step-down transformer\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 208.0 #Secondary voltage(V)\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "P_sc = 8200.0 #Wattmeter reading in SC test(W)\n",
+ "I_sc = 217.4 #Short circuit current(A)\n",
+ "V_sc = 95.0 #Short circuit voltage(V)\n",
+ "P_oc = 1800.0 #Wattmeter reading in OC test(W)\n",
+ "I_oc = 85.0 #Open circuit current(A)\n",
+ "V_oc = 208.0 #Open circuit voltage(V)\n",
+ "\n",
+ "#Calculation\n",
+ "alpha = V_1/V_2 #Transformation ratio\n",
+ "#Case(a)\n",
+ "P = P_sc #Wattmeter reading(W)\n",
+ "I1 = I_sc #Short circuit current(A)\n",
+ "R_e1 = P/(I1)**2 #Equivalent resistance w.r.t HV side(ohm)\n",
+ "R_e2 = R_e1/alpha**2 #Equivalent resistance referred to LV side(ohm)\n",
+ "#Case(b)\n",
+ "r_2 = R_e2/2 #Resistance of low-voltage side(ohm)\n",
+ "#Case(c)\n",
+ "I_m = I_oc #Open circuit current(A)\n",
+ "P_cu = I_m**2*r_2 #Transformer copper loss of the LV side winding during OC-test(W)\n",
+ "#Case(d)\n",
+ "P_c = P_oc-P_cu #Transformer core loss(W)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Equivalent resistance to low voltage side , R_e2 = %.3f m\u03a9' %(1000*R_e2))\n",
+ "print('Case(b): Resistance of low voltage side , r_2 = %.2f m\u03a9' %(1000*r_2))\n",
+ "print('Case(c): Transformer copper loss of the LV side winding during OC-test , I_m^2*r_2 = %.2f W' %P_cu)\n",
+ "print('Case(d): Transformer core loss when rated voltage is applied , P_c = %.1f W' %P_c)\n",
+ "print('Case(e): Yes.The error is approximately 5/1800 = 0.278 percent, which is within error produced by the instruments used in test');\n",
+ "print(' We may assume that the core loss is %d W' %P_oc)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Equivalent resistance to low voltage side , R_e2 = 1.419 m\u03a9\n",
+ "Case(b): Resistance of low voltage side , r_2 = 0.71 m\u03a9\n",
+ "Case(c): Transformer copper loss of the LV side winding during OC-test , I_m^2*r_2 = 5.13 W\n",
+ "Case(d): Transformer core loss when rated voltage is applied , P_c = 1794.9 W\n",
+ "Case(e): Yes.The error is approximately 5/1800 = 0.278 percent, which is within error produced by the instruments used in test\n",
+ " We may assume that the core loss is 1800 W\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.21, Page number 516"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V_sc = 50.0 #Short circuit voltage(V)\n",
+ "V_1 = 2300.0 #Rated primary voltage(V)\n",
+ "P_c = 1.8 #Core losses(kW)\n",
+ "P_k = 1.8 #Fixed losses(kW)\n",
+ "P_cu_rated = 8.2 #Rated copper loss(kW)\n",
+ "kVA = 500.0 #Power rating(kVA)\n",
+ "PF = 1.0 #Power factor\n",
+ "P_o = kVA*PF #Full-load output at unity PF(kW)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "LF1 = 1.0/4 #Load fraction\n",
+ "LF2 = 1.0/2 #Load fraction\n",
+ "LF3 = 3.0/4 #Load fraction\n",
+ "LF4 = 5.0/4 #Load fraction\n",
+ "P_cu_fl = 8.2 #Equivalent copper loss at full-load slip(kW)\n",
+ "P_cu_LF1 = LF1**2*P_cu_fl #Equivalent copper loss at 1/4 rated load(kW)\n",
+ "P_cu_LF2 = LF2**2*P_cu_fl #Equivalent copper loss at 1/2 rated load(kW)\n",
+ "P_cu_LF3 = LF3**2*P_cu_fl #Equivalent copper loss at 3/4 rated load(kW)\n",
+ "P_cu_LF4 = LF4**2*P_cu_fl ; #Equivalent copper loss at 5/4 rated load(kW)\n",
+ "P_L_fl = P_c+P_cu_fl #Total losses at rated load(kW)\n",
+ "P_L_1 = P_c+P_cu_LF1 #Total losses at 1/4 rated load(kW)\n",
+ "P_L_2 = P_c+P_cu_LF2 #Total losses at 1/2 rated load(kW)\n",
+ "P_L_3 = P_c+P_cu_LF3 #Total losses at 3/4 rated load(kW)\n",
+ "P_L_4 = P_c+P_cu_LF4 #Total losses at 5/4 rated load(kW)\n",
+ "P_o_fl = P_o #Total output at rated load(kW)\n",
+ "P_o_1 = P_o*LF1 #Total output at 1/4 rated load(kW)\n",
+ "P_o_2 = P_o*LF2 #Total output at 1/2 rated load(kW)\n",
+ "P_o_3 = P_o*LF3 #Total output at 3/4 rated load(kW)\n",
+ "P_o_4 = P_o*LF4 #Total output at 5/4 rated load(kW)\n",
+ "P_in_fl = P_L_fl+P_o_fl #Total input at rated load(kW)\n",
+ "P_in_1 = P_L_1+P_o_1 #Total input at 1/4 rated load(kW)\n",
+ "P_in_2 = P_L_2+P_o_2 #Total input at 1/2 rated load(kW)\n",
+ "P_in_3 = P_L_3+P_o_3 #Total input at 3/4 rated load(kW)\n",
+ "P_in_4 = P_L_4+P_o_4 #Total input at 5/4 rated load(kW)\n",
+ "n_fl = (P_o_fl/P_in_fl)*100 #Efficiency at rated load(%)\n",
+ "n_1 = (P_o_1/P_in_1)*100 #Efficiency at 1/4 rated load(%)\n",
+ "n_2 = (P_o_2/P_in_2)*100 #Efficiency at 1/2 rated load(%)\n",
+ "n_3 = (P_o_3/P_in_3)*100 #Efficiency at 3/4 rated load(%)\n",
+ "n_4 = (P_o_4/P_in_4)*100 #Efficiency at 5/4 rated load(%)\n",
+ "#Case(b)\n",
+ "PF_b = 0.8 #PF lagging\n",
+ "Po_fl = P_o*PF_b #Total output at 1rated load(kW)\n",
+ "Po_1 = P_o*LF1*PF_b #Total output at 1/4 rated load(kW)\n",
+ "Po_2 = P_o*LF2*PF_b #Total output at 1/2 rated load(kW)\n",
+ "Po_3 = P_o*LF3*PF_b #Total output at 3/4 rated load(kW)\n",
+ "Po_4 = P_o*LF4*PF_b #Total output at 5/4 rated load(kW)\n",
+ "Pin_fl = P_L_fl+Po_fl #Total input at rated load(kW)\n",
+ "Pin_1 = P_L_1+Po_1 #Total input at 1/4 rated load(kW)\n",
+ "Pin_2 = P_L_2+Po_2 #Total input at 1/2 rated load(kW)\n",
+ "Pin_3 = P_L_3+Po_3 #Total input at 3/4 rated load(kW)\n",
+ "Pin_4 = P_L_4+Po_4 #Total input at 5/4 rated load(kW)\n",
+ "nfl = (Po_fl/Pin_fl)*100 #Efficiency at rated load(%)\n",
+ "n1 = (Po_1/Pin_1)*100 #Efficiency at 1/4 rated load(%)\n",
+ "n2 = (Po_2/Pin_2)*100 #Efficiency at 1/2 rated load(%)\n",
+ "n3 = (Po_3/Pin_3)*100 #Efficiency at 3/4 rated load(%)\n",
+ "n4 = (Po_4/Pin_4)*100 #Efficiency at 5/4 rated load(%)\n",
+ "#Case(c)\n",
+ "R_e2 = 1.417*10**-3 #Equivalent resistance referred to LV side(ohm)\n",
+ "Pc = 1800.0 #Core losses(W)\n",
+ "I_2 = (Pc/R_e2)**0.5 #Load current for maximum efficiency invariant of LF(A)\n",
+ "#Case(d)\n",
+ "V = 208.0 #Voltage rating(V)\n",
+ "I_2_rated = kVA*1000/V #Rated secondary current(A)\n",
+ "LF_max = I_2/I_2_rated #Load fraction for maximum efficiency\n",
+ "#Case(e)\n",
+ "cos_theta = 1.0 #Unity PF\n",
+ "V_2 = V #Secondary voltage(V)\n",
+ "n_max_e = (V_2*I_2*cos_theta)/((V_2*I_2*cos_theta)+(Pc+I_2**2*R_e2))*100 #Maximum efficiency(%)\n",
+ "#Case(f)\n",
+ "cos_theta2 = 0.8 #PF lagging\n",
+ "n_max_f = (V_2*I_2*cos_theta2)/((V_2*I_2*cos_theta2)+(Pc+I_2**2*R_e2))*100 #Maximum efficiency(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Tabulation at unity PF:')\n",
+ "print('__________________________________________________________________________________________________________')\n",
+ "print('L.F \\t Core loss \\t Copper loss \\tTotal loss \\t Total Output \\t Total Input \\t Efficiency')\n",
+ "print(' \\t (kW) \\t (kW) \\t P_L (kW) \\t P_o(kW) \\t P_L+P_o(kW) \\t P_o/P_in(percent)')\n",
+ "print('__________________________________________________________________________________________________________')\n",
+ "print('%.2f \\t %.1f \\t\\t %.3f \\t %.3f \\t\\t %.1f \\t %.2f \\t %.2f' %(LF1,P_c,P_cu_LF1,P_L_1,P_o_1,P_in_1,n_1))\n",
+ "print('%.2f \\t %.1f \\t\\t %.3f \\t %.2f \\t\\t %.1f \\t %.2f \\t %.2f' %(LF2,P_c,P_cu_LF2,P_L_2,P_o_2,P_in_2,n_2))\n",
+ "print('%.2f \\t %.1f \\t\\t %.3f \\t %.2f \\t\\t %.1f \\t %.2f \\t %.2f' %(LF3,P_c,P_cu_LF3,P_L_3,P_o_3,P_in_3,n_3))\n",
+ "print('1 \\t %.1f \\t\\t %.3f \\t %.2f \\t\\t %.1f \\t %.1f \\t %.2f' %(P_c,P_cu_fl,P_L_fl,P_o_fl,P_in_fl,n_fl))\n",
+ "print('%.2f \\t %.1f \\t\\t %.3f \\t %.1f \\t\\t %.1f \\t %.1f \\t %.2f' %(LF4,P_c,P_cu_LF4,P_L_4,P_o_4,P_in_4,n_4))\n",
+ "print('__________________________________________________________________________________________________________')\n",
+ "print('\\nCase(b): Tabulation at 0.8 PF lagging:')\n",
+ "print('__________________________________________________________________________________________________________')\n",
+ "print('L.F \\t Core loss \\t Copper loss \\tTotal loss \\t Total Output \\t Total Input \\t Efficiency')\n",
+ "print('\\t (kW) \\t (kW) \\t P_L (kW) \\t P_o(kW) \\t P_L+P_o(kW)\\t P_o/P_in(percent)')\n",
+ "print('__________________________________________________________________________________________________________')\n",
+ "print('%.2f \\t %.1f \\t\\t %.3f \\t %.3f \\t\\t %.1f \\t %.2f \\t %.2f' %(LF1,P_c,P_cu_LF1,P_L_1,Po_1,Pin_1,n1))\n",
+ "print('%.2f \\t %.1f \\t\\t %.2f \\t %.2f \\t\\t %.1f \\t %.2f \\t %.2f' %(LF2,P_c,P_cu_LF2,P_L_2,Po_2,Pin_2,n2))\n",
+ "print('%.2f \\t %.1f \\t\\t %.2f \\t %.2f \\t\\t %.1f \\t %.2f \\t %.2f' %(LF3,P_c,P_cu_LF3,P_L_3,Po_3,Pin_3,n3))\n",
+ "print('1 \\t %.1f \\t\\t %.1f \\t\\t %.2f \\t\\t %.1f \\t %.f \\t\\t %.2f' %(P_c,P_cu_fl,P_L_fl,Po_fl,Pin_fl,nfl))\n",
+ "print('%.2f \\t %.1f \\t\\t %.1f \\t %.1f \\t\\t %.1f \\t %.1f \\t %.2f' %(LF4,P_c,P_cu_LF4,P_L_4,Po_4,Pin_4,n4))\n",
+ "print('__________________________________________________________________________________________________________\\n')\n",
+ "print('Case(c): Load current at which maximum efficiency occurs regardless of load PF , I_2 = %.1f A' %I_2)\n",
+ "print('Case(d): Load fraction at which maximum efficiency occurs = %.3f (approximately half rated load)' %LF_max)\n",
+ "print('Case(e): Maximum efficiency at unity PF , \u03b7_max = %.2f percent' %n_max_e)\n",
+ "print('Case(f): Maximum efficiency at 0.8 PF lagging , \u03b7_max = %.2f percent' %n_max_f)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Tabulation at unity PF:\n",
+ "__________________________________________________________________________________________________________\n",
+ "L.F \t Core loss \t Copper loss \tTotal loss \t Total Output \t Total Input \t Efficiency\n",
+ " \t (kW) \t (kW) \t P_L (kW) \t P_o(kW) \t P_L+P_o(kW) \t P_o/P_in(percent)\n",
+ "__________________________________________________________________________________________________________\n",
+ "0.25 \t 1.8 \t\t 0.512 \t 2.312 \t\t 125.0 \t 127.31 \t 98.18\n",
+ "0.50 \t 1.8 \t\t 2.050 \t 3.85 \t\t 250.0 \t 253.85 \t 98.48\n",
+ "0.75 \t 1.8 \t\t 4.612 \t 6.41 \t\t 375.0 \t 381.41 \t 98.32\n",
+ "1 \t 1.8 \t\t 8.200 \t 10.00 \t\t 500.0 \t 510.0 \t 98.04\n",
+ "1.25 \t 1.8 \t\t 12.812 \t 14.6 \t\t 625.0 \t 639.6 \t 97.72\n",
+ "__________________________________________________________________________________________________________\n",
+ "\n",
+ "Case(b): Tabulation at 0.8 PF lagging:\n",
+ "__________________________________________________________________________________________________________\n",
+ "L.F \t Core loss \t Copper loss \tTotal loss \t Total Output \t Total Input \t Efficiency\n",
+ "\t (kW) \t (kW) \t P_L (kW) \t P_o(kW) \t P_L+P_o(kW)\t P_o/P_in(percent)\n",
+ "__________________________________________________________________________________________________________\n",
+ "0.25 \t 1.8 \t\t 0.512 \t 2.312 \t\t 100.0 \t 102.31 \t 97.74\n",
+ "0.50 \t 1.8 \t\t 2.05 \t 3.85 \t\t 200.0 \t 203.85 \t 98.11\n",
+ "0.75 \t 1.8 \t\t 4.61 \t 6.41 \t\t 300.0 \t 306.41 \t 97.91\n",
+ "1 \t 1.8 \t\t 8.2 \t\t 10.00 \t\t 400.0 \t 410 \t\t 97.56\n",
+ "1.25 \t 1.8 \t\t 12.8 \t 14.6 \t\t 500.0 \t 514.6 \t 97.16\n",
+ "__________________________________________________________________________________________________________\n",
+ "\n",
+ "Case(c): Load current at which maximum efficiency occurs regardless of load PF , I_2 = 1127.1 A\n",
+ "Case(d): Load fraction at which maximum efficiency occurs = 0.469 (approximately half rated load)\n",
+ "Case(e): Maximum efficiency at unity PF , \u03b7_max = 98.49 percent\n",
+ "Case(f): Maximum efficiency at 0.8 PF lagging , \u03b7_max = 98.12 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.22, Page number 520"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 230.0 #Secondary voltage(V)\n",
+ "P = 20.0 #Power rating of the transformer(kVA)\n",
+ "P_sc = 250.0 #Power measured(W)\n",
+ "V_sc = 50.0 #Short circuit voltage(V)\n",
+ "I_sc = 8.7 #Short circuit current(A)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "V_1b = V_1 #Base voltage(V)\n",
+ "Z_eq_pu = V_sc/V_1\n",
+ "beta = math.acos(P_sc/(V_sc*I_sc)) #Angle(radian)\n",
+ "beta_a = beta*180/math.pi #Angle(degree)\n",
+ "Zeq_pu = Z_eq_pu*cmath.exp(1j*beta) #Equivalent pu impedance\n",
+ "#Case(b)\n",
+ "PF_b = 1.0 #Unity PF\n",
+ "theta_b = math.acos(PF_b)*180/math.pi #PF angle(degree)\n",
+ "V_1_pu = 1.0*cmath.exp(1j*0*math.pi/180)+1.0*cmath.exp(1j*theta_b*math.pi/180)*Zeq_pu #pu voltage\n",
+ "V_1_pu_m = abs(V_1_pu) #Magnitude of V_1_pu\n",
+ "#Case(c)\n",
+ "theta = math.acos(0.7)*180/math.pi #Power factor angle(degrees)\n",
+ "V1_pu = 1.0*cmath.exp(1j*0*math.pi/180)+1.0*cmath.exp(1j*(-theta)*math.pi/180)*Zeq_pu #pu voltage\n",
+ "V1_pu_m = abs(V1_pu) #Magnitude of V1_pu\n",
+ "#Case(d)\n",
+ "VR_unity_PF = (V_1_pu_m-1.0)*100 #Voltage regulation at unity PF(%)\n",
+ "#Case(e)\n",
+ "VR_lag_PF = (V1_pu_m-1.0)*100 #Voltage regulation at 0.7 lagging PF(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Z_eq(pu)\u2220\u03b2 = %.5f\u2220%.f\u00b0 p.u' %(abs(Z_eq_pu),beta_a))\n",
+ "print('Case(b): V_1(pu) at unity PF , |V_1(pu)| = %.4f ' %V_1_pu_m)\n",
+ "print('Case(c): V_1(pu) at 0.7 PF lagging , |V_1(pu)| = %.5f ' %V1_pu_m)\n",
+ "print('Case(d): Voltage regulation at unity PF , VR = %.2f percent' %VR_unity_PF)\n",
+ "print('Case(e): Voltage regulation at 0.7 PF lagging , VR = %.2f percent' %VR_lag_PF)\n",
+ "print('Case(f): VRs as found by p.u method are essentially the same as those found in Exs.14-17 and 14-19 using the same data, for the same transformer but with much less effort')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Z_eq(pu)\u2220\u03b2 = 0.02174\u222055\u00b0 p.u\n",
+ "Case(b): V_1(pu) at unity PF , |V_1(pu)| = 1.0127 \n",
+ "Case(c): V_1(pu) at 0.7 PF lagging , |V_1(pu)| = 1.02146 \n",
+ "Case(d): Voltage regulation at unity PF , VR = 1.27 percent\n",
+ "Case(e): Voltage regulation at 0.7 PF lagging , VR = 2.15 percent\n",
+ "Case(f): VRs as found by p.u method are essentially the same as those found in Exs.14-17 and 14-19 using the same data, for the same transformer but with much less effort\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.23, Page number 521"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 230.0 #Secondary voltage(V)\n",
+ "S = 500.0 #Power rating of the transformer(kVA)\n",
+ "f= 60.0 #Frequency(Hz)\n",
+ "V_oc = 208.0 #Open circuit voltage(V)\n",
+ "I_oc = 85.0 #Open circuit current(A)\n",
+ "P_oc = 1800.0 #Power measured(W)\n",
+ "V_sc = 95.0 #Short circuit voltage(V)\n",
+ "I_sc = 217.4 #Short circuit current(A)\n",
+ "P_sc = 8200.0 #Power measured(W)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "S_b = S ; #Base voltage(kVA)\n",
+ "Psc = 8.2 #Power measured in kW during SC-test\n",
+ "P_Cu_pu = Psc/S_b #Per unit value of P_Cu at rated load\n",
+ "#Case(b)\n",
+ "Poc = 1.8 #Power measured during OC-test(kW)\n",
+ "P_CL_pu = Poc/S_b #Per unit value of P_CL at rated load\n",
+ "#Case(c)\n",
+ "PF = 1.0 #Unity Power factor\n",
+ "n_pu = PF/(PF+P_CL_pu+P_Cu_pu)*100 #Efficiency at rated load,unity PF(%)\n",
+ "#Case(d)\n",
+ "PF_d = 0.8 #Lagging Power factor\n",
+ "n_pu_d = PF_d/(PF_d+P_CL_pu+P_Cu_pu)*100 #Efficiency at rated load,0.8 lagging PF\n",
+ "#Case(e)\n",
+ "LF = (P_CL_pu/P_Cu_pu)**0.5 #Load fraction producing maximum efficiency\n",
+ "#Case(f)\n",
+ "n_pu_max = (LF*PF)/((LF*PF)+2*(P_CL_pu))*100 #Maximum efficiency at unity PF load\n",
+ "#Case(f)\n",
+ "n_pu_max_g = (LF*PF_d)/((LF*PF_d)+2*(P_CL_pu))*100 #Maximum efficiency at 0.8 lagging PF load\n",
+ "\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Per unit copper loss at rated load , P_Cu(pu) = %.4f p.u = R_eq(pu)' %P_Cu_pu)\n",
+ "print('Case(b): Per unit core loss at rated load , P_CL(pu) = %.4f p.u' %P_CL_pu)\n",
+ "print('Case(c): Efficiency at rated load, unity PF , \u03b7_pu = %.2f percent' %n_pu)\n",
+ "print('Case(d): Efficiency at rated load, 0.8 PF lagging , \u03b7_pu = %.2f percent' %n_pu_d)\n",
+ "print('Case(e): Load fraction producing maximum efficiency , L.F = %.3f ' %LF)\n",
+ "print('Case(f): Maximum efficiency at unity PF load , \u03b7_pu = %.2f percent' %n_pu_max)\n",
+ "print('Case(g): Maximum efficiency at 0.8 PF lagging , \u03b7_pu = %.2f percent' %n_pu_max_g)\n",
+ "print('Case(h): All efficiency values are identical to those computed in solution to Ex.14-21')\n",
+ "print('Case(i): Per-unit method is much simpler and less subject to error than conventional method')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Per unit copper loss at rated load , P_Cu(pu) = 0.0164 p.u = R_eq(pu)\n",
+ "Case(b): Per unit core loss at rated load , P_CL(pu) = 0.0036 p.u\n",
+ "Case(c): Efficiency at rated load, unity PF , \u03b7_pu = 98.04 percent\n",
+ "Case(d): Efficiency at rated load, 0.8 PF lagging , \u03b7_pu = 97.56 percent\n",
+ "Case(e): Load fraction producing maximum efficiency , L.F = 0.469 \n",
+ "Case(f): Maximum efficiency at unity PF load , \u03b7_pu = 98.49 percent\n",
+ "Case(g): Maximum efficiency at 0.8 PF lagging , \u03b7_pu = 98.12 percent\n",
+ "Case(h): All efficiency values are identical to those computed in solution to Ex.14-21\n",
+ "Case(i): Per-unit method is much simpler and less subject to error than conventional method\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.24, Page number 521"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 230.0 #Secondary voltage(V)\n",
+ "S = 500.0 #Power rating of the transformer(kVA)\n",
+ "f= 60.0 #Frequency(Hz)\n",
+ "V_oc = 208.0 #Open circuit voltage(V)\n",
+ "I_oc = 85.0 #Open circuit current(A)\n",
+ "P_oc = 1800.0 #Power measured(W)\n",
+ "V_sc = 95.0 #Short circuit voltage(V)\n",
+ "I_sc = 217.4 #Short circuit current(A)\n",
+ "P_sc = 8200.0 #Power measured(W)\n",
+ "\n",
+ "#Calculation\n",
+ "S_b = S ; #Base voltage(kVA)\n",
+ "Psc = 8.2 #Power measured in kW during SC-test\n",
+ "P_Cu_pu = Psc/S_b #Per unit value of P_Cu at rated load\n",
+ "Poc = 1.8 #Power measured during OC-test(kW)\n",
+ "P_CL_pu = Poc/S_b #Per unit value of P_CL at rated load\n",
+ "#Case(a)\n",
+ "LF1 = 3.0/4 #Load fraction of rated load \n",
+ "PF1 = 1.0 #Unity Power factor\n",
+ "n_pu_LF1 = (LF1*PF1)/((LF1*PF1)+P_CL_pu+(LF1)**2*P_Cu_pu)*100 #Efficiency at rated load,unity PF(%)\n",
+ "#Case(b)\n",
+ "LF2 = 1.0/4 #Load fraction of rated load\n",
+ "PF2 = 0.8 #Lagging PF\n",
+ "n_pu_LF2 = (LF2*PF2)/((LF2*PF2)+P_CL_pu+(LF2)**2*P_Cu_pu)*100 #Efficiency at 1/4 rated load,0.8 lagging PF(%)\n",
+ "#Case(c)\n",
+ "LF3 = 5.0/4 #Load fraction of rated load\n",
+ "PF3 = 0.8 #Leading PF\n",
+ "n_pu_LF3 = (LF3*PF3)/((LF3*PF3)+P_CL_pu+(LF3)**2*P_Cu_pu)*100 #Efficiency at r1/4 rated load,0.8 leading PF(%)\n",
+ "\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): p.u efficiency at 3/4 load unity PF , \u03b7_pu = %.2f percent' %n_pu_LF1)\n",
+ "print('Case(b): p.u efficiency at 1/4 load 0.8 PF lagging , \u03b7_pu = %.2f percent' %n_pu_LF2)\n",
+ "print('Case(c): p.u efficiency at 5/4 load 0.8 PF leading , \u03b7_pu = %.2f percent' %n_pu_LF3)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): p.u efficiency at 3/4 load unity PF , \u03b7_pu = 98.32 percent\n",
+ "Case(b): p.u efficiency at 1/4 load 0.8 PF lagging , \u03b7_pu = 97.74 percent\n",
+ "Case(c): p.u efficiency at 5/4 load 0.8 PF leading , \u03b7_pu = 97.16 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.25, Page number 522"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "kVA_1 = 500.0 #Power rating of the transformer 1(kVA)\n",
+ "R_1_pu = 0.01 #Per-unit value of resistance of the transformer 1\n",
+ "X_1_pu = 0.05 #Per-unit value of reactance of the transformer 1\n",
+ "Z_1_pu = complex(R_1_pu,X_1_pu) #Per-unit value of impedance of the transformer 1\n",
+ "PF = 0.8 #Lagging PF\n",
+ "V_2 = 400.0 #Secondary voltage(V)\n",
+ "S_load = 750.0 #Increased system load(kVA)\n",
+ "kVA_2 = 250.0 #Power rating of the transformer 2(kVA)\n",
+ "R_pu_2 = 0.015 #Per-unit value of resistance of the transformer 2\n",
+ "X_pu_2 = 0.04 #Per-unit value of reactance of the transformer 2\n",
+ "\n",
+ "#Calculation\n",
+ "Z_pu_1 = complex(R_pu_2,X_pu_2) #New transformer p.u. impedance\n",
+ "#Case(a)\n",
+ "V_b1 = 400.0 #Base voltage(V)\n",
+ "V_b2 = 400.0 #Base voltage(V)\n",
+ "Z_pu_2 = (kVA_1/kVA_2)*(V_b1/V_b2)**2*(Z_pu_1) #New transformer p.u impedance\n",
+ "Z_2_pu = Z_pu_2 #New transformer p.u impedance\n",
+ "#Case(b)\n",
+ "cos_theta = PF #Power factor\n",
+ "sin_theta = (1-(cos_theta)**2)**0.5\n",
+ "S_t_conjugate = (kVA_1+kVA_2)*complex(cos_theta,sin_theta) #kVA of total load\n",
+ "#Case(c)\n",
+ "S_2_conjugate = S_t_conjugate*(Z_1_pu/(Z_1_pu+Z_2_pu)) #Portion of load carried by the smaller transformer(kVA)\n",
+ "S_2_conjugate_m = abs(S_2_conjugate) #Magnitude of S_2_conjugate(kVA)\n",
+ "S_2_conjugate_a = cmath.phase(S_2_conjugate)*180/math.pi #Phase angle of S_2_conjugate(degree)\n",
+ "#Case(d)\n",
+ "S_1_conjugate = S_t_conjugate*(Z_2_pu/(Z_1_pu+Z_2_pu)) #Portion of load carried by the original transformer(kVA)\n",
+ "S_1_conjugate_m = abs(S_1_conjugate) #Magnitude of S_1_conjugate(kVA)\n",
+ "S_1_conjugate_a = cmath.phase(S_1_conjugate)*180/math.pi #Phase angle of S_1_conjugate(degree)\n",
+ "#Case(e)\n",
+ "S_1 = S_1_conjugate_m\n",
+ "S_b1 = kVA_1 #Base power of trancsformer 1(kVA)\n",
+ "LF1 = (S_1/S_b1)*100 #Load factor of the original transformer(%)\n",
+ "#Case(f)\n",
+ "S_2 = S_2_conjugate_m\n",
+ "S_b2 = kVA_2 #Base power of trancsformer 1(kVA)\n",
+ "LF2 = (S_2/S_b2)*100 #Load factor of the new transformer(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): New transformer p.u impedance , Z_p.u.2 = (%.2f+j%.2f) p.u' %(Z_pu_2.real,Z_pu_2.imag))\n",
+ "print('Case(b): kVA of total load , S*_t = (%.f+j%.f) kVA ' %(S_t_conjugate.real,S_t_conjugate.imag))\n",
+ "print('Case(c): Portion of load now carried by the smaller transformer , S*_2 = (%.2f+j%.2f) kVA = %.1f\u2220%.1f\u00b0 kVA' %(S_2_conjugate.real,S_2_conjugate.imag,S_2_conjugate_m,S_2_conjugate_a))\n",
+ "print('Case(d): Portion of load now carried by the original transformer , S*_1 = (%.2f+j%.1f) kVA = %.1f\u2220%.1f\u00b0 kVA' %(S_1_conjugate.real,S_1_conjugate.imag,S_1_conjugate_m,S_1_conjugate_a))\n",
+ "print('Case(e): Load factor of the original transformer , L.F_1 = %.1f percent' %LF1)\n",
+ "print('Case(f): Load factor of the new transformer , L.F_w = %.1f percent' %LF2)\n",
+ "print('Case(g): Yes. Reduce no-load voltage of the new transformer to some value below that of its present value so that its share of the load is reduced')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): New transformer p.u impedance , Z_p.u.2 = (0.03+j0.08) p.u\n",
+ "Case(b): kVA of total load , S*_t = (600+j450) kVA \n",
+ "Case(c): Portion of load now carried by the smaller transformer , S*_2 = (206.76+j190.54) kVA = 281.2\u222042.7\u00b0 kVA\n",
+ "Case(d): Portion of load now carried by the original transformer , S*_1 = (393.24+j259.5) kVA = 471.1\u222033.4\u00b0 kVA\n",
+ "Case(e): Load factor of the original transformer , L.F_1 = 94.2 percent\n",
+ "Case(f): Load factor of the new transformer , L.F_w = 112.5 percent\n",
+ "Case(g): Yes. Reduce no-load voltage of the new transformer to some value below that of its present value so that its share of the load is reduced\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.26, Page number 523"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "kVA_1 = 500.0 #Power rating of the transformer 1(kVA)\n",
+ "R_1_pu = 0.01 #Per-unit value of resistance of the transformer 1\n",
+ "X_1_pu = 0.05 #Per-unit value of reactance of the transformer 1\n",
+ "Z_1_pu = complex(R_1_pu,X_1_pu) #Per-unit value of impedance of the transformer 1\n",
+ "PF = 0.8 #Lagging PF\n",
+ "V = 400.0 #Secondary voltage(V)\n",
+ "S_load = 750.0 #Increased system load(kVA)\n",
+ "kVA_2 = 250.0 #Power rating of the transformer 2(kVA)\n",
+ "R_pu_2 = 0.015 #Per-unit value of resistance of the transformer 2\n",
+ "X_pu_2 = 0.04 #Per-unit value of reactance of the transformer 2\n",
+ "\n",
+ "#Calculation\n",
+ "Z_pu_1 = complex(R_1_pu,X_1_pu) #New transformer p.u. impedance\n",
+ "Z_pu1 = complex(R_pu_2,X_pu_2) #New transformer p.u. impedance\n",
+ "#Case(a)\n",
+ "V_b = V #Base voltage(V)\n",
+ "#Case(b)\n",
+ "S_b = kVA_1 #Base power(kVA)\n",
+ "I_b = S_b/V_b*1000 #Base current(A)\n",
+ "#Case(c)\n",
+ "Zb = V_b/I_b #Base impedance(ohm). Method 1\n",
+ "Z_b = V**2/(S_b*1000) #Base impedance(ohm). Method 2\n",
+ "#Case(d)\n",
+ "Z_1 = Z_b*Z_pu_1*1000 #Actual impedance of larger transformer(m\u03a9)\n",
+ "Z_1_m = abs(Z_1) #Magnitude of Z_1(\u03a9)\n",
+ "Z_1_a = cmath.phase(Z_1)*180/math.pi #Phase angle of Z_1(degree)\n",
+ "#Case(e)\n",
+ "V_b1 = V_b #Base voltage(V)\n",
+ "V_b2 = V_b #Base voltage(V)\n",
+ "Z_pu_2 = (kVA_1/kVA_2)*(V_b1/V_b2)**2*(Z_pu1) #New transformer p.u impedance\n",
+ "Z_2_pu = Z_pu_2\n",
+ "Z_2 = Z_b*Z_2_pu*1000 #Actual impedance of smaller transformer(m\u03a9)\n",
+ "Z_2_m = abs(Z_2) #Magnitude of Z_2(\u03a9)\n",
+ "Z_2_a = cmath.phase(Z_2)*180/math.pi #Phase angle of Z_2(degree)\n",
+ "#Case(f)\n",
+ "cos_theta = 0.8 #Lagging power factor\n",
+ "sin_theta = (1-(cos_theta)**2)**0.5\n",
+ "S_T = (kVA_1+kVA_2)*complex(cos_theta,-sin_theta) #kVA of total load\n",
+ "I_T = S_T*1000/V_b #Total current(A)\n",
+ "I_1 = I_T*(Z_2/(Z_1+Z_2)) #Actual current delivered by larger transformer(A)\n",
+ "I_1_m = abs(I_1) #Magnitude of I_1(A)\n",
+ "I_1_a = cmath.phase(I_1)*180/math.pi #Phase angle of I_1(degree)\n",
+ "#Case(g)\n",
+ "I_2 = I_T*(Z_1/(Z_1+Z_2)) #Actual current delivered by smaller transformer(A)\n",
+ "I_2_m = abs(I_2) #Magnitude of I_2(A)\n",
+ "I_2_a = cmath.phase(I_2)*180/math.pi #Phase angle of I_2(degree)\n",
+ "#Case(h)\n",
+ "Z1 = Z_1/1000 #Actual impedance of larger transformer(\u03a9)\n",
+ "E_1 = I_1*Z1+V_b #No-load voltage of larger transformer(V)\n",
+ "E_1_m = abs(E_1) #Magnitude of E_1(V)\n",
+ "E_1_a = cmath.phase(E_1)*180/math.pi #Phase angle of E_1(degree)\n",
+ "#Case(i)\n",
+ "Z2 = Z_2/1000 #Actual impedance of smaller transformer(\u03a9)\n",
+ "E_2 = I_2*Z2+V_b #No-load voltage of smaller transformer(V)\n",
+ "E_2_m = abs(E_2) #Magnitude of E_2(V)\n",
+ "E_2_a = cmath.phase(E_2)*180/math.pi #Phase angle of E_2(degree)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Base voltage , V_b = %.f V' %V_b)\n",
+ "print('Case(b): Base current , I_b = %.2f kA' %(I_b/1000))\n",
+ "print('Case(c): Base impedance , Z_b = %.2f \u03a9 (Method 1)' %Zb)\n",
+ "print(' Base impedance , Z_b = %.2f \u03a9 (Method 2)' %Z_b)\n",
+ "print('Case(d): Actual impedance of larger transformer , Z_1 = %.2f\u2220%.1f\u00b0 m\u03a9' %(Z_1_m,Z_1_a))\n",
+ "print('Case(e): Actual impedance of smaller transformer , Z_2 = %.2f\u2220%.2f\u00b0 m\u03a9' %(Z_2_m,Z_2_a))\n",
+ "print('Case(f): Actual current delivered by larger transformer , I_1 = %.f\u2220%.2f\u00b0 A' %(I_1_m,I_1_a))\n",
+ "print('Case(g): Actual current delivered by smaller transformer , I_2 = %.1f\u2220%.1f\u00b0 A' %(I_2_m,I_2_a))\n",
+ "print('Case(h): No-load voltage of larger transformer , E_1 = %.2f\u2220%.2f\u00b0 V' %(E_1_m,E_1_a))\n",
+ "print('Case(i): No-load voltage of smaller transformer , E_2 = %.2f\u2220%.2f\u00b0 V' %(E_2_m,E_2_a))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Base voltage , V_b = 400 V\n",
+ "Case(b): Base current , I_b = 1.25 kA\n",
+ "Case(c): Base impedance , Z_b = 0.32 \u03a9 (Method 1)\n",
+ " Base impedance , Z_b = 0.32 \u03a9 (Method 2)\n",
+ "Case(d): Actual impedance of larger transformer , Z_1 = 16.32\u222078.7\u00b0 m\u03a9\n",
+ "Case(e): Actual impedance of smaller transformer , Z_2 = 27.34\u222069.44\u00b0 m\u03a9\n",
+ "Case(f): Actual current delivered by larger transformer , I_1 = 1178\u2220-40.32\u00b0 A\n",
+ "Case(g): Actual current delivered by smaller transformer , I_2 = 702.9\u2220-31.1\u00b0 A\n",
+ "Case(h): No-load voltage of larger transformer , E_1 = 415.24\u22201.65\u00b0 V\n",
+ "Case(i): No-load voltage of smaller transformer , E_2 = 415.24\u22201.65\u00b0 V\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.27, Page number 525"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "P_L = 14400.0 #Load output power(W)\n",
+ "V_L = 120.0 #Load voltage(V)\n",
+ "V_b1 = 120.0 #Base voltage at point 1(V)\n",
+ "V_b2 = 600.0 #Base voltage at point 2(V)\n",
+ "V_b3 = 120.0 #Base voltage at point 3(V)\n",
+ "S_b3 = 14.4 #Base power(kVA)\n",
+ "X_2 = 0.25 #Reactance(p.u)\n",
+ "X_1 = 0.2 #Reactance(p.u)\n",
+ "I_L = 120.0 #Load current(A)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "R_L = P_L/(V_L**2) #Resistance of the load(ohm)\n",
+ "#Case(b)\n",
+ "Z_bL = (V_b3**2)/(S_b3*1000) #Base impedance(ohm)\n",
+ "#Case(c)\n",
+ "Z_L_pu = R_L/Z_bL #Per unit load impedance \n",
+ "#Case(d)\n",
+ "Z_2_pu = complex(0,X_2) #Per unit impedance of T2\n",
+ "#Case(e)\n",
+ "Z_1_pu = complex(0,X_1) #Per unit impedance of T1\n",
+ "#Case(g)\n",
+ "I_bL = (S_b3*1000)/V_b3 #Base current in load(A)\n",
+ "#Case(h)\n",
+ "I_L_pu = I_L/I_bL #Per unit load current\n",
+ "#Case(i)\n",
+ "V_R_pu = I_L_pu*Z_L_pu #Per unit voltage across load \n",
+ "#Case(j)\n",
+ "I_S_pu = I_L_pu #Per unit current of source\n",
+ "Z_T_pu = Z_L_pu+Z_1_pu+Z_2_pu #Total p.u impedance\n",
+ "V_S_pu = I_S_pu*Z_T_pu #Per unit voltage of source\n",
+ "V_S_pu_m = abs(V_S_pu) #Magnitude of V_S_pu\n",
+ "V_S_pu_a = cmath.phase(V_S_pu)*180/math.pi #Phase angle of V_S_pu(degrees)\n",
+ "#Case(k)\n",
+ "V_S = V_S_pu*V_b1 #Actual voltage across source(V)\n",
+ "V_S_m = abs(V_S) #Magnitude of V_S(V)\n",
+ "V_S_a = cmath.phase(V_S)*180/math.pi #Phase angle of V_S(degrees)\n",
+ "#Case(l)\n",
+ "I_x_pu = I_L_pu #p.u current at point x\n",
+ "Z_x_pu = Z_L_pu+Z_2_pu #p.u impedance at point x \n",
+ "V_x_pu = I_x_pu*Z_x_pu #p.u voltage at point x\n",
+ "#Case(m)\n",
+ "V_x = V_x_pu*V_b2 #Actual voltage at point x(V)\n",
+ "V_x_m = abs(V_x) #Magnitude of V_x(V)\n",
+ "V_x_a = cmath.phase(V_x)*180/math.pi #Phase angle of V_x(degrees)\n",
+ "\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Resistance of the load , R_L = %.f \u03a9' %R_L)\n",
+ "print('Case(b): Base impedance of the load , Z_bL = %.f \u03a9' %Z_bL)\n",
+ "print('Case(c): Per-unit load impedance , Z_L(pu) = (%.f+j%.f) p.u' %(Z_L_pu.real,Z_L_pu.imag))\n",
+ "print('Case(d): Per-unit impedance of transformer T2 , Z_2(pu) = j%.2f p.u' %Z_2_pu.imag)\n",
+ "print('Case(e): Per-unit impedance of transformer T1 , Z_1(pu) = j%.1f p.u' %Z_2_pu.imag)\n",
+ "print('Case(f): See Fig.14-23b in textbook page no-526')\n",
+ "print('Case(g): Base current in the load , I_bL = %.f A (resistive)' %I_bL)\n",
+ "print('Case(h): Per-unit load current , I_L_pu = (%.f+j%.f) p.u' %(I_L_pu.real,I_L_pu.imag))\n",
+ "print('Case(i): Per-unit voltage across load , V_R_pu = (%.f+j%.f) p.u' %(V_R_pu.real,V_R_pu.imag))\n",
+ "print('Case(j): Per-unit voltage of source , V_S_pu = %.3f\u2220%.2f\u00b0 pu' %(V_S_pu_m,V_S_pu_a))\n",
+ "print('Case(k): Actual voltage across source , V_S = %.1f\u2220%.2f\u00b0 pu' %(V_S_m,V_S_a))\n",
+ "print('Case(l): Per-unit voltage at point x in the second transmission loop , V_x(pu) = (%.f+j%.2f) p.u' %(V_x_pu.real,V_x_pu.imag))\n",
+ "print('Case(m): Voltage at point x , V_x = %.1f\u2220%.f\u00b0 V' %(V_x_m,V_x_a))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Resistance of the load , R_L = 1 \u03a9\n",
+ "Case(b): Base impedance of the load , Z_bL = 1 \u03a9\n",
+ "Case(c): Per-unit load impedance , Z_L(pu) = (1+j0) p.u\n",
+ "Case(d): Per-unit impedance of transformer T2 , Z_2(pu) = j0.25 p.u\n",
+ "Case(e): Per-unit impedance of transformer T1 , Z_1(pu) = j0.2 p.u\n",
+ "Case(f): See Fig.14-23b in textbook page no-526\n",
+ "Case(g): Base current in the load , I_bL = 120 A (resistive)\n",
+ "Case(h): Per-unit load current , I_L_pu = (1+j0) p.u\n",
+ "Case(i): Per-unit voltage across load , V_R_pu = (1+j0) p.u\n",
+ "Case(j): Per-unit voltage of source , V_S_pu = 1.097\u222024.23\u00b0 pu\n",
+ "Case(k): Actual voltage across source , V_S = 131.6\u222024.23\u00b0 pu\n",
+ "Case(l): Per-unit voltage at point x in the second transmission loop , V_x(pu) = (1+j0.25) p.u\n",
+ "Case(m): Voltage at point x , V_x = 618.5\u222014\u00b0 V\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.28, Page number 526"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "V_1 = 11.0 #Tr.1 voltage(kV)\n",
+ "V_b1 = 11.0 #Base Tr.1 voltage(kV)\n",
+ "S_1 = 50.0 #KVA rating of power for Tr.1\n",
+ "S_2 = 100.0 #KVA rating of power for Tr.2\n",
+ "Z_1_pu = complex(0,0.1) #Per unit impedance of Tr.1\n",
+ "Z_2_pu = complex(0,0.1) #Per unit impedance of Tr.2\n",
+ "V_b2 = 55.0 #Base Tr.2 voltage(kV)\n",
+ "S_b = 100.0 #Base power(kVA)\n",
+ "PF = 0.8 #Power factor of the load\n",
+ "Z_line = complex(0,200) #Line impedance(ohm)\n",
+ "V_L = 10.0 #Load voltage(kV)\n",
+ "V_Lb3 = 11.0 #Base line voltage at point 3(V)\n",
+ "V_b3 = 11.0 #Line voltage at point 3(V)\n",
+ "P_L = 50.0 #Power rating of each transformer(kW)\n",
+ "cos_theta_L = 0.8 #Lagging PF of load\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "Z_T1 = Z_1_pu*(V_1/V_b1)**2*(S_2/S_1) #p.u impedance of T1\n",
+ "#Case(b)\n",
+ "Z_T2 = Z_2_pu*(V_1/V_b3)**2*(S_2/S_1) #p.u impedance of T2\n",
+ "#Case(c)\n",
+ "V_b = V_b2 #Base voltage(V)\n",
+ "Z_b_line = (V_b**2)/S_b*1000 #Base line impedance(ohm)\n",
+ "Z_line_pu = Z_line/Z_b_line #p.u impedance of the transmission line\n",
+ "#Case(d)\n",
+ "V_L_pu = V_L/V_Lb3 #p.u voltage across load\n",
+ "#Case(f)\n",
+ "I_bL = S_b/V_b3 #Base current in load(A)\n",
+ "#Case(g)\n",
+ "VL = V_b3 #Load voltage(kV)\n",
+ "I_L = P_L/(VL*cos_theta_L) #Load current(A)\n",
+ "I_L_pu = I_L/I_bL #p.u load current\n",
+ "theta = math.acos(cos_theta_L) #PF angle(radian)\n",
+ "theta_a = theta*180/math.pi #PF angle(degree)\n",
+ "I_Lpu = I_L_pu*complex(math.cos(theta),-math.sin(theta)) #p.u current in complex form\n",
+ "#Case(h)\n",
+ "Z_series_pu = Z_T1+Z_line_pu+Z_T2 #p.u series impedance of the transmission line\n",
+ "V_S_pu = I_Lpu*Z_series_pu+V_L_pu #p.u source voltage\n",
+ "V_S_pu_m = abs(V_S_pu) #Magnitude of V_S_pu\n",
+ "V_S_pu_a = cmath.phase(V_S_pu)*180/math.pi #Phase angle of V_S_pu(degrees)\n",
+ "#Case(i)\n",
+ "V_S = V_S_pu*V_b1 #Actual value of source voltage(kV)\n",
+ "V_S_m = abs(V_S) #Magnitude of V_S_pu(kV)\n",
+ "V_S_a = cmath.phase(V_S)*180/math.pi #Phase angle of V_S(degrees)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Per-unit impedance of transformer T1 , Z_T1 = j%.1f p.u' %Z_T1.imag)\n",
+ "print('Case(b): Per-unit impedance of transformer T2 , Z_T2 = j%.1f p.u' %Z_T2.imag)\n",
+ "print('Case(c): Per-unit impedance of transmission line , Z(line)_pu = j%.4f p.u' %Z_line_pu.imag)\n",
+ "print('Case(d): Per-unit voltage across load , V_L_pu = (%.3f+j%.f) p.u' %(V_L_pu.real,V_L_pu.imag))\n",
+ "print('Case(e): See Fig.14-24b in textbook Page no-527')\n",
+ "print('Case(f): Base current in load , I_bL = %.3f A' %I_bL)\n",
+ "print('Case(g): Per-unit load current , I_L_pu = (%.1f%.3fj) p.u' %(I_Lpu.real,I_Lpu.imag))\n",
+ "print('Case(h): Per-unit source voltage , V_S_pu = %.3f\u2220%.2f\u00b0 pu' %(V_S_pu_m,V_S_pu_a))\n",
+ "print('Case(i): Actual value of source voltage , V_S = %.1f\u2220%.2f\u00b0 kV' %(V_S_m,V_S_a))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Per-unit impedance of transformer T1 , Z_T1 = j0.2 p.u\n",
+ "Case(b): Per-unit impedance of transformer T2 , Z_T2 = j0.2 p.u\n",
+ "Case(c): Per-unit impedance of transmission line , Z(line)_pu = j0.0066 p.u\n",
+ "Case(d): Per-unit voltage across load , V_L_pu = (0.909+j0) p.u\n",
+ "Case(e): See Fig.14-24b in textbook Page no-527\n",
+ "Case(f): Base current in load , I_bL = 9.091 A\n",
+ "Case(g): Per-unit load current , I_L_pu = (0.5-0.375j) p.u\n",
+ "Case(h): Per-unit source voltage , V_S_pu = 1.081\u222010.84\u00b0 pu\n",
+ "Case(i): Actual value of source voltage , V_S = 11.9\u222010.84\u00b0 kV\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.29, Page number 528"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "Z_pu_1 = 1j*0.1 #p.u impedance \n",
+ "MVA_2 = 80.0 #MVA rating os system 2\n",
+ "MVA_1 = 100.0 #MVA rating of T1 and T2\n",
+ "V_2 = 30.0 #Voltage(kV)\n",
+ "V_1 = 32.0 #Voltage(kV)\n",
+ "Z_pu_2 = 1j*0.15 #p.u impedance \n",
+ "V_b1 = 100.0 #Base voltage of T1(kV)\n",
+ "Z_line = 1j*60 #Line impedance(ohm)\n",
+ "MVA_M1 = 20.0 #MVA rating of motor load 1\n",
+ "Z_pu_M1 = 1j*0.15 #p.u impedance of motor load M1\n",
+ "MVA_M2 = 35.0 #MVA rating of motor load 2\n",
+ "Z_pu_M2 = 1j*0.25 #p.u impedance of motor load M2\n",
+ "MVA_M3 = 25.0 #MVA rating of motor load 3\n",
+ "Z_pu_M3 = 1j*0.2 #p.u impedance of motor load M3\n",
+ "V_M = 28.0 #Voltage across motor loads M1,M2,M3(kV)\n",
+ "\n",
+ "#Calculations\n",
+ "Z_1_pu = Z_pu_1*(MVA_2/MVA_1)*(V_2/V_1)**2 #p.u imepedance of T1\n",
+ "Z_2_pu = Z_pu_2*(MVA_2/MVA_1)*(V_2/V_1)**2 #p.u imepedance of T2\n",
+ "V_b_line = V_b1*(V_1/V_2) #ase voltage of the long-transmission line(kV)\n",
+ "MVA_b = 80.0 #Base MVA rating\n",
+ "V_b = V_b_line\n",
+ "Z_line_pu = Z_line*(MVA_b/(V_b_line)**2) #p.u impedance of the transmission line\n",
+ "Z_M1_pu = Z_pu_M1*(MVA_2/MVA_M1)*(V_M/V_1)**2 #p.u impedance of motor load M1\n",
+ "Z_M2_pu = Z_pu_M2*(MVA_2/MVA_M2)*(V_M/V_1)**2 #p.u impedance of motor load M2\n",
+ "Z_M3_pu = Z_pu_M3*(MVA_2/MVA_M3)*(V_M/V_1)**2 #p.u impedance of motor load M3\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Per-unit impedance of T1 , Z_1(pu) = j%.4f p.u' %Z_1_pu.imag)\n",
+ "print('Case(b): Per-unit impedance of T2 , Z_2(pu) = j%.4f p.u' %Z_2_pu.imag)\n",
+ "print('Case(c): Base voltage of the long-transmission line between T1 and T2 , V_b(line) = %.1f kV' %V_b_line)\n",
+ "print('Case(d): Per-unit impedance of the transmission line , Z(line)_pu = j%.4f p.u' %Z_line_pu.imag)\n",
+ "print('Case(e): Per-unit impedance of motor load M1 , Z_M1(pu) = j%.4f p.u' %Z_M1_pu.imag)\n",
+ "print('Case(f): Per-unit impedance of motor load M2 , Z_M2(pu) = j%.4f p.u' %Z_M2_pu.imag)\n",
+ "print('Case(g): Per-unit impedance of motor load M3 , Z_M3(pu) = j%.2f p.u' %Z_M3_pu.imag)\n",
+ "print('Case(h): See Fig.14-25b in textbook page no-529')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Per-unit impedance of T1 , Z_1(pu) = j0.0703 p.u\n",
+ "Case(b): Per-unit impedance of T2 , Z_2(pu) = j0.1055 p.u\n",
+ "Case(c): Base voltage of the long-transmission line between T1 and T2 , V_b(line) = 106.7 kV\n",
+ "Case(d): Per-unit impedance of the transmission line , Z(line)_pu = j0.4219 p.u\n",
+ "Case(e): Per-unit impedance of motor load M1 , Z_M1(pu) = j0.4594 p.u\n",
+ "Case(f): Per-unit impedance of motor load M2 , Z_M2(pu) = j0.4375 p.u\n",
+ "Case(g): Per-unit impedance of motor load M3 , Z_M3(pu) = j0.49 p.u\n",
+ "Case(h): See Fig.14-25b in textbook page no-529\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.30, Page number 533"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V_pa = 1000.0 #Phase voltage(V)\n",
+ "I_1a = 1.0 #Line current in primary(A)\n",
+ "V_2a = 100.0 #Voltage across secondary(V)\n",
+ "Ic_a = 10.0 #Current in lower half of auto-transformer(A)\n",
+ "V_s = 100.0 #Voltage in secondary winding(V)\n",
+ "I_2b = 10.0 #Current in secondary(A)\n",
+ "V_1b = 1000.0 #Voltage across primary(V)\n",
+ "Ic_b = 1.0 #Current in lower half of auto-transformer(A)\n",
+ "\n",
+ "#Calculation\n",
+ "S_T1 = (V_pa*I_1a+V_2a*I_1a)/1000 #Total kVA transfer in step-down mode\n",
+ "S_T2 = (V_s*I_2b+V_1b*I_2b)/1000 #Total kVA transfer in step-up mode\n",
+ "S_x_former_c = V_pa*I_1a/1000 #kVA rating of th autotransformer in Fig.14-27a\n",
+ "V_1 = V_pa\n",
+ "S_x_former_d = V_1*Ic_b/1000 #kVA rating of th autotransformer in Fig.14-26b\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Total kVA transfer in step-down mode , S_T = %.1f kVA transferred' %S_T1)\n",
+ "print('Case(b): Total kVA transfer in step-up mode , S_T = %.1f kVA transferred' %S_T2)\n",
+ "print('Case(c): kVA rating of the autotransformer in Fig.14-27a , S_x-former = %.f kVA' %S_x_former_c)\n",
+ "print('Case(d): kVA rating of the autotransformer in Fig.14-26b , S_x-former = %.f kVA' %S_x_former_d)\n",
+ "print('Case(e): Both transformers have the same kVA rating of 1 kVA since the same autotransformer is used in both parts.')\n",
+ "print(' Both transformers transform a total of 1 KVA. But the step-down transformer in part(a) conducts only 0.1 kVA')\n",
+ "print(' while the step-up transformer in the part(b) conducts 10 kVA from the primary to the secondary')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Total kVA transfer in step-down mode , S_T = 1.1 kVA transferred\n",
+ "Case(b): Total kVA transfer in step-up mode , S_T = 11.0 kVA transferred\n",
+ "Case(c): kVA rating of the autotransformer in Fig.14-27a , S_x-former = 1 kVA\n",
+ "Case(d): kVA rating of the autotransformer in Fig.14-26b , S_x-former = 1 kVA\n",
+ "Case(e): Both transformers have the same kVA rating of 1 kVA since the same autotransformer is used in both parts.\n",
+ " Both transformers transform a total of 1 KVA. But the step-down transformer in part(a) conducts only 0.1 kVA\n",
+ " while the step-up transformer in the part(b) conducts 10 kVA from the primary to the secondary\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.31, Page number 535"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "S = 500.0 #kVA rating of the distribution transformer\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 208.0 #Secondary voltage(V)\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "P_sc = 8200.0 #Wattmeter reading in SC test(W)\n",
+ "I_sc = 217.4 #Short circuit current(A)\n",
+ "V_sc = 95.0 #Short circuit voltage(V)\n",
+ "P_oc = 1800.0 #Wattmeter reading in OC test(W)\n",
+ "I_oc = 85.0 #Open circuit current(A)\n",
+ "V_oc = 208.0 #Open circuit voltage(V)\n",
+ "LF1 = 0.2 #Load fraction \n",
+ "LF2 = 0.4 #Load fraction \n",
+ "LF3 = 0.8 #Load fraction \n",
+ "LF4 = 1.25 #Load fraction \n",
+ "PF1 = 0.7 #Power factor\n",
+ "PF2 = 0.8 #Power factor\n",
+ "PF3 = 0.9 #Power factor\n",
+ "PF_fl = 1.0 #Power factor\n",
+ "PF4 = 0.85 #Power factor\n",
+ "t1 = 4.0 #Period of operation(hours)\n",
+ "t2 = 4.0 #Period of operation(hours)\n",
+ "t3 = 6.0 #Period of operation(hours)\n",
+ "t_fl = 6.0 #Period of operation(hours)\n",
+ "t4 = 2.0 #Period of operation(hours)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "t = 24.0 #Hours in a day\n",
+ "P_c = P_oc #Wattmeter reading(W). OC test\n",
+ "W_c = (P_c*t)/1000 #Core loss over 24 hour period(kWh)\n",
+ "#Case(b)\n",
+ "Psc = P_sc/1000 #Wattmeter reading(W). SC test\n",
+ "P_loss_1 = (LF1**2)*Psc #Power loss for 20% Load(kW)\n",
+ "P_loss_2 = (LF2**2)*Psc #Power loss for 40% Load(kW)\n",
+ "P_loss_3 = (LF3**2)*Psc #Power loss for 80% Load(kW)\n",
+ "P_loss_fl = Psc #Power loss for 100% Load(kW)\n",
+ "P_loss_4 = (LF4**2)*Psc #Power loss for 125% Load(kW)\n",
+ "energy_loss1 = P_loss_1*t1 #Enegry loss for 20% Load(kWh)\n",
+ "energy_loss2 = P_loss_2*t2 #Enegry loss for 40% Load(kWh)\n",
+ "energy_loss3 = P_loss_3*t3 #Enegry loss for 80% Load(kWh)\n",
+ "energy_loss_fl = P_loss_fl*t_fl #Enegry loss for 100% Load(kWh)\n",
+ "energy_loss4 = P_loss_4*t4 #Enegry loss for 125% Load(kWh)\n",
+ "W_loss_total = energy_loss1+energy_loss2+energy_loss3+energy_loss_fl+energy_loss4 #Total energy loss(kWh)\n",
+ "#Case(c)\n",
+ "P_1 = LF1*S*PF1 #Power output for 20% load(kW)\n",
+ "P_2 = LF2*S*PF2 #Power output for 40% load(kW)\n",
+ "P_3 = LF3*S*PF3 #Power output for 80% load(kW)\n",
+ "P_fl = S*PF_fl #Power output for 100% load(kW)\n",
+ "P_4 = LF4*S*PF4 #Power output for 125% load(kW)\n",
+ "Energy_1 = P_1*t1 #Energy delivered for 20% load(kWh)\n",
+ "Energy_2 = P_2*t2 #Energy delivered for 40% load(kWh)\n",
+ "Energy_3 = P_3*t3 #Energy delivered for 80% load(kWh)\n",
+ "Energy_fl = P_fl*t_fl #Energy delivered for 100% load(kWh)\n",
+ "Energy_4 = P_4*t4 #Energy delivered for 125% load(kWh)\n",
+ "W_out_total = Energy_1+Energy_2+Energy_3+Energy_fl+Energy_4 #Total energy delivered in 24hrs(kwh)\n",
+ "#Case(d)\n",
+ "n = W_out_total/(W_out_total+W_c+W_loss_total)*100 #All-day efficiency(%)\n",
+ "\n",
+ "#Result\n",
+ "print('case(a): Core loss over the 24 hour period , W_c = P_c*t = %.1f kWh' %W_c)\n",
+ "print('Case(b): Total energy loss over the 24 hour period = %.2f kWh' %W_loss_total)\n",
+ "print('Case(c): Total energy output over the 24 hour period = %.f kWh' %W_out_total)\n",
+ "print('Case(d): All-day efficiency = %.1f percent' %n)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "case(a): Core loss over the 24 hour period , W_c = P_c*t = 43.2 kWh\n",
+ "Case(b): Total energy loss over the 24 hour period = 112.87 kWh\n",
+ "Case(c): Total energy output over the 24 hour period = 7142 kWh\n",
+ "Case(d): All-day efficiency = 97.9 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.32, Page number 540"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "S_1 = 10.0 #VA rating of small transformer\n",
+ "V = 115.0 #Voltage rating of transformer(V)\n",
+ "V_2_1 = 6.3 #Voltage rating of one part of secondary winding(V)\n",
+ "V_2_2 = 5.0 #Voltage rating of other part of secondary winding(V)\n",
+ "Z_2_1 = 0.2 #Impedance of one part of secondary winding(ohm)\n",
+ "Z_2_2 = 0.15 #Impedance of other part of secondary winding(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "V_2 = V_2_1+V_2_2 #Voltage across secondary winding(V)\n",
+ "I_2 = S_1/V_2 #Rated secondary current when the LV secondaries are connected in series-aiding(A)\n",
+ "#Case(b)\n",
+ "I_c = (V_2_1-V_2_2)/(Z_2_1+Z_2_2) #Circulating current when LV windings are paralled(A)\n",
+ "percent_overload = (I_c/I_2)*100 #Percent overload produced\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Rated secondary current when the low-voltage secondaries are connected series-aiding , I_2 = %.3f A' %I_2)\n",
+ "print('Case(b): Circulating current when LV windings are paralled , I_c = %.2f A' %I_c)\n",
+ "print(' Percent overload produced = %.f percent' %percent_overload)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Rated secondary current when the low-voltage secondaries are connected series-aiding , I_2 = 0.885 A\n",
+ "Case(b): Circulating current when LV windings are paralled , I_c = 3.71 A\n",
+ " Percent overload produced = 420 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.33, Page number 541"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "S = 20.0 #kVA rating of transformer\n",
+ "N_1 = 230.0 #Number of primary turns\n",
+ "N_2 = 20.0 #Number of secondary turns\n",
+ "V_1 = 230.0 #Primary voltage(V)\n",
+ "V_2 = 20.0 #Secondary voltage(V)\n",
+ "V_sc = 4.5 #Short circuit voltage(V)\n",
+ "I_sc = 87.0 #Short circuit current(A)\n",
+ "P_sc = 250.0 #Power measured(W)\n",
+ "\n",
+ "#Calculation\n",
+ "V_h = V_sc #Short circuit voltage on HV side(V)\n",
+ "I_h = I_sc #Short circuit current on HV side(A)\n",
+ "Z_eh = V_h/I_h #Equivalent impedance reffered to the high side when coils are series connected(ohm)\n",
+ "Z_el = Z_eh*(N_2/N_1)**2 #Equivalent impedance reffered to the low side when coils are series connected(ohm)\n",
+ "I_2_rated = (S*1000)/V_2 #Rated secondary current when coils are series connected(A)\n",
+ "I_2_sc = S/Z_el #Secondary current when coils in Fig.14-31a are short-circuited with rated voltage applied to HV side(A)\n",
+ "percent_overload = (I_2_sc/I_2_rated)*100 #Percent overload\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Equivalent impedance reffered to the high side when coils are series-connected , Z_eh = %.4f ohm' %Z_eh)\n",
+ "print('Case(b): Equivalent impedance reffered to the low side when coils are series connected , Z_el = %.2e ohm' %Z_el)\n",
+ "print('Case(c): Rated secondary current when coils are series connected , I_2(rated) = %.e A' %I_2_rated)\n",
+ "print('Case(d): Secondary current when coils in Fig.14-31a are short-circuited with rated voltage applied to HV side , I_2(sc) = %.1e A' %I_2_sc)\n",
+ "print(' Percent overload produced = %.f percent' %percent_overload)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Equivalent impedance reffered to the high side when coils are series-connected , Z_eh = 0.0517 ohm\n",
+ "Case(b): Equivalent impedance reffered to the low side when coils are series connected , Z_el = 3.91e-04 ohm\n",
+ "Case(c): Rated secondary current when coils are series connected , I_2(rated) = 1e+03 A\n",
+ "Case(d): Secondary current when coils in Fig.14-31a are short-circuited with rated voltage applied to HV side , I_2(sc) = 5.1e+04 A\n",
+ " Percent overload produced = 5114 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.34, Page number 548"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "I_L = 100.0 #Load current(A)\n",
+ "cos_theta = 0.7 #Power factor lagging\n",
+ "S = 60.0 #kVA rating of transformer\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 230.0 #Secondary voltage(V)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "V_L = 230.0 #Voltage across load(V)\n",
+ "P_T = (3**0.5*V_L*I_L*cos_theta)/1000 #Power consumed by the plant(kW)\n",
+ "kVA_T = P_T/cos_theta #Apparent power(kVA)\n",
+ "#Case(b)\n",
+ "kVA = S #kVA rating of transformer\n",
+ "V_p = V_2 #Phase voltage(V). delta-connection on load side\n",
+ "I_P2_rated = (kVA*1000)/(3*V_p) #Rated secondary phase current(A)\n",
+ "I_L2_rated = 3**0.5*I_P2_rated #Rated secondary line current(A)\n",
+ "#Case(c)\n",
+ "percent_load = I_L/I_L2_rated*100 #Percent load on each transformer \n",
+ "#Case(d)\n",
+ "V_L_d = 2300.0\n",
+ "I_P1 = (kVA_T*1000)/(3**0.5*V_L_d) #Primary phase current(A)\n",
+ "I_L1 = I_P1 #Primary line current(A). Y-connection\n",
+ "#Case(e)\n",
+ "kVA_transformer = kVA/3 #kVA rating of each transformer\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Power consumed by the plant , P_T = %.1f kW' %P_T)\n",
+ "print(' Apparent power , kVA_T = %.1f kVA' %kVA_T)\n",
+ "print('Case(b): Rated secondary phase current of transformer bank , I_P2(rated) = %.f A' %I_P2_rated)\n",
+ "print(' Rated secondary line current of transformer bank , I_L2(rated) = %.1f A' %I_L2_rated)\n",
+ "print('Case(c): Percent load on each transformer = %.1f percent' %percent_load)\n",
+ "print('Case(d): Primary phase current drawn by each transformer , I_P1 = %.f A' %I_P1)\n",
+ "print(' Primary line current drawn by each transformer , I_L1 = %.f A' %I_L1)\n",
+ "print('Case(e): kVA rating of each transformer = %.f kVA' %kVA_transformer)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Power consumed by the plant , P_T = 27.9 kW\n",
+ " Apparent power , kVA_T = 39.8 kVA\n",
+ "Case(b): Rated secondary phase current of transformer bank , I_P2(rated) = 87 A\n",
+ " Rated secondary line current of transformer bank , I_L2(rated) = 150.6 A\n",
+ "Case(c): Percent load on each transformer = 66.4 percent\n",
+ "Case(d): Primary phase current drawn by each transformer , I_P1 = 10 A\n",
+ " Primary line current drawn by each transformer , I_L1 = 10 A\n",
+ "Case(e): kVA rating of each transformer = 20 kVA\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.35, Page number 548"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "I_L = 100.0 #Load current(A)\n",
+ "cos_theta = 0.7 #Power factor lagging\n",
+ "S = 60.0 #kVA rating of transformer\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 230.0 #Secondary voltage(V)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(a)\n",
+ "V_L = 230.0 #Voltage across load(V)\n",
+ "P_T = (3**0.5*V_L*I_L*cos_theta)/1000 #Power consumed by the plant(kW)\n",
+ "kVA_T = P_T/cos_theta #Apparent power(kVA)\n",
+ "#Case(b)\n",
+ "kVA = S #kVA rating of transformer\n",
+ "V_p = V_2 #Phase voltage(V)\n",
+ "I_P2_rated = (kVA*1000)/(3*V_p) #Rated secondary phase current(A)\n",
+ "I_L2_rated = 3**0.5*I_P2_rated #Rated secondary line current(A)\n",
+ "#Case(c)\n",
+ "percent_load = I_L/I_L2_rated*100 #Percent load on each transformer \n",
+ "#Case(d)\n",
+ "V_L_d = 2300.0\n",
+ "I_P1 = (kVA_T*1000)/(3**0.5*V_L_d) #Primary phase current(A)\n",
+ "I_L1 = 3**0.5*I_P1 #Primary line current(A)\n",
+ "#Case(e)\n",
+ "kVA_transformer = kVA/3 #kVA rating of each transformer\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Power consumed by the plant , P_T = %.1f kW' %P_T)\n",
+ "print(' Apparent power , kVA_T = %.1f kVA' %kVA_T)\n",
+ "print('Case(b): Rated secondary phase current of transformer bank , I_P2(rated) = %.f A' %I_P2_rated)\n",
+ "print(' Rated secondary line current of transformer bank , I_L2(rated) = %.1f A' %I_L2_rated)\n",
+ "print('Case(c): Percent load on each transformer = %.1f percent' %percent_load)\n",
+ "print('Case(d): Primary phase current drawn by each transformer , I_P1 = %.f A' %I_P1)\n",
+ "print(' Primary line current drawn by each transformer , I_L1 = %.1f A' %I_L1)\n",
+ "print(' Primary line current drawn by a \u0394-\u0394 bank is \u221a3 times the line current drawn by a Y-\u0394 bank')\n",
+ "print('Case(e): kVA rating of each transformer = %.f kVA' %kVA_transformer)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Power consumed by the plant , P_T = 27.9 kW\n",
+ " Apparent power , kVA_T = 39.8 kVA\n",
+ "Case(b): Rated secondary phase current of transformer bank , I_P2(rated) = 87 A\n",
+ " Rated secondary line current of transformer bank , I_L2(rated) = 150.6 A\n",
+ "Case(c): Percent load on each transformer = 66.4 percent\n",
+ "Case(d): Primary phase current drawn by each transformer , I_P1 = 10 A\n",
+ " Primary line current drawn by each transformer , I_L1 = 17.3 A\n",
+ " Primary line current drawn by a \u0394-\u0394 bank is \u221a3 times the line current drawn by a Y-\u0394 bank\n",
+ "Case(e): kVA rating of each transformer = 20 kVA\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.36, Page number 554"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Variable declaration\n",
+ "V_L = 33.0 #Line voltage(kV)\n",
+ "f = 60.0 #Frequency(Hz)\n",
+ "PF1 = 1.0 #Unity power factor for I_AB\n",
+ "PF2 = 0.7 #Lagging power factor for I_BC\n",
+ "PF3 = 0.9 #Leading power factor for I_CA\n",
+ "IAB = 10.0 #Magnitude of I_AB(kA)\n",
+ "IBC = 15.0 #Magnitude of I_BC(kA)\n",
+ "ICA = 12.0 #Magnitude of I_CA(kA)\n",
+ "\n",
+ "#Calculation\n",
+ "V_AB = V_L*cmath.exp(1j*0*math.pi/180) #Line voltage taken as reference voltage(kV)\n",
+ "V_AB_a = cmath.phase(V_AB)*180/math.pi #Voltage angle(degree)\n",
+ "V_BC = V_L*cmath.exp(1j*-120*math.pi/180) #Line voltage(kV)\n",
+ "V_BC_a = cmath.phase(V_BC)*180/math.pi #Voltage angle(degree)\n",
+ "V_CA = V_L*cmath.exp(1j*120*math.pi/180) #Line voltage(kV)\n",
+ "V_CA_a = cmath.phase(V_CA)*180/math.pi #Voltage angle(degree)\n",
+ "theta_1 = math.acos(PF1)*180/math.pi #PF1 angle(degree)\n",
+ "theta_2 = math.acos(PF2)*180/math.pi #PF2 angle(degree)\n",
+ "theta_3 = math.acos(PF3)*180/math.pi #PF3 angle(degree)\n",
+ "I_AB = IAB*cmath.exp(1j*(theta_1)*math.pi/180) #Current(kA)\n",
+ "I_BC = IBC*cmath.exp(1j*(V_BC_a-theta_2)*math.pi/180) #Current(kA)\n",
+ "I_CA = ICA*cmath.exp(1j*(V_CA_a+theta_3)*math.pi/180) #Current(kA)\n",
+ "#Case(a)\n",
+ "I_AC = -I_CA\n",
+ "I_A = I_AB+I_AC #Phase current(kA)\n",
+ "I_A_m = abs(I_A) #Magnitude of I_A(kA)\n",
+ "I_A_a = cmath.phase(I_A)*180/math.pi #Phase angle of I_A(degrees)\n",
+ "#Case(b)\n",
+ "I_BA = -I_AB\n",
+ "I_B = I_BC+I_BA #Phase current(kA)\n",
+ "I_B_m = abs(I_B) #Magnitude of I_B(kA)\n",
+ "I_B_a = cmath.phase(I_B)*180/math.pi #Phase angle of I_B(degrees)\n",
+ "#Case(c)\n",
+ "I_CB = -I_BC\n",
+ "I_C = I_CA+I_CB #Phase current(kA)\n",
+ "I_C_m = abs(I_C) #Magnitude of I_C(kA)\n",
+ "I_C_a = cmath.phase(I_C)*180/math.pi #Phase angle of I_C(degrees)\n",
+ "#Case(d)\n",
+ "phasor_sum = I_A+I_B+I_C #Phasor sum of line currents\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Current in line A , I_A = %.2f\u2220%.2f\u00b0 kA' %(I_A_m,I_A_a))\n",
+ "print('Case(b): Current in line B , I_B = %.2f\u2220%.2f\u00b0 kA' %(I_B_m,I_B_a))\n",
+ "print('Case(c): Current in line C , I_C = %.2f\u2220%.2f\u00b0 kA' %(I_C_m,I_C_a))\n",
+ "print('Case(d): Phasor sum of line currents , \u03a3I_L = (%.f+j%.f) ' %(phasor_sum.real,phasor_sum.imag))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Current in line A , I_A = 21.04\u2220-18.68\u00b0 kA\n",
+ "Case(b): Current in line B , I_B = 24.81\u2220-171.34\u00b0 kA\n",
+ "Case(c): Current in line C , I_C = 11.44\u222066.30\u00b0 kA\n",
+ "Case(d): Phasor sum of line currents , \u03a3I_L = (-0+j0) \n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.37, Page number 556"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "kVA_1 = 20.0 #kVA rating of transformer 1\n",
+ "kVA_2 = 20.0 #kVA rating of transformer 2\n",
+ "kVA_3 = 20.0 #kVA rating of transformer 3\n",
+ "V_1 = 2300.0 #Primary voltage(V)\n",
+ "V_2 = 230.0 #Secondary voltage(V)\n",
+ "kVA = 40.0 #kVA supplied by the bank\n",
+ "PF = 0.7 #Lagging power factor at which bank supplies kVA\n",
+ "\n",
+ "#Calculation\n",
+ "kVA_transformer = kVA/3**0.5 #kVA load carried by each transformer\n",
+ "percent_ratedload_Tr = kVA_transformer/kVA_1*100 #Percent load carried by each transformer\n",
+ "kVA_V_V = 3**0.5*kVA_1 #Total kVA rating of the transformer bank in V-V\n",
+ "ratio_banks = kVA_V_V/(kVA_1+kVA_2+kVA_3)*100 #Ratio of V-V bank to \u0394-\u0394 bank transformer ratings\n",
+ "kVA_Tr = kVA/3 \n",
+ "percent_increase_load = kVA_transformer/kVA_Tr*100 #Percent increase in load on each transformer when one transformer is removed\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): kVA load carried by each transformer = %.1f kVA/transformer' %kVA_transformer)\n",
+ "print('Case(b): Percent rated load carried by each transformer = %.1f percent' %percent_ratedload_Tr)\n",
+ "print('Case(c): Total kVA rating of the transformer bank in V-V = %.2f kVA' %kVA_V_V)\n",
+ "print('Case(d): Ratio of V-V bank to \u0394-\u0394 bank transformer ratings = %.1f percent' %ratio_banks)\n",
+ "print('Case(e): Percent increase in load on each transformer when one transformer is removed = %.1f percent' %percent_increase_load)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): kVA load carried by each transformer = 23.1 kVA/transformer\n",
+ "Case(b): Percent rated load carried by each transformer = 115.5 percent\n",
+ "Case(c): Total kVA rating of the transformer bank in V-V = 34.64 kVA\n",
+ "Case(d): Ratio of V-V bank to \u0394-\u0394 bank transformer ratings = 57.7 percent\n",
+ "Case(e): Percent increase in load on each transformer when one transformer is removed = 173.2 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.38, Page number 562"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "V = 440.0 #Rated voltage of SCIM(V)\n",
+ "hp = 100.0 #Rated power of SCIM(hp)\n",
+ "PF = 0.8 #Power factor\n",
+ "V_1 = 155.0 #Primary voltage of transformer(V)\n",
+ "V_2 = 110.0 #Secondary voltage of transformer(V)\n",
+ "V_a = 110.0 #Armature voltage(V)\n",
+ "V_L = 440.0 #Load voltage(V)\n",
+ "n = 0.98 #Efficiency of the transformer\n",
+ "\n",
+ "#Calculation\n",
+ "I_L = 124*1.25 #Motor line current(A). Appendix A-3\n",
+ "alpha = V_a/V_L #Transformation ratio\n",
+ "I_a = (3**0.5/2)*(I_L/(alpha*n)) #Current in the primary of the scott transformers(A)\n",
+ "kVA = (V_a*I_a)/((3**0.5/2)*1000) #kVA rating of the main and teaser transformers\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Motor line current , I_L = %.f A' %I_L)\n",
+ "print('Case(b): Transformation ratio , \u03b1 = N_1/N_2 = V_a/V_L = %.2f ' %alpha)\n",
+ "print('Case(c): Current in the primary of the scott transformers , I_a = %.f A' %I_a)\n",
+ "print('Case(d): kVA rating of the main and teaser transformers , kVA = %.1f kVA' %kVA)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Motor line current , I_L = 155 A\n",
+ "Case(b): Transformation ratio , \u03b1 = N_1/N_2 = V_a/V_L = 0.25 \n",
+ "Case(c): Current in the primary of the scott transformers , I_a = 548 A\n",
+ "Case(d): kVA rating of the main and teaser transformers , kVA = 69.6 kVA\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.39, Page number 570"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Variable declaration\n",
+ "I_L = 1.0 #Load current(kA)\n",
+ "V_m = 750.0 #Peak voltage(kV)\n",
+ "\n",
+ "#Calculation\n",
+ "V_L = (V_m)/2**0.5 #Maximum allowable rms voltagethat may be applied to the lines using ac(kV)\n",
+ "S_T_ac = 3**0.5*V_L*I_L #Total 3-phase apparent power(MVA)\n",
+ "I_rms = I_L #rms value of load current(kA)\n",
+ "I_dc =I_rms*2**0.5 #Maximum allowable current that can be delivered by dc transmission(kA)\n",
+ "V_dc = V_m #dc voltage(kV)\n",
+ "S_T_dc = V_dc*I_dc #Total dc apparent power delivered by two lines(MVA)\n",
+ "S_ac_line = S_T_ac/3 #Power per ac line\n",
+ "S_dc_line = S_T_dc/2 #Power per dc line\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a): Maximum allowable rms voltage that may be applied to the lines using ac , V_L = %.1f kV' %V_L)\n",
+ "print('Case(b): Total 3-phase ac apparent power delivered by three lines , S_T = %.1f MVA' %S_T_ac)\n",
+ "print('Case(c): Maximum allowable current that can be delivered by dc transmission , I_dc = %.3f kA' %I_dc)\n",
+ "print('Case(d): Total dc apparent power delivered by two lines , S_T = %.1f MVA' %S_T_dc)\n",
+ "print('Case(e): Power per ac line , S/ac line = %.1f MVA/line' %S_ac_line)\n",
+ "print('Case(f): Power per dc line , S/dc line = %.1f MVA/line' %S_dc_line)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a): Maximum allowable rms voltage that may be applied to the lines using ac , V_L = 530.3 kV\n",
+ "Case(b): Total 3-phase ac apparent power delivered by three lines , S_T = 918.6 MVA\n",
+ "Case(c): Maximum allowable current that can be delivered by dc transmission , I_dc = 1.414 kA\n",
+ "Case(d): Total dc apparent power delivered by two lines , S_T = 1060.7 MVA\n",
+ "Case(e): Power per ac line , S/ac line = 306.2 MVA/line\n",
+ "Case(f): Power per dc line , S/dc line = 530.3 MVA/line\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file |