diff options
| author | Jovina Dsouza | 2014-06-18 12:43:07 +0530 |
|---|---|---|
| committer | Jovina Dsouza | 2014-06-18 12:43:07 +0530 |
| commit | 206d0358703aa05d5d7315900fe1d054c2817ddc (patch) | |
| tree | f2403e29f3aded0caf7a2434ea50dd507f6545e2 /Electrical_Power_Systems:_Concepts,_Theory_and_Practice | |
| parent | c6f0d6aeb95beaf41e4b679e78bb42c4ffe45a40 (diff) | |
| download | Python-Textbook-Companions-206d0358703aa05d5d7315900fe1d054c2817ddc.tar.gz Python-Textbook-Companions-206d0358703aa05d5d7315900fe1d054c2817ddc.tar.bz2 Python-Textbook-Companions-206d0358703aa05d5d7315900fe1d054c2817ddc.zip | |
adding book
Diffstat (limited to 'Electrical_Power_Systems:_Concepts,_Theory_and_Practice')
23 files changed, 5181 insertions, 0 deletions
diff --git a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_10_2.ipynb b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_10_2.ipynb new file mode 100644 index 00000000..2a9ddf10 --- /dev/null +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_10_2.ipynb @@ -0,0 +1,185 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "CHAPTER 10: POWER SYSTEM ECONOMICS"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 10.1, Page number 339-340"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find annual electricity charge\n",
+ "\n",
+ "#Variable declaration\n",
+ "max_dm_kW = 150.0 #Maximum demand(kW)\n",
+ "pf = 0.85 #Average power factor\n",
+ "rate = 90.0 #Cost of maximum demand(Rs/kVA)\n",
+ "E_rate = 0.3 #Cost of energy consumed(Rs)\n",
+ "lf = 0.65 #Annual load factor \n",
+ "\n",
+ "#Calculation\n",
+ "max_dm_kVA = max_dm_kW/pf #Maximum demand(kVA)\n",
+ "annual_chg_kVA = rate*max_dm_kVA #Annual fixed charges based on max demand(Rs)\n",
+ "E_kWh = lf*365*24*max_dm_kW #Energy consumed per annum(kWh)\n",
+ "annual_E_chg = E_kWh*E_rate #Annual energy charges(Rs)\n",
+ "annual_elect_charge = annual_chg_kVA + annual_E_chg #Annual electricity charge to be paid(Rs)\n",
+ "\n",
+ "#Result\n",
+ "print('Annual electricity charges to be paid by consumer = Rs %.2f' %annual_elect_charge)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Annual electricity charges to be paid by consumer = Rs 272112.35\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 10.2, Page number 340-341"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Obtain two part tariff\n",
+ "\n",
+ "#Variable declaration\n",
+ "P = 75.0 #Power(kW)\n",
+ "cost_plant = 3000.0 #Cost of plant(Rs/kW)\n",
+ "cost_td = 30.0*10**5 #Cost of transmission & distribution(Rs)\n",
+ "interest = 0.15 #Interest,insurance charges(/annum)\n",
+ "depreciation = 0.05 #Depreciation(/annum)\n",
+ "cost_fix_mt = 4.0*10**5 #Fixed maintainance(Rs)\n",
+ "cost_var_mt = 6.0*10**5 #Variable maintainance(Rs)\n",
+ "cost_fuel = 10.0*10**6 #Fuel cost(Rs/annum)\n",
+ "cost_opr = 3.0*10**6 #Operation cost(Rs/annum)\n",
+ "max_demand = 70.0 #Maximum demand(MW)\n",
+ "df = 1.6 #Diversity factor b/w consumers\n",
+ "lf = 0.6 #Annual load factor\n",
+ "dividend = 10**6 #Dividend to shareholders(Rs/annum)\n",
+ "per_L = 0.10 #Total energy loss(% of generated energy)\n",
+ "\n",
+ "#Calculation\n",
+ "cost = cost_plant*P*1000 #Cost of plant(Rs)\n",
+ "#Fixed cost\n",
+ "per_value = interest+depreciation #Total interest & depreciation(/annum)\n",
+ "cost_fix_ann = (cost+cost_opr)*per_value+cost_fix_mt+dividend #Total fixed cost(Rs)\n",
+ "#Variable cost\n",
+ "cost_var_ann = cost_fuel+cost_opr+cost_var_mt #Total running cost(Rs)\n",
+ "E_gen_ann = max_demand*1000*24*365*lf #Energy generated per annum(kWh)\n",
+ "E_loss = per_L*E_gen_ann #Energy losses(kWh)\n",
+ "E_sold = E_gen_ann - E_loss #Energy sold(kWh)\n",
+ "sum_max_demand = df*max_demand*1000 #Sum of maximum demand of consumers(kW)\n",
+ "charge_max_demand = cost_fix_ann/sum_max_demand #Charge to consumers per kW of max demand per year(Rs)\n",
+ "charge_energy = cost_var_ann/E_sold*100 #Charge for energy(paise per kWh)\n",
+ "\n",
+ "#Result\n",
+ "print('Two-part tariff is :')\n",
+ "print('Rs %.2f per kW of maximum demand per year + %.1f paise per kWh consumed' %(charge_max_demand,charge_energy))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Two-part tariff is :\n",
+ "Rs 419.64 per kW of maximum demand per year + 4.1 paise per kWh consumed\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 10.3, Page number 349-350"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find optimal scheduling & total cost\n",
+ "\n",
+ "#Variable declaration\n",
+ "P_D = 500.0 #Total load(MW)\n",
+ "b_1 = 15.0 #Beta value of controllable thermal plant C1\n",
+ "g_1 = 0.012 #Gamma value of controllable thermal plant C1\n",
+ "b_2 = 16.0 #Beta value of controllable thermal plant C2\n",
+ "g_2 = 0.018 #Gamma value of controllable thermal plant C2\n",
+ "b_3 = 19.0 #Beta value of controllable thermal plant C3\n",
+ "g_3 = 0.020 #Gamma value of controllable thermal plant C3\n",
+ "\n",
+ "#Calculation\n",
+ "l = (P_D+((b_1/(2*g_1))+(b_2/(2*g_2))+(b_3/(2*g_3))))/((1/(2*g_1))+(1/(2*g_2))+(1/(2*g_3))) #Lambda value which is a Lagrange multiplier\n",
+ "P_G1 = (l - b_1)/(2*g_1) #(MW)\n",
+ "P_G2 = (l - b_2)/(2*g_2) #(MW)\n",
+ "P_G3 = (l - b_3)/(2*g_3) #(MW)\n",
+ "C1 = 1500.0 + b_1*P_G1 + g_1*P_G1**2 #Fuel cost of plant C1(Rs/hr)\n",
+ "C2 = 2000.0 + b_2*P_G2 + g_2*P_G2**2 #Fuel cost of plant C2(Rs/hr)\n",
+ "C3 = 1000.0 + b_3*P_G3 + g_3*P_G3**2 #Fuel cost of plant C3(Rs/hr)\n",
+ "C = C1 + C2 + C3 #Total fuel cost(Rs/hr)\n",
+ "\n",
+ "#Result\n",
+ "print('Value of \u03bb from equation(10.14) = %.3f' %l)\n",
+ "print('Optimal scheduling of thermal plant C1 = %.2f MW' %P_G1)\n",
+ "print('Optimal scheduling of thermal plant C2 = %.2f MW' %P_G2)\n",
+ "print('Optimal scheduling of thermal plant C3 = %.2f MW' %P_G3)\n",
+ "print('Total cost , C = Rs %.2f/hr' %C)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Value of \u03bb from equation(10.14) = 21.647\n",
+ "Optimal scheduling of thermal plant C1 = 276.96 MW\n",
+ "Optimal scheduling of thermal plant C2 = 156.86 MW\n",
+ "Optimal scheduling of thermal plant C3 = 66.18 MW\n",
+ "Total cost , C = Rs 13872.55/hr\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file diff --git a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_12_2.ipynb b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_12_2.ipynb new file mode 100644 index 00000000..825a19ae --- /dev/null +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_12_2.ipynb @@ -0,0 +1,274 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "CHAPTER 12: OVER-VOLTAGE TRANSIENTS IN POWER SYSTEMS AND PROTECTION"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 12.1, Page number 408"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find reflected & refracted voltage & current\n",
+ "\n",
+ "#Variable declaration\n",
+ "V_i = 100.0 #Incident voltage(kV)\n",
+ "Z_1 = 400.0 #Surge impedance(ohm)\n",
+ "Z_2 = 350.0 #Surge impedance(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "beta = 2*Z_2/(Z_1+Z_2) #Refraction coeffeicient of voltage\n",
+ "alpha = (Z_2-Z_1)/(Z_1+Z_2) #Reflection coeffeicient of voltage\n",
+ "V_t = beta*V_i #Refracted voltage(kV)\n",
+ "V_r = alpha*V_i #Reflected voltage(kV)\n",
+ "I_t = V_t/Z_2*1000 #Refracted current(A)\n",
+ "I_r = -(V_r/Z_1)*1000 #Reflected current(A)\n",
+ "\n",
+ "#Result\n",
+ "print('Reflected voltage , V_r = %.1f kV' %V_r)\n",
+ "print('Refracted voltage , V_t = %.1f kV' %V_t)\n",
+ "print('Reflected current , I_r = %.1f A' %I_r)\n",
+ "print('Refracted current , I_t = %.1f A' %I_t)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Reflected voltage , V_r = -6.7 kV\n",
+ "Refracted voltage , V_t = 93.3 kV\n",
+ "Reflected current , I_r = 16.7 A\n",
+ "Refracted current , I_t = 266.7 A\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 12.2, Page number 408-409"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find refracted voltage & current waves in overhead line & underground cable\n",
+ "\n",
+ "#Variable declaration\n",
+ "V_i = 100.0 #Incident voltage(kV)\n",
+ "Z_1 = 400.0 #Surge impedance(ohm)\n",
+ "Z_21 = 350.0 #Surge impedance of line connected at T(ohm)\n",
+ "Z_22 = 50.0 #Surge impedance of cable connected at T(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "Z_2 = Z_21*Z_22/(Z_21+Z_22) #Surge impedance(ohm)\n",
+ "V_t = 2*Z_2*V_i/(Z_1+Z_2) #Refracted voltage(kV)\n",
+ "V_r = (Z_2-Z_1)*V_i/(Z_1+Z_2) #Reflected voltage(kV)\n",
+ "I_t1 = V_t/Z_21*1000 #Refracted current in Z_21(A)\n",
+ "I_t2 = V_t/Z_22*1000 #Refracted current in Z_22(A)\n",
+ "I_r = -(V_r/Z_1)*1000 #Reflected current in Z_1(A)\n",
+ "\n",
+ "#Result\n",
+ "print('Refracted voltage , V_t = %.2f kV' %V_t)\n",
+ "print('Refracted current in overhead line , I_t1 = %.2f A' %I_t1)\n",
+ "print('Refracted current in underground cable , I_t2 = %.2f A' %I_t2)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Refracted voltage , V_t = 19.72 kV\n",
+ "Refracted current in overhead line , I_t1 = 56.34 A\n",
+ "Refracted current in underground cable , I_t2 = 394.37 A\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 12.3, Page number 409"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find reflected & refracted voltage & current\n",
+ "\n",
+ "#Variable declaration\n",
+ "V_i = 100.0 #Incident voltage(kV)\n",
+ "Z_1 = 400.0 #Surge impedance of overhead line(ohm)\n",
+ "Z_2 = 50.0 #Surge impedance of underground cable(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "beta = 2*Z_2/(Z_1+Z_2) #Refraction coeffeicient of voltage\n",
+ "alpha = (Z_2-Z_1)/(Z_1+Z_2) #Reflection coeffeicient of voltage\n",
+ "V_t = beta*V_i #Refracted voltage(kV)\n",
+ "V_r = alpha*V_i #Reflected voltage(kV)\n",
+ "I_t = V_t/Z_2*1000 #Refracted current(A)\n",
+ "I_r = -(V_r/Z_1)*1000 #Reflected current(A)\n",
+ "\n",
+ "#Result\n",
+ "print('Reflected voltage , V_r = %.1f kV' %V_r)\n",
+ "print('Refracted voltage , V_t = %.1f kV' %V_t)\n",
+ "print('Reflected current , I_r = %.1f A' %I_r)\n",
+ "print('Refracted current , I_t = %.1f A' %I_t)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Reflected voltage , V_r = -77.8 kV\n",
+ "Refracted voltage , V_t = 22.2 kV\n",
+ "Reflected current , I_r = 194.4 A\n",
+ "Refracted current , I_t = 444.4 A\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 12.5, Page number 410-411"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find distance the surge travel to attenuate to half value\n",
+ "\n",
+ "#Variable declaration\n",
+ "R = 74.0*10**-6 #Resistance of overhead line(ohm/meter)\n",
+ "L = 1.212*10**-6 #Inductance of overhead line(H/meter)\n",
+ "C = 9.577*10**-12 #Capacitance of overhead line(F/meter)\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "Z_0 = (L/C)**0.5 #Surge impedance of line(ohm)\n",
+ "a = R/(2*Z_0)\n",
+ "x_1 = math.log(2)/a #Distance to be travelled(m)\n",
+ "\n",
+ "#Result\n",
+ "print('The distance the surge must travel to attenuate to half value = %.2e meter = %.2e km' %(x_1,x_1*10**-3))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "The distance the surge must travel to attenuate to half value = 6.66e+06 meter = 6.66e+03 km\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 12.7, Page number 412-413"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find current,arrester resistance,refraction & relection coefficient of voltage\n",
+ "\n",
+ "#Variable declaration\n",
+ "V_i = 2000.0 #Incident voltage(kV)\n",
+ "Z = 300.0 #Surge impedance(ohm)\n",
+ "V_p = 1200.0 #Arrester protection level(kV)\n",
+ "\n",
+ "#Calculation\n",
+ "I_surge = V_i/Z #Surge current(kA)\n",
+ "V_oc = 2*V_i #Open-circuit voltage(kV)\n",
+ "I_A = (V_oc-V_p)/Z #Current through the arrestor(kA)\n",
+ "I_r = I_A - I_surge #Reflected current in line(kA)\n",
+ "V_r = -I_r*Z #Reflected voltage of line(kV)\n",
+ "V_t = V_p #Refracted voltage into arrestor(kV)\n",
+ "V_r_coeff = V_r/V_i #Reflected coefficient of voltage\n",
+ "V_t_coeff = V_t/V_i #Refracted coefficient of voltage\n",
+ "R_a = V_p/I_A #Arrestor resistance(ohm)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a) :')\n",
+ "print('Current flowing in line before the surge voltage reaches the arrestor terminal = %.2f kA' %I_surge)\n",
+ "print('\\nCase(b) :')\n",
+ "print('Current through the arrestor , I_A = %.2f kA' %I_A)\n",
+ "print('\\nCase(c) :')\n",
+ "print('Refraction coefficient of voltage at arrestor terminals = %.1f ' %V_t_coeff)\n",
+ "print('Reflection coefficient of voltage at arrestor terminals = %.1f ' %V_r_coeff)\n",
+ "print('\\nCase(d) :')\n",
+ "print('Value of arrestor resistance = %.1f ohm' %R_a)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a) :\n",
+ "Current flowing in line before the surge voltage reaches the arrestor terminal = 6.67 kA\n",
+ "\n",
+ "Case(b) :\n",
+ "Current through the arrestor , I_A = 9.33 kA\n",
+ "\n",
+ "Case(c) :\n",
+ "Refraction coefficient of voltage at arrestor terminals = 0.6 \n",
+ "Reflection coefficient of voltage at arrestor terminals = -0.4 \n",
+ "\n",
+ "Case(d) :\n",
+ "Value of arrestor resistance = 128.6 ohm\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file diff --git a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_13_2.ipynb b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_13_2.ipynb new file mode 100644 index 00000000..84e2db43 --- /dev/null +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_13_2.ipynb @@ -0,0 +1,824 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "CHAPTER 13: SHORT-CIRCUIT PHENOMENA"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 13.1, Page number 426-430"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find symmetrical fault & fault current shared\n",
+ "\n",
+ "#Variable declaration\n",
+ "kv_gA = 11.0 #Voltage rating of generator A(kV)\n",
+ "MVA_gA = 40.0 #MVA rating of generator A\n",
+ "x_gA = 0.12 #Reactance of generator A(p.u)\n",
+ "kv_gB = 11.0 #Voltage rating of generator B(kV)\n",
+ "MVA_gB = 20.0 #MVA rating of generator B\n",
+ "x_gB = 0.08 #Reactance of generator B(p.u)\n",
+ "kv_Tlv = 11.0 #Low-voltage winding of transformer(kV)\n",
+ "kv_Thv = 66.0 #High-voltage winding of transformer(kV)\n",
+ "x_T = 0.10 #Reactance of Transformer(p.u)\n",
+ "kv_f = 66.0 #Feeder voltage(kV)\n",
+ "x_f = 30.0 #Reactance of feeder(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "MVA_base = 75.0 #Base MVA\n",
+ "kv_base_lv = 11.0 #Base voltage on LT side(kV)\n",
+ "kv_base_hv = 66.0 #Base voltage on HT side(kV)\n",
+ "x_gA_new = x_gA*(MVA_base/MVA_gA) #New Reactance of generator A(p.u)\n",
+ "x_gB_new = x_gB*(MVA_base/MVA_gB) #New Reactance of generator B(p.u)\n",
+ "x_f_new = x_f*(MVA_base/kv_base_hv**2) #New reactance of feeder(p.u)\n",
+ "\n",
+ "#For case(a)\n",
+ "x_eq = x_T+(x_gA_new*x_gB_new/(x_gA_new+x_gB_new)) #Equivalent reactance(p.u)\n",
+ "V_f = kv_Thv/kv_base_hv #Fault voltage by applying Thevenin's Theorem at FF(p.u)\n",
+ "I_f = V_f/complex(0,x_eq) #Fault current(A)\n",
+ "I_f_ht = I_f*(MVA_base*1000/(3**0.5*kv_base_hv)) #Fault current on HT side(A)\n",
+ "I_f_lt = I_f_ht*kv_base_hv/kv_base_lv #Fault current on LT side(A)\n",
+ "MVA_fault = V_f*MVA_base/x_eq #Fault MVA\n",
+ "I_A = I_f*x_gB_new/(x_gA_new+x_gB_new) #Current in generator A(p.u)\n",
+ "I_A1 = I_A*MVA_base*1000/(3**0.5*kv_base_lv) #Current in generator A(A)\n",
+ "I_B = I_f*x_gA_new/(x_gA_new+x_gB_new) #Current in generator B(p.u)\n",
+ "I_B1 = I_B*MVA_base*1000/(3**0.5*kv_base_lv) #Current in generator B(A)\n",
+ "\n",
+ "#For case(b)\n",
+ "x_eq2 = x_f_new+x_T+(x_gA_new*x_gB_new/(x_gA_new+x_gB_new)) #Equivalent reactance(p.u)\n",
+ "I_f2 = V_f/complex(0,x_eq2) #Fault current(p.u)\n",
+ "I_f_ht2 = I_f2*(MVA_base*1000/(3**0.5*kv_base_hv)) #Fault current on HT side(A)\n",
+ "MVA_fault2 = V_f*MVA_base/x_eq2 #Fault MVA\n",
+ "I_A_pu = I_f2*x_gB_new/(x_gA_new+x_gB_new) #Current in generator A(p.u)\n",
+ "I_A2 = I_A_pu*MVA_base*1000/(3**0.5*kv_base_lv) #Current in generator A(A)\n",
+ "I_B_pu = I_f2*x_gA_new/(x_gA_new+x_gB_new) #Current in generator B(p.u)\n",
+ "I_B2 = I_B_pu*MVA_base*1000/(3**0.5*kv_base_lv) #Current in generator B(A)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a) :')\n",
+ "print('Fault MVA for symmetric fault at the high voltage terminals of transformer = %.2f MVA' %MVA_fault)\n",
+ "print('Fault current shared by generator A , I_A = %.2fj A' %(I_A1.imag))\n",
+ "print('Fault current shared by generator B , I_B = %.2fj A' %(I_B1.imag))\n",
+ "print('\\nCase(b) :')\n",
+ "print('Fault MVA for symmetric fault at the load end of the feeder = %.2f MVA' %MVA_fault2)\n",
+ "print('Fault current shared by generator A , I_A = %.2fj A' %(I_A2.imag))\n",
+ "print('Fault current shared by generator B , I_B = %.2fj A' %(I_B2.imag))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a) :\n",
+ "Fault MVA for symmetric fault at the high voltage terminals of transformer = 328.12 MVA\n",
+ "Fault current shared by generator A , I_A = -9841.20j A\n",
+ "Fault current shared by generator B , I_B = -7380.90j A\n",
+ "\n",
+ "Case(b) :\n",
+ "Fault MVA for symmetric fault at the load end of the feeder = 100.66 MVA\n",
+ "Fault current shared by generator A , I_A = -3018.94j A\n",
+ "Fault current shared by generator B , I_B = -2264.21j A\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 13.2, Page number 430-432"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find the rating of the circuit breaker\n",
+ "\n",
+ "#Variable declaration\n",
+ "MVA_base = 100.0 #Base MVA\n",
+ "x1 = 0.15 #Reactance b/w F & B(p.u) . (Refer textbook diagram for marking)\n",
+ "x2 = 0.1 #Reactance b/w F & B(p.u)\n",
+ "x3 = 0.18 #Reactance b/w B & C(p.u)\n",
+ "x4 = 0.1 #Reactance b/w B & F(p.u)\n",
+ "x5 = 0.05 #Reactance b/w F & C(p.u)\n",
+ "x6 = 0.05 #Reactance b/w F & C(p.u)\n",
+ "x7 = 0.1 #Reactance b/w C & F(p.u)\n",
+ "x8 = 0.12 #Reactance b/w C & F(p.u)\n",
+ "\n",
+ "\n",
+ "#Calculation\n",
+ "V_f = 1.0 #Fault voltage by applying Thevenin's Theorem at FF(p.u)\n",
+ "x1_eq = x1+x2\n",
+ "x2_eq = x7+x8\n",
+ "x3_eq = x5*x6/(x5+x6)\n",
+ "x4_eq = x3*x4/(x3+x4+x3_eq)\n",
+ "x5_eq = x4*x3_eq/(x3+x4+x3_eq)\n",
+ "x6_eq = x3*x3_eq/(x3+x4+x3_eq)\n",
+ "x7_eq = (x1_eq+x4_eq)*(x2_eq+x6_eq)/(x1_eq+x4_eq+x2_eq+x6_eq)\n",
+ "X_eq = x7_eq+x5_eq #Equivalent reactance\n",
+ "MVA_SC = V_f*MVA_base/X_eq #Short circuit MVA at A\n",
+ "\n",
+ "#Result\n",
+ "print('Rating of the circuit breaker at the location A = %.1f MVA' %MVA_SC)\n",
+ "print('\\nNOTE : ERROR : Delta to star reactance conversion mistake in textbook')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Rating of the circuit breaker at the location A = 706.2 MVA\n",
+ "\n",
+ "NOTE : ERROR : Delta to star reactance conversion mistake in textbook\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 13.3, Page number 432-434"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find the possible short-circuit MVA at each station bus-bars\n",
+ "\n",
+ "#Variable declaration\n",
+ "x = 1.2 #Reactance of interconnector(ohm per phase)\n",
+ "kv = 33.0 #Voltage of bus-bars(kV)\n",
+ "SC_MVA1 = 3000.0 #Short-circuit MVA at bus-bar of first station(MVA)\n",
+ "SC_MVA2 = 2000.0 #Short-circuit MVA at bus-bar of second station(MVA)\n",
+ "\n",
+ "#Calculation\n",
+ "MVA_base = 3000.0 #Base MVA\n",
+ "kv_base = 33.0 #Base kV\n",
+ "x_c = x*(MVA_base/kv_base**2) #Cable reactance(p.u)\n",
+ "x1 = MVA_base/SC_MVA1 #Reactance b/w e.m.f source & bus-bars for station 1(p.u)\n",
+ "x2 = MVA_base/SC_MVA2 #Reactance b/w e.m.f source & bus-bars for station 2(p.u)\n",
+ "V_f = 1.0 #Fault voltage by applying Thevenin's Theorem at FF(p.u)\n",
+ "X_eq1 = x1*(x_c+x2)/(x1+x_c+x2) #Thevenin reactance for short-circuit at bus bars at station 1(p.u)\n",
+ "SC_MVA1_poss = V_f*MVA_base/X_eq1 #Possible short-circuit at station 1(MVA)\n",
+ "X_eq2 = x2*(x_c+x1)/(x1+x_c+x2) #Thevenin reactance for short-circuit at bus bars at station 2(p.u)\n",
+ "SC_MVA2_poss = V_f*MVA_base/X_eq2 #Possible short-circuit at station 2(MVA)\n",
+ "\n",
+ "#Result\n",
+ "print('Possible short-circuit MVA at station 1 = %.2f MVA' %SC_MVA1_poss)\n",
+ "print('Possible short-circuit MVA at station 2 = %.2f MVA' %SC_MVA2_poss)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Possible short-circuit MVA at station 1 = 3624.25 MVA\n",
+ "Possible short-circuit MVA at station 2 = 2696.74 MVA\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 13.4, Page number 434-436"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find fault current fed by generator\n",
+ "\n",
+ "#Variable declaration\n",
+ "MVA_G1 = 20.0 #MVA rating of generator 1(MVA)\n",
+ "kv_G1 = 13.2 #Voltage rating of generator 1(kV)\n",
+ "x_G1 = 0.14 #Reactance of generator 1(p.u)\n",
+ "MVA_T1 = 20.0 #MVA rating of transformer 1(MVA)\n",
+ "kv_T1_lv = 13.2 #L.V voltage rating of transformer 1(kV)\n",
+ "kv_T1_hv = 132.0 #H.V voltage rating of transformer 1(kV)\n",
+ "x_T1 = 0.08 #Reactance of transformer 1(p.u)\n",
+ "MVA_G2 = 30.0 #MVA rating of generator 2(MVA)\n",
+ "kv_G2 = 13.2 #Voltage rating of generator 2(kV)\n",
+ "x_G2 = 0.16 #Reactance of generator 2(p.u)\n",
+ "MVA_T2 = 30.0 #MVA rating of transformer 2(MVA)\n",
+ "kv_T2_lv = 13.2 #L.V voltage rating of transformer 2(kV)\n",
+ "kv_T2_hv = 132.0 #H.V voltage rating of transformer 2(kV)\n",
+ "x_T2 = 0.12 #Reactance of transformer 2(p.u)\n",
+ "x_L = 75.0 #Line reactance(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "MVA_base = 45.0 #Base MVA\n",
+ "kv_lv_base = 13.2 #L.T base voltage(kV)\n",
+ "kv_hv_base = 132.0 #H.T base voltage(kV)\n",
+ "I_lt_base = MVA_base*1000/(3**0.5*kv_lv_base) #Base current on LT side(A)\n",
+ "x_G1_new = x_G1*(MVA_base/MVA_G1) #New reactance of generator 1(p.u)\n",
+ "x_G2_new = x_G2*(MVA_base/MVA_G2) #New reactance of generator 2(p.u)\n",
+ "x_T1_new = x_T1*(MVA_base/MVA_T1) #New reactance of transformer 1(p.u)\n",
+ "x_T2_new = x_T2*(MVA_base/MVA_T2) #New reactance of transformer 2(p.u)\n",
+ "x_L_new = x_L*(MVA_base/kv_hv_base**2) #New line reactance(p.u)\n",
+ "V_f = 1.0 #Pre-fault voltage at fault point FF(p.u)\n",
+ "x_T = (x_L_new/2)+((x_G1_new+x_T1_new)*(x_G2_new+x_T2_new)/(x_G1_new+x_T1_new+x_G2_new+x_T2_new)) #Thevenin reactance(p.u)\n",
+ "I_f = V_f/complex(0,x_T) #Fault current(A)\n",
+ "I_G1 = I_f*(x_G2_new+x_T2_new)/(x_G1_new+x_T1_new+x_G2_new+x_T2_new) #Fault current shared by generator 1(p.u)\n",
+ "I_f_G1 = I_G1*I_lt_base #Fault current shared by generator 1(A)\n",
+ "I_G2 = I_f*(x_G1_new+x_T1_new)/(x_G1_new+x_T1_new+x_G2_new+x_T2_new) #Fault current shared by generator 2(p.u)\n",
+ "I_f_G2 = I_G2*I_lt_base #Fault current shared by generator 2(A)\n",
+ "\n",
+ "#Result\n",
+ "print('Fault current fed by generator 1 = %.1fj A' %I_f_G1.imag)\n",
+ "print('Fault current fed by generator 2 = %.1fj A' %I_f_G2.imag)\n",
+ "print('\\nNOTE : ERROR : MVA ratings of G2 & T2 are 30 MVA , not 25 MVA as in textbook question')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Fault current fed by generator 1 = -2787.9j A\n",
+ "Fault current fed by generator 2 = -3285.7j A\n",
+ "\n",
+ "NOTE : ERROR : MVA ratings of G2 & T2 are 30 MVA , not 25 MVA as in textbook question\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 13.5, Page number 436-439"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find SCC of bus 1\n",
+ "\n",
+ "#Variable declaration\n",
+ "MVA_base = 20.0 #Base MVA\n",
+ "\n",
+ "#Calculation\n",
+ "V_f = 1.0 #Pre-fault voltage at bus 1(p.u).(Refer textbook diagram for marking.After circuit simplification)\n",
+ "x1 = 0.049 #Reactance(p.u)\n",
+ "x2 = 0.064 #Reactance(p.u)\n",
+ "x3 = 0.04 #Reactance(p.u)\n",
+ "x_eq = (x1+x2)*x3/(x1+x2+x3) #Equivalent reactance(p.u)\n",
+ "MVA_fault = V_f*MVA_base/x_eq #Fault MVA\n",
+ "\n",
+ "#Result\n",
+ "print('SCC of bus 1 = %.f MVA' %MVA_fault)\n",
+ "print('\\nNOTE : Changes in answer is due to more decimal places')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "SCC of bus 1 = 677 MVA\n",
+ "\n",
+ "NOTE : Changes in answer is due to more decimal places\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 13.6, Page number 439-441"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find SCC,total post-fault current & post-fault voltage\n",
+ "\n",
+ "#Variable declaration\n",
+ "x_G1 = 0.15 #Sub-transient reactance of generator 1(p.u)\n",
+ "x_G2 = 0.15 #Sub-transient reactance of generator 2(p.u)\n",
+ "x_T1 = 0.12 #Leakage reactance of transformer 1(p.u)\n",
+ "x_T2 = 0.12 #Leakage reactance of transformer 2(p.u)\n",
+ "x_s = 0.2 #Reactance of tie line(p.u)\n",
+ "load = complex(1.5,0.5) #Load(p.u)\n",
+ "S_12 = complex(0.75,0.25) #Load at tie line(p.u)\n",
+ "V1 = 1.0 #Pre-fault voltage at bus 1(p.u)\n",
+ "\n",
+ "#Calculation\n",
+ "import cmath\n",
+ "#Pre-fault current & voltages\n",
+ "V_f = 1.0 #Voltage at FF(p.u)\n",
+ "Y_s = 1/complex(0,x_s) #Series admittance of line(p.u)\n",
+ "V2 = (1-(S_12/Y_s.conjugate())).conjugate() #Voltage at bus 2(p.u)\n",
+ "Z_L = (abs(V2)**2/load).conjugate() #Load at bus 2(p.u)\n",
+ "I_s = (V1-V2)*Y_s #Current through tie line(p.u)\n",
+ "I1 = I_s #Current through G1 & T1(p.u)\n",
+ "I_L = V2/Z_L #Load current(p.u)\n",
+ "I2 = I_L - I_s #Pre-fault current from generator 2(p.u)\n",
+ "\n",
+ "#Fault current\n",
+ "x_eq = (x_G1+x_T1)*(x_G2+x_T2+x_s)/(x_G1+x_T1+x_G2+x_T2+x_s) #Equivalent reactance of n/w(p.u)\n",
+ "I_f = 1/complex(0,x_eq) #Fault current(p.u)\n",
+ "I_f1 = I_f*(x_G2+x_T2+x_s)/(x_G1+x_T1+x_G2+x_T2+x_s) #Fault current through G1,T1 towards F(p.u)\n",
+ "I_f2 = I_f*(x_G1+x_T1)/(x_G1+x_T1+x_G2+x_T2+x_s) #Fault current through G2,T2 & tie-line towards F(p.u)\n",
+ "\n",
+ "#Post-fault current & voltage\n",
+ "V_1f = 0 #Post-fault voltage at bus 1(p.u)\n",
+ "V_2f = V_1f+(I_f2-I_s)*complex(0,x_s) #Post-fault voltage at bus 2(p.u)\n",
+ "\n",
+ "#Short-circuit capacity\n",
+ "SCC = V_f/x_eq #Fault MVA or SCC\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a) :')\n",
+ "print('SCC of bus 1 = %.2f p.u' %SCC)\n",
+ "print('\\nCase(b) :')\n",
+ "print('Total post-fault ac current shared by generator 1 , I_f1 = %.2fj p.u' %I_f1.imag)\n",
+ "print('Total post-fault ac current shared by generator 2 , I_f2 = %.2fj p.u' %I_f2.imag)\n",
+ "print('\\nCase(c) :')\n",
+ "print('Post-fault voltage of bus 2 , V_2f = %.3f\u2220%.2f\u00b0 p.u' %(abs(V_2f),cmath.phase(V_2f)*180/cmath.pi))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a) :\n",
+ "SCC of bus 1 = 5.83 p.u\n",
+ "\n",
+ "Case(b) :\n",
+ "Total post-fault ac current shared by generator 1 , I_f1 = -3.70j p.u\n",
+ "Total post-fault ac current shared by generator 2 , I_f2 = -2.13j p.u\n",
+ "\n",
+ "Case(c) :\n",
+ "Post-fault voltage of bus 2 , V_2f = 0.404\u2220-21.77\u00b0 p.u\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 13.7, Page number 462-463"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find symmetrical components of line currents\n",
+ "\n",
+ "#Variable declaration\n",
+ "import cmath\n",
+ "I_a = 10.0*cmath.exp(1j*90*cmath.pi/180) #Line current(A)\n",
+ "I_b = 10.0*cmath.exp(1j*-90*cmath.pi/180) #Line current(A)\n",
+ "I_c = 10.0*cmath.exp(1j*0*cmath.pi/180) #Line current(A)\n",
+ "\n",
+ "#Calculation\n",
+ "a = 1.0*cmath.exp(1j*120*cmath.pi/180) #Operator\n",
+ "I_a0 = 1.0/3*(I_a+I_b+I_c) #Zero-sequence component(A)\n",
+ "I_a1 = 1.0/3*(I_a+a*I_b+a**2*I_c) #Positive-sequence component(A)\n",
+ "I_a2 = 1.0/3*(I_a+a**2*I_b+a*I_c) #Negative-sequence component(A)\n",
+ "\n",
+ "#Result\n",
+ "print('Zero-sequence component , I_a0 = %.2f\u2220%.f\u00b0 A' %(abs(I_a0),cmath.phase(I_a0)*180/cmath.pi))\n",
+ "print('Positive-sequence component , I_a1 = %.3f\u2220%.f\u00b0 A' %(abs(I_a1),cmath.phase(I_a1)*180/cmath.pi))\n",
+ "print('Negative-sequence component , I_a2 = %.1f\u2220%.f\u00b0 A' %(abs(I_a2),cmath.phase(I_a2)*180/cmath.pi))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Zero-sequence component , I_a0 = 3.33\u22200\u00b0 A\n",
+ "Positive-sequence component , I_a1 = 2.440\u222060\u00b0 A\n",
+ "Negative-sequence component , I_a2 = 9.1\u2220120\u00b0 A\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 13.8, Page number 463-467"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find short-circuit current & terminal voltages\n",
+ "\n",
+ "#Variable declaration\n",
+ "kv = 13.2 #Voltage rating of generator(kV)\n",
+ "MVA = 25.0 #MVA rating of generator\n",
+ "MVA_sc = 170.0 #Short circuit MVA\n",
+ "x0 = 0.05 #Zero sequence reactance(p.u)\n",
+ "x2 = 0.13 #Negative sequence reactance(p.u)\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "import cmath\n",
+ "MVA_base = 25.0 #Base MVA\n",
+ "kv_base = 13.2 #Line-to-line Base voltage(kV)\n",
+ "I_base = MVA_base*1000/(3**0.5*kv_base) #Base current(A)\n",
+ "x1 = MVA_base/MVA_sc #Positive sequence reactance(p.u)\n",
+ "V_f = 1.0 #Pre-fault terminal voltage(p.u)\n",
+ "Z_f = 0 #Fault impedance\n",
+ "a = 1.0*cmath.exp(1j*120*cmath.pi/180) #Operator\n",
+ "\n",
+ "#L-G fault\n",
+ "I_a1 = V_f/complex(0,(x0+x1+x2)) #Positive sequence current(p.u)\n",
+ "I_a2 = I_a1 #Negative sequence current(p.u)\n",
+ "I_a0 = I_a1 #Zero sequence current(p.u)\n",
+ "I_a = 3*I_a1*I_base #Fault current at phase a(A)\n",
+ "I_b = 0 #Fault current at phase b(A)\n",
+ "I_c = 0 #Fault current at phase c(A)\n",
+ "V_a1 = V_f - I_a1*complex(0,x1) #Terminal voltage(p.u)\n",
+ "V_a2 = -I_a2*complex(0,x2) #Terminal voltage(p.u)\n",
+ "V_a0 = -I_a0*complex(0,x0) #Terminal voltage(p.u)\n",
+ "V_a = (V_a0+V_a1+V_a2)*kv_base/3**0.5 #Line-to-neutral voltage at terminal(kV)\n",
+ "V_b = (V_a0+a**2*V_a1+a*V_a2)*kv_base/3**0.5 #Line-to-neutral voltage at terminal(kV)\n",
+ "V_c = (V_a0+a*V_a1+a**2*V_a2)*kv_base/3**0.5 #Line-to-neutral voltage at terminal(kV)\n",
+ "V_ab = (V_a-V_b) #Line voltages at terminal(kV)\n",
+ "V_bc = (V_b-V_c) #Line voltages at terminal(kV)\n",
+ "V_ca = (V_c-V_a) #Line voltages at terminal(kV)\n",
+ "\n",
+ "#L-L fault\n",
+ "I_a12 = V_f/complex(0,(x1+x2)) #Positive sequence current(p.u)\n",
+ "I_a22 = -I_a12 #Negative sequence current(p.u)\n",
+ "I_a02 = 0 #Zero sequence current(p.u)\n",
+ "I_a_2 = (I_a12+I_a22+I_a02)*I_base #Fault current at phase a(A)\n",
+ "I_b_2 = (a**2*I_a12+a*I_a22+I_a02)*I_base #Fault current at phase b(A)\n",
+ "I_c_2 = -I_b_2 #Fault current at phase c(A)\n",
+ "V_a12 = V_f - I_a12*complex(0,x1) #Terminal voltage(p.u)\n",
+ "V_a22 = V_a12 #Terminal voltage(p.u)\n",
+ "V_a02 = 0 #Terminal voltage(p.u)\n",
+ "V_a_2 = (V_a02+V_a12+V_a22)*kv_base/3**0.5 #Line-to-neutral voltage at terminal(kV)\n",
+ "V_b_2 = (V_a02+a**2*V_a12+a*V_a22)*kv_base/3**0.5 #Line-to-neutral voltage at terminal(kV)\n",
+ "V_c_2 = (V_a02+a*V_a12+a**2*V_a22)*kv_base/3**0.5 #Line-to-neutral voltage at terminal(kV)\n",
+ "V_ab2 = (V_a_2-V_b_2) #Line voltages at terminal(kV)\n",
+ "V_bc2 = (V_b_2-V_c_2) #Line voltages at terminal(kV)\n",
+ "V_ca2 = (V_c_2-V_a_2) #Line voltages at terminal(kV)\n",
+ "\n",
+ "#L-L-G fault\n",
+ "I_a13 = V_f/complex(0,(x1+(x0*x2/(x0+x2)))) #Positive sequence current(p.u)\n",
+ "I_a23 = -I_a13*x0/(x0+x2) #Negative sequence current(p.u)\n",
+ "I_a03 = -I_a13*x2/(x0+x2) #Zero sequence current(p.u)\n",
+ "I_a_3 = (I_a13+I_a23+I_a03)*I_base #Fault current at phase a(A)\n",
+ "I_b_3 = (I_a03+a**2*I_a13+a*I_a23)*I_base #Fault current at phase b(A)\n",
+ "I_c_3 = (I_a03+a*I_a13+a**2*I_a23)*I_base #Fault current at phase c(A)\n",
+ "V_a13 = V_f-I_a13*complex(0,x1) #Terminal voltage(p.u)\n",
+ "V_a23 = V_a13 #Terminal voltage(p.u)\n",
+ "V_a03 = V_a13 #Terminal voltage(p.u)\n",
+ "V_a3 = (V_a03+V_a13+V_a23)*kv_base/3**0.5 #Line-to-neutral voltage at terminal(kV)\n",
+ "V_b3 = (V_a03+a**2*V_a13+a*V_a23)*kv_base/3**0.5 #Line-to-neutral voltage at terminal(kV)\n",
+ "V_c3 = (V_a03+a*V_a13+a**2*V_a23)*kv_base/3**0.5 #Line-to-neutral voltage at terminal(kV)\n",
+ "V_ab3 = (V_a3-V_b3) #Line voltages at terminal(kV)\n",
+ "V_bc3 = (V_b3-V_c3) #Line voltages at terminal(kV)\n",
+ "V_ca3 = (V_c3-V_a3) #Line voltages at terminal(kV)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(i) : L-G fault :')\n",
+ "print('Short circuit current , I_a = %.1fj A = %.1f\u2220%.f\u00b0 A' %(I_a.imag,abs(I_a),cmath.phase(I_a)*180/math.pi))\n",
+ "print('Short circuit current , I_b = %.f\u2220%.f\u00b0 A' %(abs(I_b),cmath.phase(I_b)*180/math.pi))\n",
+ "print('Short circuit current , I_c = %.f\u2220%.f\u00b0 A' %(abs(I_c),cmath.phase(I_c)*180/math.pi))\n",
+ "print('Terminal line voltage , V_ab = %.2f\u2220%.2f\u00b0 kV' %(abs(V_ab),cmath.phase(V_ab)*180/math.pi))\n",
+ "print('Terminal line voltage , V_bc = %.2f\u2220%.2f\u00b0 kV' %(abs(V_bc),cmath.phase(V_bc)*180/math.pi))\n",
+ "print('Terminal line voltage , V_ca = %.2f\u2220%.2f\u00b0 kV' %(abs(V_ca),cmath.phase(V_ca)*180/math.pi))\n",
+ "print('\\nCase(ii) : L-L fault :')\n",
+ "print('Short circuit current , I_a = %.f\u2220%.f\u00b0 A' %(abs(I_a_2),cmath.phase(I_a_2)*180/math.pi))\n",
+ "print('Short circuit current , I_b = %.2f\u2220%.1f\u00b0 A' %(abs(I_b_2),cmath.phase(I_b_2)*180/math.pi))\n",
+ "print('Short circuit current , I_c = %.2f\u2220%.1f\u00b0 A' %(abs(I_c_2),cmath.phase(I_c_2)*180/math.pi))\n",
+ "print('Terminal line voltage , V_ab = %.3f\u2220%.1f\u00b0 kV' %(abs(V_ab2),cmath.phase(V_ab2)*180/math.pi))\n",
+ "print('Terminal line voltage , V_bc = %.f\u2220%.1f\u00b0 kV' %(abs(V_bc2),cmath.phase(V_bc2)*180/math.pi))\n",
+ "print('Terminal line voltage , V_ca = %.3f\u2220%.1f\u00b0 kV' %(abs(V_ca2),cmath.phase(V_ca2)*180/math.pi))\n",
+ "print('\\nCase(iii) : L-L-G fault :')\n",
+ "print('Short circuit current , I_a = %.f\u2220%.f\u00b0 A' %(abs(I_a_3),cmath.phase(I_a_3)*180/math.pi))\n",
+ "print('Short circuit current , I_b = %.2f\u2220%.1f\u00b0 A' %(abs(I_b_3),cmath.phase(I_b_3)*180/math.pi))\n",
+ "print('Short circuit current , I_c = %.2f\u2220%.1f\u00b0 A' %(abs(I_c_3),cmath.phase(I_c_3)*180/math.pi))\n",
+ "print('Terminal line voltage , V_ab = %.3f\u2220%.f\u00b0 kV' %(abs(V_ab3),cmath.phase(V_ab3)*180/math.pi))\n",
+ "print('Terminal line voltage , V_bc = %.f\u2220%.f\u00b0 kV' %(abs(V_bc3),cmath.phase(V_bc3)*180/math.pi))\n",
+ "print('Terminal line voltage , V_ca = %.3f\u2220%.f\u00b0 kV' %(abs(V_ca3),cmath.phase(V_ca3)*180/math.pi))\n",
+ "print('\\nNOTE : Changes in answer is due to more decimal places')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(i) : L-G fault :\n",
+ "Short circuit current , I_a = -10030.0j A = 10030.0\u2220-90\u00b0 A\n",
+ "Short circuit current , I_b = 0\u22200\u00b0 A\n",
+ "Short circuit current , I_c = 0\u22200\u00b0 A\n",
+ "Terminal line voltage , V_ab = 6.50\u222074.39\u00b0 kV\n",
+ "Terminal line voltage , V_bc = 12.51\u2220-90.00\u00b0 kV\n",
+ "Terminal line voltage , V_ca = 6.50\u2220105.61\u00b0 kV\n",
+ "\n",
+ "Case(ii) : L-L fault :\n",
+ "Short circuit current , I_a = 0\u22200\u00b0 A\n",
+ "Short circuit current , I_b = 6835.87\u2220180.0\u00b0 A\n",
+ "Short circuit current , I_c = 6835.87\u2220-0.0\u00b0 A\n",
+ "Terminal line voltage , V_ab = 10.728\u2220-0.0\u00b0 kV\n",
+ "Terminal line voltage , V_bc = 0\u22200.0\u00b0 kV\n",
+ "Terminal line voltage , V_ca = 10.728\u2220180.0\u00b0 kV\n",
+ "\n",
+ "Case(iii) : L-L-G fault :\n",
+ "Short circuit current , I_a = 0\u22200\u00b0 A\n",
+ "Short circuit current , I_b = 9244.62\u2220135.6\u00b0 A\n",
+ "Short circuit current , I_c = 9244.62\u222044.4\u00b0 A\n",
+ "Terminal line voltage , V_ab = 4.507\u2220-0\u00b0 kV\n",
+ "Terminal line voltage , V_bc = 0\u22200\u00b0 kV\n",
+ "Terminal line voltage , V_ca = 4.507\u2220180\u00b0 kV\n",
+ "\n",
+ "NOTE : Changes in answer is due to more decimal places\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 13.9, Page number 467"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find fault current & neutral potential\n",
+ "\n",
+ "#Variable declaration\n",
+ "x0 = 0.05 #Zero sequence reactance(p.u)\n",
+ "x2 = 0.13 #Negative sequence reactance(p.u)\n",
+ "r = 1.0 #Resistance through which generator neutral is earthed(ohm)\n",
+ "MVA_sc = 170.0 #Short circuit MVA\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "import cmath\n",
+ "MVA_base = 25.0 #Base MVA\n",
+ "kv_base = 13.2 #Line-to-line Base voltage(kV)\n",
+ "I_base = MVA_base*1000/(3**0.5*kv_base) #Base current(A)\n",
+ "kv_base1 = 11.0 #Base kV\n",
+ "Z_n = r*MVA_base/kv_base1**2 #Neutral impedance(p.u)\n",
+ "V_f = 1.0 #Pre-fault terminal voltage(p.u)\n",
+ "x1 = MVA_base/MVA_sc #Positive sequence reactance(p.u)\n",
+ "I_a1 = V_f/complex(3*Z_n,(x1+x2+x0)) #Positive sequence current(p.u)\n",
+ "I_a0 = I_a1 #Zero sequence current(p.u)\n",
+ "I_a2 = I_a1 #Negative sequence current(p.u)\n",
+ "I_a = 3*I_a1*I_base #Fault current(A)\n",
+ "V_n = 3*I_a0*Z_n*I_base #Potential of neutral(V)\n",
+ "\n",
+ "#Result\n",
+ "print('Fault current for a L-G short-circuit at its terminals , I_a = %.2f\u2220%.2f\u00b0 A' %(abs(I_a),cmath.phase(I_a)*180/math.pi))\n",
+ "print('Neutral potential = %.3f\u2220%.2f\u00b0 V' %(abs(V_n),cmath.phase(V_n)*180/math.pi))\n",
+ "print('\\nNOTE : ERROR : For calculating neutral potential in textbook Z_n = 1 is taken instead of Z_n = 0.206611570248')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Fault current for a L-G short-circuit at its terminals , I_a = 4680.74\u2220-27.82\u00b0 A\n",
+ "Neutral potential = 967.094\u2220-27.82\u00b0 V\n",
+ "\n",
+ "NOTE : ERROR : For calculating neutral potential in textbook Z_n = 1 is taken instead of Z_n = 0.206611570248\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 13.10, Page number 467-471"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find fault current & current contributed by G1 & G2\n",
+ "\n",
+ "#Variable declaration\n",
+ "x1_G1 = complex(0,0.17) #Positive sequence reactance of G1(p.u)\n",
+ "x2_G1 = complex(0,0.14) #Negative sequence reactance of G1(p.u)\n",
+ "x0_G1 = complex(0,0.05) #Zero sequence reactance of G1(p.u)\n",
+ "x1_G2 = complex(0,0.17) #Positive sequence reactance of G2(p.u)\n",
+ "x2_G2 = complex(0,0.14) #Negative sequence reactance of G2(p.u)\n",
+ "x0_G2 = complex(0,0.05) #Zero sequence reactance of G2(p.u)\n",
+ "x1_T1 = complex(0,0.11) #Positive sequence reactance of T1(p.u)\n",
+ "x2_T1 = complex(0,0.11) #Negative sequence reactance of T1(p.u)\n",
+ "x0_T1 = complex(0,0.11) #Zero sequence reactance of T1(p.u)\n",
+ "x1_T2 = complex(0,0.11) #Positive sequence reactance of T2(p.u)\n",
+ "x2_T2 = complex(0,0.11) #Negative sequence reactance of T2(p.u)\n",
+ "x0_T2 = complex(0,0.11) #Zero sequence reactance of T2(p.u)\n",
+ "x1_L = complex(0,0.22) #Positive sequence reactance of line(p.u)\n",
+ "x2_L = complex(0,0.22) #Negative sequence reactance of line(p.u)\n",
+ "x0_L = complex(0,0.60) #Zero sequence reactance of line(p.u)\n",
+ "\n",
+ "#Calculation\n",
+ "import cmath\n",
+ "a = 1.0*cmath.exp(1j*120*cmath.pi/180) #Operator\n",
+ "Z_1T = (x1_G1+x1_T1)*(x1_G2+x1_T2+x1_L)/(x1_G1+x1_T1+x1_G2+x1_T2+x1_L) #Thevenin reactance of positive sequence(p.u)\n",
+ "Z_2T = (x2_G1+x2_T1)*(x2_G2+x2_T2+x2_L)/(x2_G1+x2_T1+x2_G2+x2_T2+x2_L) #Thevenin reactance of negative sequence(p.u)\n",
+ "Z_0T = (x0_G1+x0_T1)*(x0_T2+x0_L)/(x0_G1+x0_T1+x0_T2+x0_L) #Thevenin reactance of zero sequence(p.u)\n",
+ "V_f = 1.0 #Pre-fault terminal voltage(p.u)\n",
+ "I_a1 = V_f/(Z_1T+Z_2T+Z_0T) #Positive sequence current(p.u)\n",
+ "I_a2 = I_a1 #Negative sequence current(p.u)\n",
+ "I_a0 = I_a1 #Zero sequence current(p.u)\n",
+ "I_a = 3*I_a1 #Fault current(p.u)\n",
+ "\n",
+ "#Generator G1\n",
+ "I_a1_G1 = I_a1*(x1_L+x1_T2+x1_G2)/(x1_L+x1_T1+x1_G1+x1_T2+x1_G2) #Positive sequence current shared by G1(p.u)\n",
+ "I_a2_G1 = I_a2*(x2_L+x2_T2+x2_G2)/(x2_L+x2_T1+x2_G1+x2_T2+x2_G2) #Negative sequence current shared by G1(p.u)\n",
+ "I_a0_G1 = I_a0*(x0_L+x0_T2)/(x0_L+x0_T1+x0_G1+x0_T2) #Zero sequence current shared by G1(p.u)\n",
+ "I_a_G1 = I_a0_G1+I_a1_G1+I_a2_G1 #Phase current through G1(p.u)\n",
+ "I_b_G1 = I_a0_G1+a**2*I_a1_G1+a*I_a2_G1 #Phase current through G1(p.u)\n",
+ "I_c_G1 = I_a0_G1+a*I_a1_G1+a**2*I_a2_G1 #Phase current through G1(p.u)\n",
+ "\n",
+ "#Generator G2\n",
+ "I_a1_G2 = I_a1*(x1_T1+x1_G1)/(x1_L+x1_T1+x1_G1+x1_T2+x1_G2)*cmath.exp(1j*30*cmath.pi/180) #Positive sequence current shared by G1(p.u)\n",
+ "I_a2_G2 = I_a2*(x2_T1+x2_G1)/(x2_L+x2_T1+x2_G1+x2_T2+x2_G2)*cmath.exp(1j*-30*cmath.pi/180) #Negative sequence current shared by G1(p.u)\n",
+ "I_a0_G2 = 0 #Zero sequence current shared by G1(p.u)\n",
+ "I_a_G2 = I_a0_G2+I_a1_G2+I_a2_G2 #Phase current through G2(p.u)\n",
+ "I_b_G2 = I_a0_G2+a**2*I_a1_G2+a*I_a2_G2 #Phase current through G2(p.u)\n",
+ "I_c_G2 = I_a0_G2+a*I_a1_G2+a**2*I_a2_G2 #Phase current through G2(p.u)\n",
+ "\n",
+ "#Result\n",
+ "print('Fault current for a L-G fault at bus 1 , I_a = %.3fj p.u' %I_a.imag)\n",
+ "print('\\nPhase currents contributed by G1 :')\n",
+ "print('I_a = %.3f\u2220%.1f\u00b0 p.u' %(abs(I_a_G1),cmath.phase(I_a_G1)*180/cmath.pi))\n",
+ "print('I_b = %.3f\u2220%.1f\u00b0 p.u' %(abs(I_b_G1),cmath.phase(I_b_G1)*180/cmath.pi))\n",
+ "print('I_c = %.3f\u2220%.1f\u00b0 p.u' %(abs(I_c_G1),cmath.phase(I_c_G1)*180/cmath.pi))\n",
+ "print('\\nPhase currents contributed by G2 :')\n",
+ "print('I_a = %.3f\u2220%.1f\u00b0 p.u' %(abs(I_a_G2),cmath.phase(I_a_G2)*180/cmath.pi))\n",
+ "print('I_b = %.3f\u2220%.1f\u00b0 p.u' %(abs(I_b_G2),cmath.phase(I_b_G2)*180/cmath.pi))\n",
+ "print('I_c = %.3f\u2220%.1f\u00b0 p.u' %(abs(I_c_G2),cmath.phase(I_c_G2)*180/cmath.pi))\n",
+ "print('\\nNOTE : ERROR : Calculation mistakes in Generator G2 part')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Fault current for a L-G fault at bus 1 , I_a = -6.339j p.u\n",
+ "\n",
+ "Phase currents contributed by G1 :\n",
+ "I_a = 4.458\u2220-90.0\u00b0 p.u\n",
+ "I_b = 0.358\u2220-86.6\u00b0 p.u\n",
+ "I_c = 0.358\u2220-93.4\u00b0 p.u\n",
+ "\n",
+ "Phase currents contributed by G2 :\n",
+ "I_a = 1.292\u2220-89.4\u00b0 p.u\n",
+ "I_b = 0.025\u2220180.0\u00b0 p.u\n",
+ "I_c = 1.292\u222089.4\u00b0 p.u\n",
+ "\n",
+ "NOTE : ERROR : Calculation mistakes in Generator G2 part\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 13.11, Page number 471-473"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find fault current & fault MVA for L-G fault\n",
+ "\n",
+ "#Variable declaration\n",
+ "kv_G1 = 13.2 #Voltage rating of G1(kV)\n",
+ "MVA_G1 = 40.0 #MVA rating of G1\n",
+ "x1_G1 = 0.2 #Positive sequence reactance of G1(p.u)\n",
+ "x2_G1 = 0.2 #Negative sequence reactance of G1(p.u)\n",
+ "x0_G1 = 0.08 #Zero sequence reactance of G1(p.u)\n",
+ "MVA_T1 = 40.0 #MVA rating of T1\n",
+ "x_T1 = 0.05 #Reactance(p.u)\n",
+ "kv_lv_T1 = 13.2 #L.V side rating of T1(kV)\n",
+ "kv_hv_T1 = 132.0 #H.V side rating of T1(kV)\n",
+ "kv_L = 132.0 #Voltage rating of line(kV)\n",
+ "x1_L = 40.0 #Positive sequence resistance of line(ohm)\n",
+ "x2_L = 40.0 #Negative sequence resistance of line(ohm)\n",
+ "x0_L = 100.0 #Zero sequence resistance of line(ohm)\n",
+ "MVA_T2 = 40.0 #MVA rating of T1\n",
+ "x_T2 = 1.0 #Resistance through which neutral is earthed(ohm)\n",
+ "xp_T2 = 0.05 #Primary reactance of T2(p.u)\n",
+ "xs_T2 = 0.045 #Secondary reactance of T2(p.u)\n",
+ "xt_T2 = 0.06 #Tertiary reactance of T2(p.u)\n",
+ "\n",
+ "#Calculation\n",
+ "MVA_base = 40.0 #Base MVA\n",
+ "kv_base_G1 = 13.2 #Voltage base on generator side(kV)\n",
+ "kv_base_L = 132.0 #Voltage base on Line side(kV)\n",
+ "kv_base_T2t = 3.3 #Voltage base on tertiary side of T2(kV)\n",
+ "kv_base_T2s = 66 #Voltage base on secondary side of T2(kV)\n",
+ "R_ng = 2*MVA_base/kv_base_G1**2 #Neutral resistance of generator(p.u)\n",
+ "x1_L_new = x1_L*MVA_base/kv_base_L**2 #New Line reactance(p.u)\n",
+ "x2_L_new = x2_L*MVA_base/kv_base_L**2 #New Line reactance(p.u)\n",
+ "x0_L_new = x0_L*MVA_base/kv_base_L**2 #New Line reactance(p.u)\n",
+ "R_nT = x_T2*MVA_base/kv_base_T2s**2 #Neutral resistance of T2(p.u)\n",
+ "V_f = 1.0 #Pre-fault voltage at fault point(p.u)\n",
+ "Z1 = complex(0,x1_G1+x_T1+(x1_L_new/2)+xp_T2+xs_T2) #Thevenin impedance of positive sequence(p.u)\n",
+ "Z2 = complex(0,x2_G1+x_T1+(x2_L_new/2)+xp_T2+xs_T2) #Thevenin impedance of negative sequence(p.u)\n",
+ "Z0 = complex(0.0024,0.0593) #Thevenin impedance of zero sequence(p.u).Refer diagram\n",
+ "I_f = 3*V_f/(Z1+Z2+Z0) #Fault current(p.u)\n",
+ "I_f1 = abs(I_f)*MVA_base*1000/(3**0.5*kv_base_T2s) #Fault current(A)\n",
+ "MVA_fault = abs(I_f)*MVA_base #Fault MVA\n",
+ "\n",
+ "#Result\n",
+ "print('Fault current , I_f = %.2f A' %I_f1)\n",
+ "print('Fault MVA for L-G fault = %.2f MVA' %MVA_fault)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Fault current , I_f = 1248.00 A\n",
+ "Fault MVA for L-G fault = 142.67 MVA\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file diff --git a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_14_2.ipynb b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_14_2.ipynb new file mode 100644 index 00000000..7e9e089f --- /dev/null +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_14_2.ipynb @@ -0,0 +1,253 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "CHAPTER 14: ELEMENTS OF CIRCUIT-BREAKERS AND RELAYS"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.1, Page number 521"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find operating time of relay\n",
+ "\n",
+ "#Variable declaration\n",
+ "TMS = 0.5 #Time multiplier setting\n",
+ "I_f = 5000.0 #Fault current(A)\n",
+ "CT = 500.0/5 #CT ratio\n",
+ "set_plug = 1.0 #Relay plug set\n",
+ "I_relay = 5.0 #Rated relay current(A)\n",
+ "\n",
+ "#Calculation\n",
+ "PSM = I_f/(CT*set_plug*I_relay) #Plug setting multiplier\n",
+ "T1 = 1.0 #Time of operation for obtained PSM & TMS of 1 from graph.Refer Fig 14.22\n",
+ "T2 = TMS*3/T1 #Time of operation(sec)\n",
+ "\n",
+ "#Result\n",
+ "print('Operating time of the relay = %.1f sec' %T2)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Operating time of the relay = 1.5 sec\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.2, Page number 528-529"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find CT ratio,PSM,TMS for each IDMT relays\n",
+ "\n",
+ "#Variable declaration\n",
+ "I_f_A = 6000.0 #3-phase fault current of substation A(A)\n",
+ "I_f_B = 5000.0 #3-phase fault current of substation B(A)\n",
+ "I_f_C = 3000.0 #3-phase fault current of substation C(A)\n",
+ "I_f_D = 2000.0 #3-phase fault current of substation D(A)\n",
+ "I_L_max = 100.0 #Maximum load cuurent(A)\n",
+ "T = 0.5 #Operating time of breakers(sec)\n",
+ " \n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "import cmath\n",
+ "I_set = 1.0 #Setting current(A)\n",
+ "\n",
+ "#For relay D\n",
+ "I_L_maxD = I_L_max #Maximum load current at D(A)\n",
+ "CT_D = I_L_max/1 #CT ratio\n",
+ "PSM_D = I_f_D/(CT_D*I_set) #Plug setting multiplier\n",
+ "TMS_D = 0.1 #Time multiplier setting\n",
+ "T_D = 0.14*TMS_D/(PSM_D**0.02-1) #Time of operation(sec)\n",
+ "\n",
+ "#For relay C\n",
+ "I_L_maxC = I_L_max+I_L_maxD #Maximum load current at C(A)\n",
+ "CT_C = I_L_maxC/1 #CT ratio\n",
+ "PSM_C = I_f_C/(CT_C*I_set) #Plug setting multiplier\n",
+ "T_C = T_D+T #Minimum time of operation(sec)\n",
+ "TMS_C = T_C*(PSM_C**0.02-1)/0.14 #Time multiplier setting\n",
+ "\n",
+ "#For relay B\n",
+ "I_L_maxB = I_L_max+I_L_maxC #Maximum load current at B(A)\n",
+ "CT_B = I_L_maxB/1 #CT ratio\n",
+ "PSM_B = I_f_B/(CT_B*I_set) #Plug setting multiplier\n",
+ "T_B = T_C+T #Minimum time of operation(sec)\n",
+ "TMS_B = T_B*(PSM_B**0.02-1)/0.14 #Time multiplier setting\n",
+ "\n",
+ "#For relay A\n",
+ "I_L_maxA = I_L_max+I_L_maxB #Maximum load current at A(A)\n",
+ "CT_A = I_L_maxA/1 #CT ratio\n",
+ "PSM_A = I_f_A/(CT_A*I_set) #Plug setting multiplier\n",
+ "T_A = T_B+T #Minimum time of operation(sec)\n",
+ "TMS_A = T_A*(PSM_A**0.02-1)/0.14 #Time multiplier setting\n",
+ "\n",
+ "#Result\n",
+ "print('Relay A :')\n",
+ "print('CT ratio = %.f/1' %CT_A)\n",
+ "print('PSM of R_A = %.1f' %PSM_A)\n",
+ "print('TMS of R_A = %.1f sec' %TMS_A)\n",
+ "print('\\nRelay B :')\n",
+ "print('CT ratio = %.f/1' %CT_B)\n",
+ "print('PSM of R_B = %.2f' %PSM_B)\n",
+ "print('TMS of R_B = %.1f sec' %TMS_B)\n",
+ "print('\\nRelay C :')\n",
+ "print('CT ratio = %.f/1' %CT_C)\n",
+ "print('PSM of R_C = %.1f' %PSM_C)\n",
+ "print('TMS of R_C = %.1f sec' %TMS_C)\n",
+ "print('\\nRelay D :')\n",
+ "print('CT ratio = %.f/1' %CT_D)\n",
+ "print('PSM of R_D = %.1f' %PSM_D)\n",
+ "print('TMS of R_D = %.2f sec' %TMS_D)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Relay A :\n",
+ "CT ratio = 400/1\n",
+ "PSM of R_A = 15.0\n",
+ "TMS of R_A = 0.7 sec\n",
+ "\n",
+ "Relay B :\n",
+ "CT ratio = 300/1\n",
+ "PSM of R_B = 16.67\n",
+ "TMS of R_B = 0.5 sec\n",
+ "\n",
+ "Relay C :\n",
+ "CT ratio = 200/1\n",
+ "PSM of R_C = 15.0\n",
+ "TMS of R_C = 0.3 sec\n",
+ "\n",
+ "Relay D :\n",
+ "CT ratio = 100/1\n",
+ "PSM of R_D = 20.0\n",
+ "TMS of R_D = 0.10 sec\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.3, Page number 537-538"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find ratio of CT on high tension side\n",
+ "\n",
+ "#Variable declaration\n",
+ "kv_hv = 66.0 #Voltage rating of HV side of transformer(kV)\n",
+ "kv_lv = 11.0 #Voltage rating of LV side of transformer(kV)\n",
+ "CT = 300.0/5 #CT ratio on low tension side\n",
+ "\n",
+ "#Calculation\n",
+ "I = 300.0 #Assumed current flowing at low tension side(A)\n",
+ "I_HT = kv_lv/kv_hv*I #Line current on HT side(A)\n",
+ "I_LT_CT = I/CT #Pilot wire current from LT side(A)\n",
+ "CT_ratio_HT = I_HT*3**0.5/I_LT_CT #Ratio of CT on HT side\n",
+ "\n",
+ "#Result\n",
+ "print('Ratio of CT on high tension side = %.f\u221a3/%.f' %(I_HT,I_LT_CT))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Ratio of CT on high tension side = 50\u221a3/5\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 14.4, Page number 543-544"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find percentage of winding that remains unprotected\n",
+ "\n",
+ "#Variable declaration\n",
+ "kv = 11.0 #Voltage rating(kV)\n",
+ "MVA = 5.0 #MVA rating\n",
+ "R = 10.0 #Resistance(ohm)\n",
+ "per_a = 0.15 #Armature winding reactance\n",
+ "per_trip = 0.3 #Relay trip for out-of-balance\n",
+ "\n",
+ "#Calculation\n",
+ "x_p = per_a*kv**2/MVA #Winding Reactance(ohm)\n",
+ "V = kv/3**0.5*1000 #Phase voltage(V)\n",
+ "I = per_trip*MVA*1000/(3**0.5*kv) #Out of balance current(A)\n",
+ "p = (((R*I)**2/(V**2-(x_p*I)**2))**0.5)*100 #Percentage of winding remains unsupported\n",
+ "\n",
+ "#Result\n",
+ "print('Percentage of winding that remains unprotected , p = %.1f percentage' %p)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Percentage of winding that remains unprotected , p = 12.4 percentage\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file diff --git a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_15_2.ipynb b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_15_2.ipynb new file mode 100644 index 00000000..5631893f --- /dev/null +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_15_2.ipynb @@ -0,0 +1,330 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "CHAPTER 15: POWER SYSTEM STABILITY"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 15.1, Page number 561"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find rotor angle & rotor velocity\n",
+ "\n",
+ "#Variable declaration\n",
+ "G = 50.0 #Rating of machine(MVA)\n",
+ "f = 50.0 #Frequency of turbo generator(Hz)\n",
+ "V = 11.0 #Voltage rating of machine(kV)\n",
+ "H = 9.0 #Cycle corresponding to 180 ms\n",
+ "P_0 = 40.0 #Pre-fault output power(MW)\n",
+ "delta_0 = 20.0 #Rotor angle at instant of fault(degree)\n",
+ "\n",
+ "#Calculation\n",
+ "P_0_close = 0 #Output power at instant of reclosing(MW)\n",
+ "P_a = P_0 - P_0_close #Net accelerating power(MW)\n",
+ "delta_sqr = P_a*180*f/(G*H) #double derivative(elect.degrees/sec^2)\n",
+ "\n",
+ "from scipy.integrate import quad\n",
+ "\n",
+ "def integrand1(t): #Integrates the double derivative to 800*t\n",
+ " return delta_sqr\n",
+ "a, err = quad(integrand1, 0, 180*10**-3) #Rotor velocity(electrical degrees/sec)\n",
+ "\n",
+ "def integrand2(t): #Integrates the double derivative to 400*t^2\n",
+ " return delta_sqr*t\n",
+ "b, err = quad(integrand2, 0, 180*10**-3)\n",
+ "delta = delta_0 + b #Rotor angle(electrical degrees)\n",
+ "\n",
+ "#Result\n",
+ "print('Rotor angle at the instant of reclosure = %.2f\u00b0 electrical degrees' %delta)\n",
+ "print('Rotor velocity at the instant of reclosure = %.1f electrical degrees/sec' %a)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Rotor angle at the instant of reclosure = 32.96\u00b0 electrical degrees\n",
+ "Rotor velocity at the instant of reclosure = 144.0 electrical degrees/sec\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 15.2, Page number 571"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find if system is stable or not\n",
+ "\n",
+ "#Variable declaration\n",
+ "V = 1.0 #Infinite bus voltage(p.u)\n",
+ "E = 1.0 #e.m.f of finite generator behind transient reactance(p.u)\n",
+ "X_T = 0.8 #Transfer reactance(p.u)\n",
+ "P_i = 0.5 #Input power(p.u)\n",
+ "P_i_d = 0.8 #p.u\n",
+ "P_0 = 0.5 #Output power(p.u)\n",
+ "P = 0.5 #Power(p.u)\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "P_m = E*V/X_T #Amplitude of power angle curve(p.u)\n",
+ "delta_0 = math.asin(P_i/P_m) #Radians\n",
+ "delta = math.asin(P_i_d/P_m) #Radians\n",
+ "delta_m = math.pi-delta #Radians\n",
+ "A_acc = P_i_d*(delta-delta_0)-P_m*(math.cos(delta_0)-math.cos(delta)) #Possible area of accceleration\n",
+ "A_dec = P_m*(math.cos(delta)-math.cos(delta_m))-P_i_d*(delta_m-delta) #Possible area of deceleration\n",
+ "\n",
+ "#Result\n",
+ "if(A_acc < A_dec):\n",
+ " print('System is stable')\n",
+ " stability = A_dec/A_acc\n",
+ " print('Margin of stability = %.2f' %stability)\n",
+ "else:\n",
+ " print('System is not stable')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "System is stable\n",
+ "Margin of stability = 12.59\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 15.3, Page number 572-575"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find if system is stable & transient stability limit\n",
+ "\n",
+ "#Variable declaration\n",
+ "x = 0.25 #Transient reactance(p.u)\n",
+ "E = 1.0 #e.m.f of finite generator behind transient reactance(p.u)\n",
+ "x_T = 0.1 #Reactance of transformer(p.u)\n",
+ "x_L = 0.4 #Reactance of one line(p.u)\n",
+ "P_i = 0.25 #Pre-fault power(p.u)\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "X_T = x+x_T+(x_L/2) #Transfer reactance at pre-fault state(p.u)\n",
+ "P_m = E**2/X_T #Amplitude of power angle curve at pre-fault state(p.u)\n",
+ "X_T1 = 1.45 #Transfer reactance b/w finite generator & infinite bus at faulty state(p.u).Refer texbook problem for figure\n",
+ "P_m1 = E**2/X_T1 #Amplitude of power angle curve at faulty state(p.u)\n",
+ "r1 = X_T/X_T1\n",
+ "delta_0 = math.asin(P_i/P_m) #Radians\n",
+ "delta_1 = math.asin(P_i/(r1*P_m)) #Radians\n",
+ "delta_m = math.pi - delta_1 #Radians\n",
+ "from scipy.integrate import quad\n",
+ "\n",
+ "def integrand1(delta):\n",
+ " return r1*P_m*math.sin(delta)\n",
+ "a, err = quad(integrand1, delta_0, delta_1)\n",
+ "A_acc = P_i*(delta_1-delta_0) - a \n",
+ "\n",
+ "def integrand2(delta):\n",
+ " return r1*P_m*math.sin(delta)\n",
+ "b, err = quad(integrand2, delta_1, delta_m)\n",
+ "A_dec = b - P_i*(delta_m-delta_1)\n",
+ "limit = 0.5648 #Obtained by iterations.Refer textbook.Here assigned directly.\n",
+ "\n",
+ "#Result\n",
+ "if(A_acc < A_dec):\n",
+ " print('System is Stable')\n",
+ " stability = A_dec/A_acc\n",
+ " print('Margin of stability = %.2f' %stability)\n",
+ "else:\n",
+ " print('System is not stable')\n",
+ "print('Transient stability limit = %.4f p.u' %limit)\n",
+ "print('\\nNOTE : ERROR : angle delta_0 = 7.9\u00b0 = 0.13788 radian not 0.014 radian as in textbook')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "System is Stable\n",
+ "Margin of stability = 38.31\n",
+ "Transient stability limit = 0.5648 p.u\n",
+ "\n",
+ "NOTE : ERROR : angle delta_0 = 7.9\u00b0 = 0.13788 radian not 0.014 radian as in textbook\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 15.4, Page number 575-578"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find the stability of system & critical clearing time\n",
+ "\n",
+ "#Variable declaration\n",
+ "x = 0.25 #Transient reactance(p.u)\n",
+ "E = 1.0 #e.m.f of finite generator behind transient reactance(p.u)\n",
+ "x_T = 0.1 #Reactance of transformer(p.u)\n",
+ "x_L = 0.4 #Reactance of one line(p.u)\n",
+ "P_i = 0.7 #Pre-fault power(p.u)\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "X_T = x+x_T+(x_L/2) #Transfer reactance at pre-fault state(p.u)\n",
+ "P_m = E**2/X_T #Amplitude of power angle curve at pre-fault state(p.u)\n",
+ "X_T1 = 1.45 #Transfer reactance b/w finite generator & infinite bus at faulty state(p.u).Refer texbook problem for figure\n",
+ "P_m1 = E**2/X_T1 #Amplitude of power angle curve at faulty state(p.u)\n",
+ "r1 = X_T/X_T1\n",
+ "X_T2 = x+x_T+x_L #Transfer reactance for post fault state(p.u)\n",
+ "r2 = X_T/X_T2\n",
+ "P_m2 = r2*P_m\n",
+ "delta_0 = math.asin(P_i/P_m) #Radians\n",
+ "delta_1 = math.asin(P_i/(r2*P_m)) #Radians\n",
+ "delta_m = math.pi - delta_1 #Radians\n",
+ "delta_c = 0.7 #Specified value(radians)\n",
+ "from scipy.integrate import quad\n",
+ "\n",
+ "def integrand1(delta):\n",
+ " return r1*P_m*math.sin(delta)\n",
+ "a, err = quad(integrand1, delta_0, delta_c)\n",
+ "A_acc = P_i*(delta_c-delta_0) - a \n",
+ "\n",
+ "def integrand2(delta):\n",
+ " return r2*P_m*math.sin(delta)\n",
+ "b, err = quad(integrand2, delta_c, delta_m)\n",
+ "A_dec = b - P_i*(delta_m-delta_c)\n",
+ "cos_delta_cr = ((delta_m-delta_0)*math.sin(delta_0)-r1*math.cos(delta_0)+r2*math.cos(delta_m))/(r2-r1)\n",
+ "delta_cr = math.acos(cos_delta_cr)*180/math.pi\n",
+ "\n",
+ "#Result\n",
+ "if(A_acc < A_dec):\n",
+ " print('System is Stable')\n",
+ " stability = A_dec/A_acc\n",
+ " print('Margin of stability , K = %.2f' %stability)\n",
+ "else:\n",
+ " print('System is not stable')\n",
+ "print('Critical clearing angle for a certain pre-fault power = %.2f\u00b0' %delta_cr)\n",
+ "print('Critical clearing time will be known from circuit-breaker specifications')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "System is Stable\n",
+ "Margin of stability , K = 7.98\n",
+ "Critical clearing angle for a certain pre-fault power = 111.48\u00b0\n",
+ "Critical clearing time will be known from circuit-breaker specifications\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 15.5, Page number 578-580"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find critical clearing angle & time for circuit breaker at bus 1\n",
+ "\n",
+ "#Variable declaration\n",
+ "P_i = 0.75 #Pre-fault power(p.u)\n",
+ "f = 50.0 #Frequency(Hz)\n",
+ "H = 6.0 #Value of H for finite machine(sec)\n",
+ "x_G = 0.2 #Reactance of machine(p.u)\n",
+ "x_T = 0.1 #Reactance of transformer(p.u)\n",
+ "x_L = 0.4 #Reactance of line(p.u)\n",
+ "V = 1.0 #Voltage of infinite bus(p.u)\n",
+ "E = 1.0 #e.m.f of finite generator behind transient reactance(p.u)\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "X_T = x_G+x_T+(x_L) #Transfer reactance at pre-fault state(p.u)\n",
+ "P_m = E**2/X_T #Amplitude of power angle curve at pre-fault state(p.u)\n",
+ "delta_0 = math.asin(P_i/P_m) #Radians\n",
+ "delta_0a = delta_0*180/math.pi\n",
+ "delta_cr = math.acos((math.pi-2*delta_0)*math.sin(delta_0)-math.cos(delta_0))\n",
+ "delta_cra = delta_cr*180/math.pi\n",
+ "t_cr = ((delta_cra-delta_0a)*2*H/(180*f*P_i))**0.5\n",
+ "\n",
+ "#Result\n",
+ "print('Critical clearing angle for circuit breaker at bus 1 = %.2f\u00b0' %delta_cra)\n",
+ "print('Time for circuit breaker at bus 1 ,t_cr = %.3f sec' %t_cr)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Critical clearing angle for circuit breaker at bus 1 = 77.42\u00b0\n",
+ "Time for circuit breaker at bus 1 ,t_cr = 0.285 sec\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file diff --git a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_2_2.ipynb b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_2_2.ipynb new file mode 100644 index 00000000..1ac5ff1b --- /dev/null +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_2_2.ipynb @@ -0,0 +1,125 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "CHAPTER 2: FUNDAMENTAL CONCEPTS OF AC CIRCUITS"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 2.1, Page number 26-27"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find p.u current,active & reactive power,impedance\n",
+ "\n",
+ "#Variable declaration\n",
+ "MVA_base = 10.0 #Three-phase base MVA\n",
+ "kV_base = 13.8 #Line-line base kV\n",
+ "P = 7.0 #Power delivered(MW)\n",
+ "PF = 0.8 #Power factor lagging\n",
+ "Z = 5.7 #Impedance(ohm)\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "I_base = (MVA_base) * (10**3)/((3**(0.5)) * kV_base) #Base current(A)\n",
+ "I_actual = P * (10**3)/((3**(0.5)) * kV_base*PF) #Actual current delivered by machine(A)\n",
+ "I_pu = I_actual/I_base #p.u current(p.u)\n",
+ "Z_pu = Z * (MVA_base/( (kV_base)**2 )) #p.u impedance(p.u)\n",
+ "P_act_pu = P/MVA_base #p.u active power(p.u)\n",
+ "x = math.acos(PF)\n",
+ "y = math.sin(x)\n",
+ "P_react = (P * y)/PF #Actual reactive power(MVAR)\n",
+ "P_react_pu = P_react/MVA_base #Actual p.u reactive power(p.u)\n",
+ "\n",
+ "#Result\n",
+ "print('p.u current = %.3f p.u' %I_pu)\n",
+ "print('p.u impedance = %.1f p.u' %Z_pu)\n",
+ "print('p.u active power = %.1f p.u' %P_act_pu)\n",
+ "print('p.u reactive power = %.3f p.u' %P_react_pu)\n"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "p.u current = 0.875 p.u\n",
+ "p.u impedance = 0.3 p.u\n",
+ "p.u active power = 0.7 p.u\n",
+ "p.u reactive power = 0.525 p.u\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 2.2, Page number 27"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find base & actual impedance on l.v,h.v sides in ohm\n",
+ "\n",
+ "#Variable declaration\n",
+ "MVA_base = 5.0 #Base MVA on both sides\n",
+ "hv_base = 11.0 #Line to line base voltages in kV on h.v side\n",
+ "lv_base = 0.4 #Line to line base voltages in kV on l.v side\n",
+ "Z = 5.0/100 #Impedance of 5%\n",
+ "\n",
+ "#Calculation\n",
+ "Z_base_hv = (hv_base)**2/MVA_base #Base impedance on h.v side(ohm)\n",
+ "Z_base_lv = (lv_base)**2/MVA_base #Base impedance on l.v side(ohm)\n",
+ "Z_act_hv = Z * Z_base_hv #Actual impedance viewed from h.v side(ohm)\n",
+ "Z_act_lv = Z * Z_base_lv #Actual impedance viewed from l.v side(ohm)\n",
+ "\n",
+ "#Result\n",
+ "print('Base impedance on h.v side = %.1f ohm' %Z_base_hv)\n",
+ "print('Base impedance on l.v side = %.3f ohm' %Z_base_lv)\n",
+ "print('Actual impedance viewed from h.v side = %.2f ohm' %Z_act_hv)\n",
+ "print('Actual impedance viewed from l.v side = %.4f ohm' %Z_act_lv)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Base impedance on h.v side = 24.2 ohm\n",
+ "Base impedance on l.v side = 0.032 ohm\n",
+ "Actual impedance viewed from h.v side = 1.21 ohm\n",
+ "Actual impedance viewed from l.v side = 0.0016 ohm\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file diff --git a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_3_2.ipynb b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_3_2.ipynb new file mode 100644 index 00000000..a6c97b20 --- /dev/null +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_3_2.ipynb @@ -0,0 +1,101 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "CHAPTER 3: GENERAL CONSIDERATIONS OF TRANSMISSION AND DISTRIBUTION"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.1, Page number 42-43"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Compare size,volume,losses of conductor materials\n",
+ "\n",
+ "#Variable declaration\n",
+ "P = 5.0 #Power(MW)\n",
+ "pf = 0.8 #lagging power factor\n",
+ "d = 15.0 #Distance of line(km)\n",
+ "J = 4.0 #Current density(amp per mm^2)\n",
+ "r = 1.78*10**(-8) #Resistivity(ohm-m)\n",
+ "kV_1 = 11.0 #Permissible voltage level(kV)\n",
+ "kV_2 = 22.0 #Permissible voltage level(kV)\n",
+ "\n",
+ "#Calculation\n",
+ "#For 11 kV level\n",
+ "I_1 = (P*10**3)/((3)**(0.5) * (kV_1) * pf) #Load current(A)\n",
+ "area_1 = I_1/J #Cross-sectional area of the phase conductor(mm^2)\n",
+ "volume_1 = 3 * (area_1/10**6) * (d*10**3) #Volume of conductors material(m^3)\n",
+ "R_1 = r * (d*10**3)/(area_1 * (10**-6)) #Resistance per phase(ohm)\n",
+ "PL_1 = 3 * (I_1**2) * (R_1*10**(-3)) #Power loss(kW)\n",
+ "\n",
+ "#For 22 kV level\n",
+ "I_2 = (P*10**3)/((3)**(0.5) * (kV_2) * pf) #Load current(A)\n",
+ "area_2 = I_2/J #Cross-sectional area of the phase conductor(mm^2)\n",
+ "volume_2 = 3 * (area_2/10**6) * (d*10**3) #Volume of conductors material(m^3)\n",
+ "R_2 = r * (d*10**3)/(area_2 * (10**-6)) #Resistance per phase(ohm)\n",
+ "PL_2 = 3 * (I_2**2) * (R_2*10**(-3)) #Power loss(kW)\n",
+ "area_ch = (area_1-area_2)/area_1*100 #Change in area of 22kV level from 11 kV level(%)\n",
+ "vol_ch = (volume_1-volume_2)/volume_1*100 #Change in volume of 22kV level from 11 kV level(%)\n",
+ "loss_ch = (PL_1-PL_2)/PL_1*100 #Change in losses of 22kV level from 11 kV level(%)\n",
+ "\n",
+ "#Result\n",
+ "print('For 11 kV level :')\n",
+ "print('Cross-sectional area of the phase conductor = %d mm^2' %area_1)\n",
+ "print('Volume of conductors material = %.2f m^3' %volume_1)\n",
+ "print('Power loss = %.2f kW' %PL_1)\n",
+ "print('\\nFor 22 kV level :')\n",
+ "print('Cross-sectional area of the phase conductor = %d mm^2' %area_2)\n",
+ "print('Volume of conductors material = %.2f m^3' %volume_2)\n",
+ "print('Power loss = %.2f kW' %PL_2)\n",
+ "print('\\nConductor size has decreased by %.f percent in 22 kV level' %area_ch)\n",
+ "print('Conductor volume has decreased by %.f percent in 22 kV level' %vol_ch)\n",
+ "print('Conductor losses has decreased by %.f percent in 22 kV level' %loss_ch)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "For 11 kV level :\n",
+ "Cross-sectional area of the phase conductor = 82 mm^2\n",
+ "Volume of conductors material = 3.69 m^3\n",
+ "Power loss = 1051.04 kW\n",
+ "\n",
+ "For 22 kV level :\n",
+ "Cross-sectional area of the phase conductor = 41 mm^2\n",
+ "Volume of conductors material = 1.85 m^3\n",
+ "Power loss = 525.52 kW\n",
+ "\n",
+ "Conductor size has decreased by 50 percent in 22 kV level\n",
+ "Conductor volume has decreased by 50 percent in 22 kV level\n",
+ "Conductor losses has decreased by 50 percent in 22 kV level\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file diff --git a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_4_2.ipynb b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_4_2.ipynb new file mode 100644 index 00000000..87e5269f --- /dev/null +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_4_2.ipynb @@ -0,0 +1,1022 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "CHAPTER 4: ELECTRICAL CHARACTERISTICS, MODELLING AND PERFORMANCE OF AERIAL TRANSMISSION LINES"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.1, Page number 56-57"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find total loop inductance\n",
+ "\n",
+ "#Variable declaration\n",
+ "l = 10.0 #Length of 1-phase line(km)\n",
+ "d = 100.0 #Spacing b/w conductors(cm)\n",
+ "r = 0.3 #Radius(cm)\n",
+ "u_r_1 = 1.0 #Relative permeability of copper\n",
+ "u_r_2 = 100.0 #Relative permeability of steel\n",
+ "\n",
+ "#Calculation\n",
+ "#For copper\n",
+ "r_1 = 0.7788*r #Radius of hypothetical conductor(cm)\n",
+ "import math\n",
+ "L_1 = 4 * 10**(-7) * math.log(d/r_1) #Loop inductance(H/m)\n",
+ "L_T1 = L_1 * l * 10**6 #Total loop inductance(mH)\n",
+ "\n",
+ "#For steel\n",
+ "L_2 = 4 * 10**(-7) * (math.log(d/r) + (u_r_2/4))#Loop inductance(H/m)\n",
+ "L_T2 = L_2 * l * 10**6 #Total loop inductance(mH)\n",
+ "\n",
+ "#Result\n",
+ "print('(i) Total loop inductance of copper conductor = %.2f mH' %L_T1)\n",
+ "print('(ii)Total loop inductance of steel conductor = %.2f mH' %L_T2)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "(i) Total loop inductance of copper conductor = 24.24 mH\n",
+ "(ii)Total loop inductance of steel conductor = 123.24 mH\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.2, Page number 57-58"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Calculate inductance per km\n",
+ "\n",
+ "#Variable declaration\n",
+ "r = 0.4 #Radius of conductor(cm)\n",
+ "h = 1000 #Height of line(cm)\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "d = 2*h #Spacing between conductors(cm)\n",
+ "L = 2 * 10**(-4) * math.log(2*h/(0.7788*r)) * 1000 #Inductance of conductor(mH/km)\n",
+ "\n",
+ "#Result\n",
+ "print('Inductance of the conductor = %.3f mH/km' %L)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Inductance of the conductor = 1.753 mH/km\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.3, Page number 58"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find line inductance per phase per km\n",
+ "\n",
+ "#Variable declaration\n",
+ "d_ab = 4 #Distance b/w conductor a & b(m)\n",
+ "d_bc = 9 #Distance b/w conductor b & c(m)\n",
+ "d_ca = 6 #Distance b/w conductor c & a(m)\n",
+ "r = 1.0 #Radius of each conductor(cm)\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "D_m = (d_ab * d_bc * d_ca)**(1.0/3) #Geometric mean separation(m)\n",
+ "r_1 = 0.7788 * (r/100) #Radius of hypothetical conductor(m)\n",
+ "L = 2 * 10**(-7) * math.log(D_m/r_1) * 10**6 #Line inductance(mH/phase/km)\n",
+ "\n",
+ "#Result\n",
+ "print('Line inductance , L = %.2f mH/phase/km' %L)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Line inductance , L = 1.33 mH/phase/km\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.4, Page number 62-63"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find loop inductance per km\n",
+ "\n",
+ "#Variable declaration\n",
+ "r = 1.0 #Radius of each conductor(cm)\n",
+ "d_11 = 30 #Distance b/w conductor 1 & 1'(cm)\n",
+ "d_22 = 30 #Distance b/w conductor 2 & 2'(cm)\n",
+ "d_12 = 130 #Distance b/w conductor 1 & 2(cm)\n",
+ "d_122 = 160 #Distance b/w conductor 1 & 2'(cm)\n",
+ "d_112 = 100 #Distance b/w conductor 1' & 2(cm)\n",
+ "d_1122 = 130 #Distance b/w conductor 1' & 2'(cm)\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "r_1 = 0.7788 * r #Radius of hypothetical conductor(cm)\n",
+ "D_s = (d_11 * r_1 * d_22 * r_1)**(1.0/4) #Geometric mean radius(cm)\n",
+ "D_m = (d_12 * d_122 * d_112 * d_1122)**(1.0/4) #Geometric mean separation(cm)\n",
+ "L = 4 * 10**(-7) * math.log(D_m/D_s) * 10**6 #Loop inductance(mH/km)\n",
+ "\n",
+ "#Inductance of single phase system having 2 conductors only\n",
+ "R = 2**0.5 #Radius of single conductor(cm)\n",
+ "d = 130.0 #Conductor position(cm)\n",
+ "L_1 = 4*10**(-7)*math.log(d/(0.7788*R))*10**6 #Loop inductance(mH/km)\n",
+ "L_diff = (L_1 - L)/L*100 #Change in inductance(%)\n",
+ "r_diff = D_s - R #Effective radius difference\n",
+ "\n",
+ "#Result\n",
+ "print('Loop inductance , L = %.3f mH/km' %L)\n",
+ "print('Loop inductance having two conductors only , L = %.3f mH/km' %L_1)\n",
+ "print('There is an Increase of %.f percent in inductance value ' %L_diff)\n",
+ "print('Effective radius of bundled conductors is about %.1f times that of unbundled system reducing field stress almost by that ratio' %r_diff)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Loop inductance , L = 1.311 mH/km\n",
+ "Loop inductance having two conductors only , L = 1.908 mH/km\n",
+ "There is an Increase of 46 percent in inductance value \n",
+ "Effective radius of bundled conductors is about 3.4 times that of unbundled system reducing field stress almost by that ratio\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.5, Page number 63-64"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find inductance/phase/km\n",
+ "\n",
+ "#Variable declaration\n",
+ "r = 1.5 #Radius of each conductor(cm)\n",
+ "D_a1a2 = 0.3 #Distance b/w conductor a1 & a2(m)\n",
+ "D_a2a1 = 0.3 #Distance b/w conductor a2 & a1(m)\n",
+ "D_a1b1 = 15.3 #Distance b/w conductor a1 & b1(m)\n",
+ "D_a1b2 = 15.6 #Distance b/w conductor a1 & b2(m)\n",
+ "D_a2b1 = 15.0 #Distance b/w conductor a2 & b1(m)\n",
+ "D_a2b2 = 15.3 #Distance b/w conductor a2 & b2(m)\n",
+ "D_b1c1 = 15.3 #Distance b/w conductor b1 & c1(m)\n",
+ "D_b1c2 = 15.6 #Distance b/w conductor b1 & c2(m)\n",
+ "D_b2c1 = 15.0 #Distance b/w conductor b2 & c1(m)\n",
+ "D_b2c2 = 15.3 #Distance b/w conductor b2 & c2(m)\n",
+ "D_a1c1 = 30.6 #Distance b/w conductor a1 & c1(m)\n",
+ "D_a1c2 = 30.9 #Distance b/w conductor a1 & c2(m)\n",
+ "D_a2c1 = 30.3 #Distance b/w conductor a2 & c1(m)\n",
+ "D_a2c2 = 30.6 #Distance b/w conductor a2 & c2(m)\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "r_1 = 0.7788 * (r/100) #Radius of hypothetical conductor(m)\n",
+ "D_s = (D_a1a2 * r_1 * D_a2a1 * r_1)**(1.0/4) #Geometric mean radius(m)\n",
+ "D_ab = (D_a1b1 * D_a1b2 * D_a2b1 * D_a2b2)**(1.0/4) #Mutual GMD b/w conductor a & b(m)\n",
+ "D_bc = (D_b1c1 * D_b1c2 * D_b2c1 * D_b2c2)**(1.0/4) #Mutual GMD b/w conductor b & c(m)\n",
+ "D_ca = (D_a1c1 * D_a1c2 * D_a2c1 * D_a2c2)**(1.0/4) #Mutual GMD b/w conductor c & a(m)\n",
+ "D_m = (D_ab * D_bc * D_ca)**(1.0/3) #Geometric mean separation(m)\n",
+ "L = 2 * 10**(-4) * math.log(D_m/D_s) * 1000 #Inductance(mH/km)\n",
+ "\n",
+ "#Result\n",
+ "print('Inductance/phase/km = %.3f mH/km' %L)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Inductance/phase/km = 1.157 mH/km\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.7, Page number 74"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find capacitance & charging current\n",
+ "\n",
+ "#Variable declaration\n",
+ "r = 0.6 #Radius of each conductor(cm)\n",
+ "d = 150 #Separation distance(cm)\n",
+ "L = 40*10**3 #Length of overhead line(m)\n",
+ "f = 50 #Frequency(Hertz)\n",
+ "v = 50*10**3 #System voltage(V)\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "C_ab = (math.pi * 8.854 * 10**(-12))/(math.log(d/r)) * L #Capacitance b/w conductors(F)\n",
+ "I = complex(0,v * 2 * math.pi * f * C_ab) #Charging current leads voltage by 90\u00b0(A)\n",
+ "\n",
+ "#Result\n",
+ "print('Capacitance between two conductors , C_ab = %.3e F' %C_ab)\n",
+ "print('Charging current , I = j%.3f A' %I.imag)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Capacitance between two conductors , C_ab = 2.015e-07 F\n",
+ "Charging current , I = j3.165 A\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.8, Page number 74-75"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find capacitance per phase per km\n",
+ "\n",
+ "#Variable declaration\n",
+ "r = 0.015 #Radius of each conductor(m)\n",
+ "D_a1a2 = 0.3 #Distance b/w conductor a1 & a2(m)\n",
+ "D_a2a1 = 0.3 #Distance b/w conductor a2 & a1(m)\n",
+ "D_a1b1 = 15.3 #Distance b/w conductor a1 & b1(m)\n",
+ "D_a1b2 = 15.6 #Distance b/w conductor a1 & b2(m)\n",
+ "D_a2b1 = 15.0 #Distance b/w conductor a2 & b1(m)\n",
+ "D_a2b2 = 15.3 #Distance b/w conductor a2 & b2(m)\n",
+ "D_b1c1 = 15.3 #Distance b/w conductor b1 & c1(m)\n",
+ "D_b1c2 = 15.6 #Distance b/w conductor b1 & c2(m)\n",
+ "D_b2c1 = 15.0 #Distance b/w conductor b2 & c1(m)\n",
+ "D_b2c2 = 15.3 #Distance b/w conductor b2 & c2(m)\n",
+ "D_a1c1 = 30.6 #Distance b/w conductor a1 & c1(m)\n",
+ "D_a1c2 = 30.9 #Distance b/w conductor a1 & c2(m)\n",
+ "D_a2c1 = 30.3 #Distance b/w conductor a2 & c1(m)\n",
+ "D_a2c2 = 30.6 #Distance b/w conductor a2 & c2(m)\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "D_s = (D_a1a2 * r * D_a2a1 * r)**(1.0/4) #Geometric mean radius(m)\n",
+ "D_ab = (D_a1b1 * D_a1b2 * D_a2b1 * D_a2b2)**(1.0/4) #Mutual GMD b/w conductor a & b(m)\n",
+ "D_bc = (D_b1c1 * D_b1c2 * D_b2c1 * D_b2c2)**(1.0/4) #Mutual GMD b/w conductor b & c(m)\n",
+ "D_ca = (D_a1c1 * D_a1c2 * D_a2c1 * D_a2c2)**(1.0/4) #Mutual GMD b/w conductor c & a(m)\n",
+ "D_m = (D_ab * D_bc * D_ca)**(1.0/3) #Geometric mean separation(m)\n",
+ "C_n = 2 * math.pi * 8.854 * 10**(-9) /(math.log(D_m/D_s)) #Capacitance per phase(F/km)\n",
+ "\n",
+ "#Result\n",
+ "print('Capacitance per phase , C_n = %.3e F/km' %C_n)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Capacitance per phase , C_n = 9.828e-09 F/km\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.9, Page number 75"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find capacitance/phase/km\n",
+ "\n",
+ "#Variable declaration\n",
+ "r = 0.015 #Radius of each conductor(m)\n",
+ "D_ab = 15 #Horizontal distance b/w conductor a & b(m)\n",
+ "D_bc = 15 #Horizontal distance b/w conductor b & c(m)\n",
+ "D_ac = 30 #Horizontal distance b/w conductor a & c(m)\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "D_m = (D_ab * D_bc * D_ac)**(1.0/3) #Geometric mean separation(m)\n",
+ "D_s = 2**(1.0/2) * r #Geometric mean radius(m)\n",
+ "C_n = 2 * math.pi * 8.854 * 10**(-9) /(math.log(D_m/D_s)) #Capacitance/phase/km(F/km)\n",
+ "\n",
+ "#Result\n",
+ "print('Capacitance per phase , C_n = %.3e F/km' %C_n)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Capacitance per phase , C_n = 8.190e-09 F/km\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.11, Page number 79-80"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find line capacitance per km & compare\n",
+ "\n",
+ "#Variable declaration\n",
+ "h = 5 #Height of conductor above ground(m)\n",
+ "d = 1.5 #Conductor spacing(m)\n",
+ "r = 0.006 #Radius of conductor(m)\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "C_AB = math.pi * 8.854*10**-9/math.log(d/(r*(1+((d*d)/(4*h*h)))**0.5)) #Capacitance with effect of earth(F/km)\n",
+ "C_AB1 = math.pi * 8.854*10**-9/math.log(d/r) #Capacitance ignoring effect of earth(F/km)\n",
+ "ch = (C_AB - C_AB1)/C_AB * 100 #Change in capacitance with effect of earth(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Line capacitance with effect of earth , C_AB = %.3e F/km' %C_AB)\n",
+ "print('Line capacitance ignoring effect of earth , C_AB = %.3e F/km' %C_AB1)\n",
+ "print('With effect of earth slight increase in capacitance = %.1f percent' %ch)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Line capacitance with effect of earth , C_AB = 5.048e-09 F/km\n",
+ "Line capacitance ignoring effect of earth , C_AB = 5.038e-09 F/km\n",
+ "With effect of earth slight increase in capacitance = 0.2 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.12, Page number 87-88"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find sending end voltage,current,power factor & transmission loss\n",
+ "\n",
+ "#Variable declaration\n",
+ "R = 0.16 #Resistance(ohm)\n",
+ "L = 1.26*10**(-3) #Inductance(H)\n",
+ "C = 8.77*10**(-9) #Capacitance(F)\n",
+ "l = 200.0 #Length of line(km)\n",
+ "P = 50.0 #Power(MVA)\n",
+ "pf = 0.8 #Lagging power factor\n",
+ "V_r = 132000.0 #Receiving end voltage(V)\n",
+ "f = 50.0 #Frequency(Hz)\n",
+ "\n",
+ "#Calculation\n",
+ "#Step-I\n",
+ "import math\n",
+ "import cmath\n",
+ "w = 2 * math.pi * f\n",
+ "z = complex(R, w*L) #Series impedance per phase per km(ohm)\n",
+ "y = complex(0, w*C) #Shunt admittance per phase per km(mho)\n",
+ "\n",
+ "#Step-II\n",
+ "g = (y*z)**(0.5) #propagation constant(/km)\n",
+ "gl = g * l\n",
+ "Z_c = (z/y)**(0.5) #Surge impedance(ohm)\n",
+ "\n",
+ "#Step-III\n",
+ "cosh_gl = cmath.cosh(gl)\n",
+ "sinh_gl = cmath.sinh(gl)\n",
+ "\n",
+ "#Step-IV\n",
+ "A = cosh_gl\n",
+ "B = Z_c * sinh_gl\n",
+ "C = (sinh_gl/Z_c)\n",
+ "D = cosh_gl\n",
+ "\n",
+ "#Step-V\n",
+ "fi = math.acos(pf) #Power factor angle(radians)\n",
+ "V_R = V_r/(3**0.5) #Receiving end voltage(V)\n",
+ "I_R = (P*10**6/((3**0.5)*V_r))*(pf - complex(0,math.sin(fi)))#Receiving end current(A)\n",
+ "V_S = (A*V_R + B*I_R) #Sending end voltage(V/phase)\n",
+ "V_S_L = V_S * (3**0.5)*10**-3 #Sending end line voltage(kV)\n",
+ "I_S = C*V_R + D*I_R #Sending end current(A)\n",
+ "pf_S = math.cos(cmath.phase(I_S) - cmath.phase(V_S)) #Sending end power factor\n",
+ "P_S = abs(V_S*I_S)*pf_S*10**-6 #Sending end power/phase(MW)\n",
+ "P_R = (P/3)*pf #Receiving end power/phase(MW)\n",
+ "P_L = 3*(P_S - P_R) #Total line loss(MW)\n",
+ "\n",
+ "#Result\n",
+ "print('Sending end voltage , V_S = %.2f\u2220%.2f\u00b0 kV/phase' %(abs(V_S*10**-3),cmath.phase(V_S)*180/math.pi))\n",
+ "print('Sending end line voltage = %.2f kV' %abs(V_S_L))\n",
+ "print('Sending end current , I_S = %.2f\u2220%.2f\u00b0 A' %(abs(I_S),cmath.phase(I_S)*180/math.pi))\n",
+ "print('Sending end power factor = %.2f lagging' %pf_S)\n",
+ "print('Total transmission line loss = %.3f MW' %P_L)\n",
+ "print('\\nNOTE : Changes in answer is due to more decimal places')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Sending end voltage , V_S = 90.98\u22206.50\u00b0 kV/phase\n",
+ "Sending end line voltage = 157.58 kV\n",
+ "Sending end current , I_S = 192.08\u2220-26.31\u00b0 A\n",
+ "Sending end power factor = 0.84 lagging\n",
+ "Total transmission line loss = 4.062 MW\n",
+ "\n",
+ "NOTE : Changes in answer is due to more decimal places\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.13, Page number 90-91"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find values of equivalent pi network\n",
+ "\n",
+ "#Variable declaration\n",
+ "R = 0.1 #Resistance/phase/km(ohm)\n",
+ "D_m = 800.0 #Spacing b/w conductors(cm)\n",
+ "d = 1.5 #Diameter of each conductor(cm)\n",
+ "l = 300.0 #Length of transmission line(km)\n",
+ "f = 50.0 #Frequency(Hz)\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "import cmath\n",
+ "L = 2*10**(-4)*math.log(D_m*2/d) #Inductance/phase/km(H)\n",
+ "C = 2*math.pi*8.854*10**(-9)/math.log(D_m*2/d) #Capacitance/phase/km(F)\n",
+ "w = 2 * math.pi * f\n",
+ "z = complex(R, w*L) #Series impedance per phase per km(ohm/km)\n",
+ "y = complex(0, w*C) #Shunt admittance per phase per km(mho/km)\n",
+ "g = (y*z)**(0.5) #propagation constant(/km)\n",
+ "gl = g * l\n",
+ "Z_c = (z/y)**(0.5) #Surge impedance(ohm)\n",
+ "sinh_gl = cmath.sinh(gl)\n",
+ "tanh_gl = cmath.tanh(gl/2)\n",
+ "Z_S = Z_c * sinh_gl #Series impedance(ohm)\n",
+ "Y_P = (1/Z_c)*cmath.tanh(gl/2) #Pillar admittance(mho)\n",
+ "\n",
+ "#Result\n",
+ "print('Values of equivalent-pi network are :')\n",
+ "print('Series impedance , Z_S = (%.2f + j%.2f) ohm' %(Z_S.real,Z_S.imag))\n",
+ "print('Pillar admittance , Y_P = %.2e\u2220%.2f\u00b0 mho = j%.2e mho' %(abs(Y_P),(cmath.phase(Y_P)*180/math.pi),Y_P.imag))\n",
+ "print('\\nNOTE : Changes in answer is due to more decimal places')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Values of equivalent-pi network are :\n",
+ "Series impedance , Z_S = (29.02 + j129.38) ohm\n",
+ "Pillar admittance , Y_P = 3.79e-04\u222089.89\u00b0 mho = j3.79e-04 mho\n",
+ "\n",
+ "NOTE : Changes in answer is due to more decimal places\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.14, Page number 101-104"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find efficiency,regulation,reactive power at sending end & absorbed by line\n",
+ "\n",
+ "#Variable declaration\n",
+ "V_r = 220000.0 #Voltage(V)\n",
+ "P = 100.0 #Power(MW)\n",
+ "r = 0.08 #Series resistance(ohm)\n",
+ "x = 0.8 #Series reactance(ohm)\n",
+ "s = 6.0*10**(-6) #Shunt susceptance(mho)\n",
+ "pf = 0.8 #Power factor lagging\n",
+ "l_1 = 60.0 #Transmission length(km) for case(i)\n",
+ "l_2 = 200.0 #Transmission length(km) for case(ii)\n",
+ "l_3 = 300.0 #Transmission length(km) for case(iii)\n",
+ "l_4 = 500.0 #Transmission length(km) for case(iv)\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "import cmath\n",
+ "z = complex(r,x) #Series impedance/km(ohm)\n",
+ "y = complex(0,s) #Shunt admittance/km(mho)\n",
+ "theta_R = math.acos(pf)\n",
+ "P_R = P/3 #Active power at receiving end/phase(MW)\n",
+ "Q_R = (P/3)*math.tan(theta_R) #Reactive power at receiving end/phase(MVAR)\n",
+ "V_R = V_r/(3**0.5) #Receiving end voltage/phase(V)\n",
+ "I_R = P*10**6/((3**0.5)*V_r*pf)*(pf - complex(0,math.sin(theta_R)))#Receiving end current(A)\n",
+ "Z_c = (z/y)**(0.5) #Surge impedance(ohm)\n",
+ "\n",
+ "#case(i) - Short length line\n",
+ "A_1 = 1 #Constant A\n",
+ "B_1 = z*l_1 #Constant B(ohm)\n",
+ "C_1 = 0 #Constant C(mho)\n",
+ "D_1 = A_1 #Constant D\n",
+ "V_S_1 = A_1*V_R + B_1*I_R #Sending end voltage(V/phase)\n",
+ "I_S_1 = I_R #Sending end current(A)\n",
+ "theta_S_1 = cmath.phase(I_S_1) - cmath.phase(V_S_1) #Sending end power factor\n",
+ "P_S_1 = abs(V_S_1*I_S_1)*math.cos(theta_S_1)*10**-6 #Sending end power(MW)\n",
+ "n_1 = (P_R/P_S_1)*100 #Transmission efficiency(%)\n",
+ "reg_1 = (abs(V_S_1/A_1) - V_R)/V_R*100 #Regulation(%)\n",
+ "Q_S_1 = V_S_1 * I_S_1.conjugate()*10**-6 #Sending end reactive power(MVAR)\n",
+ "Q_line_1 = Q_S_1.imag - Q_R #Reactive power absorbed by line(MVAR)\n",
+ "\n",
+ "#case(ii) - Medium length line\n",
+ "Z_S_2 = z*l_2\n",
+ "Y_P_2 = y*l_2/2\n",
+ "A_2 = 1 + Y_P_2*Z_S_2\n",
+ "B_2 = Z_S_2\n",
+ "C_2 = Y_P_2*(2 + Y_P_2*Z_S_2)\n",
+ "D_2 = A_2\n",
+ "V_S_2 = A_2*V_R + B_2*I_R #Sending end voltage(V/phase) \n",
+ "I_S_2 = C_2*V_R + D_2*I_R #Sending end current(A)\n",
+ "S_S_2 = V_S_2*I_S_2.conjugate()*10**-6 #Sending end complex power(MVA)\n",
+ "P_S_2 = S_S_2.real #Power at sending end(MW)\n",
+ "n_2 = (P_R/P_S_2)*100 #Transmission efficiency(%)\n",
+ "reg_2 = (abs(V_S_2/A_2) - V_R)/V_R*100 #Regulation(%)\n",
+ "Q_line_2 = S_S_2.imag - Q_R #Reactive power absorbed by line(MVAR)\n",
+ "\n",
+ "#case(iii) - Long length line\n",
+ "g_3 = (y*z)**(0.5) #propagation constant(/km)\n",
+ "gl_3 = g_3 * l_3\n",
+ "cosh_gl_3 = cmath.cosh(gl_3)\n",
+ "sinh_gl_3 = cmath.sinh(gl_3)\n",
+ "A_3 = cosh_gl_3\n",
+ "B_3 = Z_c * sinh_gl_3\n",
+ "C_3 = sinh_gl_3/Z_c\n",
+ "D_3 = cosh_gl_3\n",
+ "V_S_3 = A_3*V_R + B_3*I_R #Sending end voltage(V/phase) \n",
+ "I_S_3 = C_3*V_R + D_3*I_R #Sending end current(A)\n",
+ "S_S_3 = V_S_3*I_S_3.conjugate()*10**-6 #Sending end complex power(MVA)\n",
+ "P_S_3 = S_S_3.real #Power at sending end(MW)\n",
+ "n_3 = (P_R/P_S_3)*100 #Transmission efficiency(%)\n",
+ "reg_3 = (abs(V_S_3/A_3) - V_R)/V_R*100 #Regulation(%)\n",
+ "Q_line_3 = S_S_3.imag - Q_R #Reactive power absorbed by line(MVAR)\n",
+ "\n",
+ "#case(iv) - Long length line\n",
+ "g_4 = (y*z)**(0.5) #propagation constant(/km)\n",
+ "gl_4 = g_4 * l_4\n",
+ "cosh_gl_4 = cmath.cosh(gl_4)\n",
+ "sinh_gl_4 = cmath.sinh(gl_4)\n",
+ "A_4 = cosh_gl_4\n",
+ "B_4 = Z_c * sinh_gl_4\n",
+ "C_4 = sinh_gl_4/Z_c\n",
+ "D_4 = cosh_gl_4\n",
+ "V_S_4 = A_4*V_R + B_4*I_R #Sending end voltage(V/phase) \n",
+ "I_S_4 = C_4*V_R + D_4*I_R #Sending end current(A)\n",
+ "S_S_4 = V_S_4*I_S_4.conjugate()*10**-6 #Sending end complex power(MVA)\n",
+ "P_S_4 = S_S_4.real #Power at sending end(MW)\n",
+ "n_4 = (P_R/P_S_4)*100 #Transmission efficiency(%)\n",
+ "reg_4 = (abs(V_S_4/A_4) - V_R)/V_R*100 #Regulation(%)\n",
+ "Q_line_4 = S_S_4.imag - Q_R #Reactive power absorbed by line(MVAR)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(i) : For Length = 60 km')\n",
+ "print('Efficiency , n = %.2f percent' %n_1)\n",
+ "print('Regulation = %.3f percent' %reg_1)\n",
+ "print('Reactive power at sending end , Q_S = %.2f MVAR' %Q_S_1.imag)\n",
+ "print('Reactive power absorbed by line , Q_line = %.2f MVAR' %Q_line_1)\n",
+ "print('\\nCase(ii) : For Length = 200 km')\n",
+ "print('Efficiency , n = %.2f percent' %n_2)\n",
+ "print('Regulation = %.2f percent' %reg_2)\n",
+ "print('Reactive power at sending end , Q_S = %.2f MVAR' %S_S_2.imag)\n",
+ "print('Reactive power absorbed by line , Q_line = %.2f MVAR' %Q_line_2)\n",
+ "print('\\nCase(iii) : For Length = 300 km')\n",
+ "print('Efficiency , n = %.2f percent' %n_3)\n",
+ "print('Regulation = %.2f percent' %reg_3)\n",
+ "print('Reactive power at sending end , Q_S = %.2f MVAR' %S_S_3.imag)\n",
+ "print('Reactive power absorbed by line , Q_line = %.2f MVAR' %Q_line_3)\n",
+ "print('\\nCase(iv) : For Length = 500 km')\n",
+ "print('Efficiency , n = %.2f percent' %n_4)\n",
+ "print('Regulation = %.2f percent' %reg_4)\n",
+ "print('Reactive power at sending end , Q_S = %.2f MVAR' %S_S_4.imag)\n",
+ "print('Reactive power absorbed by line , Q_line = %.2f MVAR' %Q_line_4)\n",
+ "print('\\nNOTE : ERROR : Calculation mistake in case(iv) efficiency in textbook')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(i) : For Length = 60 km\n",
+ "Efficiency , n = 98.47 percent\n",
+ "Regulation = 8.817 percent\n",
+ "Reactive power at sending end , Q_S = 30.17 MVAR\n",
+ "Reactive power absorbed by line , Q_line = 5.17 MVAR\n",
+ "\n",
+ "Case(ii) : For Length = 200 km\n",
+ "Efficiency , n = 96.15 percent\n",
+ "Regulation = 35.64 percent\n",
+ "Reactive power at sending end , Q_S = 14.11 MVAR\n",
+ "Reactive power absorbed by line , Q_line = -10.89 MVAR\n",
+ "\n",
+ "Case(iii) : For Length = 300 km\n",
+ "Efficiency , n = 95.14 percent\n",
+ "Regulation = 59.48 percent\n",
+ "Reactive power at sending end , Q_S = 2.70 MVAR\n",
+ "Reactive power absorbed by line , Q_line = -22.30 MVAR\n",
+ "\n",
+ "Case(iv) : For Length = 500 km\n",
+ "Efficiency , n = 92.85 percent\n",
+ "Regulation = 165.71 percent\n",
+ "Reactive power at sending end , Q_S = -19.25 MVAR\n",
+ "Reactive power absorbed by line , Q_line = -44.25 MVAR\n",
+ "\n",
+ "NOTE : ERROR : Calculation mistake in case(iv) efficiency in textbook\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.16, Page number 109-111"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find reactive VARs\n",
+ "\n",
+ "#Variable declaration\n",
+ "import math\n",
+ "import cmath\n",
+ "A = 0.8*cmath.exp(1j*1.4*math.pi/180) #Line constant\n",
+ "B = 326.0*cmath.exp(1j*84.8*math.pi/180) #Line constant(ohm)\n",
+ "V_R = 220.0 #Receiving end voltage(kV)\n",
+ "V_S = 220.0 #Sending end voltage(kV)\n",
+ "P = 75.0 #Power(MVA) for case(a)\n",
+ "pf = 0.8 #Power factor lagging\n",
+ "\n",
+ "#Calculation\n",
+ "a = cmath.phase(A) #Phase angle of A(radian)\n",
+ "b = cmath.phase(B) #Phase angle of B(radian)\n",
+ "\n",
+ "#Case(a)\n",
+ "P_R = P * pf #Active power demanded by load(MW)\n",
+ "P_React = P *(1-pf**2)**0.5 #Reactive power demanded by load(MVAR)\n",
+ "cos_b_delta_1 = P_R*abs(B)/(V_R*V_S) + abs(A)*math.cos(b-a) #cos(b-delta)[in radians]\n",
+ "delta_1 = b - math.acos(cos_b_delta_1) #delta(radians)\n",
+ "Q_R_1 = (V_R*V_S/abs(B))*math.sin(b-delta_1) - (abs(A)*V_R**2/abs(B))*math.sin(b-a) #Reactive power at sending end(MVAR)\n",
+ "Reactive_power_1 = P_React - Q_R_1 #Reactive power to be supplied by compensating equipment(MVAR)\n",
+ "\n",
+ "#Case(b)\n",
+ "cos_b_delta_2 = (abs(A)*V_R/V_S)*math.cos(b-a) #cos(b-delta)[in radians]\n",
+ "delta_2 = b - math.acos(cos_b_delta_2) #delta(radians)\n",
+ "Q_R_2 = (V_R*V_S/abs(B))*math.sin(b-delta_2) - (abs(A)*V_R**2/abs(B))*math.sin(b-a) #Reactive power at sending end(MVAR)\n",
+ "Reactive_power_2 = Q_R_2 #Reactive power to be absorbed by compensating equipment(MVAR)\n",
+ "\n",
+ "#Result\n",
+ "print('(a) Reactive VARs to be supplied by compensating equipment = %.2f MVAR' %Reactive_power_1)\n",
+ "print('(b) Reactive VARs to be absorbed by compensating equipment = %.2f MVAR' %Reactive_power_2)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "(a) Reactive VARs to be supplied by compensating equipment = 34.08 MVAR\n",
+ "(b) Reactive VARs to be absorbed by compensating equipment = 29.85 MVAR\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.17, Page number 111-112"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find rating of device & power factor\n",
+ "\n",
+ "#Variable declaration\n",
+ "r = 25.0 #Resistance/phase(ohm)\n",
+ "x = 90.0 #Reactance/phase(ohm)\n",
+ "V_S = 145.0 #Sending end voltage(kV)\n",
+ "V_R = 132.0 #Receiving end voltage(kV)\n",
+ "P_R_1 = 0 #Power(MW)\n",
+ "P_R_2 = 50.0 #Power(MW)\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "import cmath\n",
+ "A = 1.0*cmath.exp(1j*0*math.pi/180) #Line constant\n",
+ "B = complex(r,x) #Line constant(ohm)\n",
+ "a = cmath.phase(A) #Phase angle of A(radian)\n",
+ "b = cmath.phase(B) #Phase angle of B(radian)\n",
+ "\n",
+ "#No load condition\n",
+ "cos_b_delta_1 = (V_R/V_S)*math.cos(b-a)\n",
+ "delta_1 = b - math.acos(cos_b_delta_1)\n",
+ "Q_R_1 = (V_R*V_S/abs(B))*math.sin(b-delta_1) - (abs(A)*V_R**2/abs(B))*math.sin(b-a)\n",
+ "\n",
+ "#For 50 MW loading\n",
+ "cos_b_delta_2 = (P_R_2*abs(B)/(V_R*V_S))+(abs(A)*V_R/V_S)*math.cos(b-a)\n",
+ "delta_2 = (b - math.acos(cos_b_delta_2))\n",
+ "Q_R_2 = (V_R*V_S/abs(B))*math.sin(b-delta_2)-(abs(A)*V_R**2/abs(B))*math.sin(b-a) #Reactive power available at receiving end(MVAR)\n",
+ "Q_S_2 = Q_R_1 + Q_R_2 #Reactive power to be supplied by equipment(MVAR)\n",
+ "pf = math.cos(math.atan(Q_S_2/P_R_2)) #Power factor\n",
+ "\n",
+ "#Result\n",
+ "print('Rating of device = %.2f MVAR' %Q_R_1)\n",
+ "print('Power factor = %.2f lagging' %pf)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Rating of device = 19.00 MVAR\n",
+ "Power factor = 0.94 lagging\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.18, Page number 112-114"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find rating,power angle,maximum power,reactive power & efficiency\n",
+ "\n",
+ "#Variable declaration\n",
+ "import math\n",
+ "import cmath\n",
+ "A = 0.9*cmath.exp(1j*1.0*math.pi/180) #Line constant\n",
+ "B = 143.0*cmath.exp(1j*84.5*math.pi/180) #Line constant(ohm)\n",
+ "V_R = 220.0 #Receiving end voltage(kV)\n",
+ "V_S = 240.0 #Sending end voltage(kV)\n",
+ "P = 100.0 #Power(MVA)\n",
+ "pf = 0.8 #Power factor lagging\n",
+ "\n",
+ "#Calculation\n",
+ "a = cmath.phase(A) #Phase angle of A(radian)\n",
+ "b = cmath.phase(B) #Phase angle of B(radian)\n",
+ "\n",
+ "#Case(a)\n",
+ "P_R = P * pf #Active power at receiving end(MW)\n",
+ "cos_b_delta = (P_R*abs(B)/(V_R*V_S))+(abs(A)*V_R/V_S)*math.cos(b-a) #cos(b-delta)[in radians]\n",
+ "delta_1 = (b - math.acos(cos_b_delta))\n",
+ "Q_R = (V_R*V_S/abs(B))*math.sin(b-delta_1)-(abs(A)*V_R**2/abs(B))*math.sin(b-a) #Reactive power at receiving end(MVAR)\n",
+ "P_Re = P *(1-pf**2)**0.5 #Reactive power(MVAR)\n",
+ "rating = P_Re - Q_R #Rating of phase modifier(MVAR)\n",
+ "\n",
+ "#Case(b)\n",
+ "delta_2 = b #Maximum power is received when delta = b\n",
+ "P_Rmax = (V_R*V_S/abs(B))-(abs(A)*V_R**2/abs(B))*math.cos(b-a) #Maximum power at receiving end(MW)\n",
+ "Q_R = -(abs(A/B)*V_R**2)*math.sin(b-a) #Reactive power at receive end(MVAR)\n",
+ "P_S = (V_S**2*abs(A/B))*math.cos(b-a)-(V_S*V_R/abs(B))*math.cos(b+delta_2) #Sending end power(MW)\n",
+ "n_line = (P_Rmax/P_S)*100 #Line efficiency(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a) :')\n",
+ "print('Rating of phase modifier = %.3f MVAR' %rating)\n",
+ "print('Power angle , delta = %.2f\u00b0' %(delta_1*180/math.pi))\n",
+ "print('\\nCase(b) :')\n",
+ "print('Maximum power at receive end , P_Rmax = %.2f MW' %P_Rmax)\n",
+ "print('Reactive power available , Q_R = %.2f MVAR' %Q_R)\n",
+ "print('Line efficiency = %.2f percent' %n_line)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a) :\n",
+ "Rating of phase modifier = 11.623 MVAR\n",
+ "Power angle , delta = 12.56\u00b0\n",
+ "\n",
+ "Case(b) :\n",
+ "Maximum power at receive end , P_Rmax = 334.75 MW\n",
+ "Reactive power available , Q_R = -302.66 MVAR\n",
+ "Line efficiency = 82.96 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 4.19, Page number 114-115"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find active power,reactive power & efficiency\n",
+ "\n",
+ "#Variable declaration\n",
+ "import math\n",
+ "import cmath\n",
+ "A = 0.96*cmath.exp(1j*1.0*math.pi/180) #Line constant\n",
+ "B = 100.0*cmath.exp(1j*83.0*math.pi/180) #Line constant(ohm)\n",
+ "V_R = 110.0 #Receiving end voltage(kV)\n",
+ "V_S = 110.0 #Sending end voltage(kV)\n",
+ "pf = 0.8 #Power factor lagging\n",
+ "delta = 15*math.pi/180 #Power angle(radians)\n",
+ "\n",
+ "#Calculation\n",
+ "a = cmath.phase(A) #Phase angle of A(radian)\n",
+ "b = cmath.phase(B) #Phase angle of B(radian)\n",
+ "\n",
+ "#Case(i)\n",
+ "P_R = (V_R*V_S/abs(B))*math.cos(b-delta) - (abs(A/B)*V_R**2)*math.cos(b-a) #Active power at receiving end(MW)\n",
+ "Q_RL = P_R*math.tan(math.acos(pf)) #Reactive power demanded by load(MVAR)\n",
+ "\n",
+ "#Case(ii)\n",
+ "Q_R = (V_R*V_S/abs(B))*math.sin(b-delta) - (abs(A/B)*V_R**2)*math.sin(b-a) #Reactive power(MVAR)\n",
+ "rating = Q_RL - Q_R #Rating of device(MVAR)\n",
+ "\n",
+ "#Case(iii)\n",
+ "P_S = (V_S**2*abs(A/B))*math.cos(b-a) - (V_R*V_S/abs(B))*math.cos(b+delta) #Sending end active power(MW)\n",
+ "n_line = (P_R/P_S)*100 #Efficiency of line(%)\n",
+ "\n",
+ "#Case(iv)\n",
+ "Q_S = (V_S**2*abs(A/B))*math.sin(b-a) - (V_R*V_S/abs(B))*math.sin(b+delta) #Sending end reactive power(MVAR)\n",
+ "\n",
+ "#Result\n",
+ "print('(i) Active power demanded by load , P_R = %.2f MW' %P_R)\n",
+ "print(' Reactive power demanded by load , Q_RL = %.2f MVAR' %Q_RL)\n",
+ "print('(ii) Rating of the device , Q_R = %.2f MVAR' %rating)\n",
+ "print('(iii)Efficiency of line = %.2f percent' %n_line)\n",
+ "print('(iv) Reactive power supplied by source and line , Q_S = %.2f MVAR' %Q_S)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "(i) Active power demanded by load , P_R = 29.16 MW\n",
+ " Reactive power demanded by load , Q_RL = 21.87 MVAR\n",
+ "(ii) Rating of the device , Q_R = 24.71 MVAR\n",
+ "(iii)Efficiency of line = 88.35 percent\n",
+ "(iv) Reactive power supplied by source and line , Q_S = -4.79 MVAR\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file diff --git a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_5_2.ipynb b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_5_2.ipynb new file mode 100644 index 00000000..52614bb8 --- /dev/null +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_5_2.ipynb @@ -0,0 +1,676 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "CHAPTER 5: OVERHEAD LINE CONSTRUCTION"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 5.1, Page number 136-138"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find sag\n",
+ "\n",
+ "#Variable declaration\n",
+ "L = 250.0 #Span(m)\n",
+ "d = 1.1*10**-2 #Conductor diameter(m)\n",
+ "w = 0.650*9.81 #Conductor weight(N/m)\n",
+ "bl = 7000.0 #Breaking load(kg)\n",
+ "sf = 2 #Safety factor\n",
+ "P_w_2 = 350.0 #Wind pressure(N/m^2) for case(ii)\n",
+ "P_w_3 = 400.0 #Wind pressure(N/m^2) for case(iii)\n",
+ "t_3 = 10.0**-2 #Thickness of ice covering(m) for case(iii)\n",
+ "w_ice = 915.0 #Ice weight(kg/m^3)\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "T_0 = (bl/sf)*9.81 #Allowable tension(N)\n",
+ "\n",
+ "#Case(i)\n",
+ "S_1 = (T_0/w)*(math.cosh(w*L/(2*T_0))-1) #Sag(m)\n",
+ "S_1_1 = (w*L**2)/(8*T_0) #Sag using parabolic equation(m)\n",
+ "\n",
+ "#Case(ii)\n",
+ "F_w_2 = P_w_2 * d #Wind force(N/m)\n",
+ "w_t_2 = (w**2 + F_w_2**2)**0.5 #Total force on conductor(N/m)\n",
+ "S_2 = (T_0/w_t_2)*(math.cosh(w_t_2*L/(2*T_0))-1) #Sag(m)\n",
+ "S_2_2 = w_t_2*L**2/(8*T_0) #Sag using parabolic equation(m)\n",
+ "alpha_2 = math.atan(F_w_2/w) #w_t inclined vertical angle(radians)\n",
+ "S_v_2 = S_2 * math.cos(alpha_2) #Vertical component of sag(m)\n",
+ "\n",
+ "#Case(iii)\n",
+ "D_3 = d + 2*t_3 #Diameter of conductor with ice(m)\n",
+ "F_w_3 = P_w_3 * D_3 #Wind force(N/m)\n",
+ "w_ice_3 = (math.pi/4)*(D_3**2 - d**2)*w_ice*9.81 #Weight of ice(N/m)\n",
+ "w_t_3 = ((w+w_ice_3)**2 + F_w_3**2)**0.5 #Total force on conductor(N/m)\n",
+ "S_3 = (T_0/w_t_3)*(math.cosh(w_t_3*L/(2*T_0))-1) #Sag(m)\n",
+ "S_3_3 = w_t_3*L**2/(8*T_0) #Sag using parabolic equation(m)\n",
+ "alpha_3 = math.atan(F_w_3/(w+w_ice_3)) #w_t inclined vertical angle(radians)\n",
+ "S_v_3 = S_3 * math.cos(alpha_3) #Vertical component of sag(m)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(i) :')\n",
+ "print('Sag using catenary equation = %.4f m ' %S_1)\n",
+ "print('Sag using parabolic equation = %.4f m \\n' %S_1_1)\n",
+ "print('Case(ii) :')\n",
+ "print('Sag using catenary equation = %.4f m ' %S_2)\n",
+ "print('Sag using parabolic equation = %.4f m ' %S_2_2)\n",
+ "print('Vertical component of sag = %.2f m \\n' %S_v_2)\n",
+ "print('Case(iii) :')\n",
+ "print('Sag using catenary equation = %.4f m ' %S_3)\n",
+ "print('Sag using parabolic equation = %.4f m ' %S_3_3)\n",
+ "print('Vertical component of sag = %.3f m \\n' %S_v_3)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(i) :\n",
+ "Sag using catenary equation = 1.4510 m \n",
+ "Sag using parabolic equation = 1.4509 m \n",
+ "\n",
+ "Case(ii) :\n",
+ "Sag using catenary equation = 1.6949 m \n",
+ "Sag using parabolic equation = 1.6948 m \n",
+ "Vertical component of sag = 1.45 m \n",
+ "\n",
+ "Case(iii) :\n",
+ "Sag using catenary equation = 3.9752 m \n",
+ "Sag using parabolic equation = 3.9738 m \n",
+ "Vertical component of sag = 2.799 m \n",
+ "\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 5.2, Page number 138"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find sag & height of lowest cross arm\n",
+ "\n",
+ "#Variable declaration\n",
+ "w = 0.85 #Weight of overhead line(kg/m)\n",
+ "T_0 = 3.5*10**4 #Maximum allowable tension(N)\n",
+ "L_1 = 160.0 #Span(m) for case(i)\n",
+ "L_2 = 200.0 #Span(m) for case(ii)\n",
+ "L_3 = 250.0 #Span(m) for case(iii)\n",
+ "L_4 = 275.0 #Span(m) for case(iv)\n",
+ "g_c = 7.1 #Minimum ground clearance(m)\n",
+ "L_S = 1.5 #Length of suspension insulator string\n",
+ "\n",
+ "#Calculation\n",
+ "w1 = w * 9.81 #Weight(N/m)\n",
+ "\n",
+ "#Case(i)\n",
+ "S_1 = w1*L_1**2/(8*T_0) #Sag(m)\n",
+ "H_1 = g_c + S_1 + L_S #Height of lowest cross-arm(m)\n",
+ "\n",
+ "#Case(ii)\n",
+ "S_2 = w1*L_2**2/(8*T_0) #Sag(m)\n",
+ "H_2 = g_c + S_2 + L_S #Height of lowest cross-arm(m)\n",
+ "\n",
+ "#Case(iii)\n",
+ "S_3 = w1*L_3**2/(8*T_0) #Sag(m)\n",
+ "H_3 = g_c + S_3 + L_S #Height of lowest cross-arm(m)\n",
+ "\n",
+ "#Case(iv)\n",
+ "S_4 = w1*L_4**2/(8*T_0) #Sag(m)\n",
+ "H_4 = g_c + S_4 + L_S #Height of lowest cross-arm(m)\n",
+ "\n",
+ "#Result\n",
+ "print('Span in meters\\t %d\\t %d\\t %d\\t %d' %(L_1,L_2,L_3,L_4))\n",
+ "print('Sag in meters\\t %.3f\\t %.3f\\t %.3f\\t %.3f' %(S_1,S_2,S_3,S_4))\n",
+ "print('Height of lowest cross-arm in meters\\t %.3f\\t %.3f\\t %.3f\\t %.3f' %(H_1,H_2,H_3,H_4))\n",
+ "print('\\nNOTE : ERROR : For finding height of lowest cross arm the length of insulation string is not considered in textbook calculation')\n",
+ "print('although it is mentioned in formula. Since length of insulation string is taken here there is a difference in answers from that of given in textbook')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Span in meters\t 160\t 200\t 250\t 275\n",
+ "Sag in meters\t 0.762\t 1.191\t 1.861\t 2.252\n",
+ "Height of lowest cross-arm in meters\t 9.362\t 9.791\t 10.461\t 10.852\n",
+ "\n",
+ "NOTE : ERROR : For finding height of lowest cross arm the length of insulation string is not considered in textbook calculation\n",
+ "although it is mentioned in formula. Since length of insulation string is taken here there is a difference in answers from that of given in textbook\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 5.3, Page number 138-139"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find minimum clearance & sag\n",
+ "\n",
+ "#Variable declaration\n",
+ "w = 0.63 #Weight of conductor(kg/m)\n",
+ "T_0 = 1350.0 #Maximum allowable load(kg)\n",
+ "h_1 = 20.0 #Height of first tower(m)\n",
+ "h_2 = 15.0 #Height of second tower(m)\n",
+ "L = 240.0 #Span(m)\n",
+ "\n",
+ "#Calculation\n",
+ "h = h_1 - h_2 #Difference in levels of towers(m)\n",
+ "L_1 = (L/2)+(T_0*h/(w*L)) #Horizontal distance from higher support(m)\n",
+ "L_2 = (L/2)-(T_0*h/(w*L)) #Horizontal distance from lower support(m)\n",
+ "S_1 = w*L_1**2/(2*T_0) #Sag from upper support(m)\n",
+ "S_2 = w*L_2**2/(2*T_0) #Sag from lower support(m)\n",
+ "clearance = (h_1 - S_1) #Minimum clearance(m)\n",
+ "\n",
+ "#Result\n",
+ "print('Minimum clearance between a line conductor & water surface = %.3f m' %clearance)\n",
+ "print('Sag from upper support = %.3f m' %S_1)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Minimum clearance between a line conductor & water surface = 13.675 m\n",
+ "Sag from upper support = 6.325 m\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 5.5, Page number 160"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find voltage across each disc & string efficiency\n",
+ "\n",
+ "#Variable declaration\n",
+ "n = 3 #Number of discs\n",
+ "m = 0.1 #capacitance of each link pin to self capacitance\n",
+ "V = 33.0 #Voltage(kV)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(i)\n",
+ "a_1 = 1\n",
+ "a_2 = (1 + m)*a_1\n",
+ "a_3 = m*(a_1 + a_2) + a_2\n",
+ "v_1 = V/(a_1 + a_2 + a_3) #Voltage across top unit(kV)\n",
+ "v_2 = a_2 * v_1 #Voltage across middle unit(kV)\n",
+ "v_3 = a_3 * v_1 #Voltage across bottom unit(kV)\n",
+ "s_v_1 = (v_1/V)*100 #Voltage across top unit to string voltage(%)\n",
+ "s_v_2 = (v_2/V)*100 #Voltage across middle unit to string voltage(%)\n",
+ "s_v_3 = (v_3/V)*100 #Voltage across bottom unit to string voltage(%)\n",
+ "\n",
+ "#Case(ii)\n",
+ "efficiency = V*100/(3*v_3) #String efficiency(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(i) :')\n",
+ "print('Voltage across top unit , v_1 = %.3f kV' %v_1)\n",
+ "print('Voltage across middle unit , v_2 = %.3f kV' %v_2)\n",
+ "print('Voltage across bottom unit , v_3 = %.3f kV' %v_3)\n",
+ "print('Voltage across top unit as a percentage of string voltage , v_1/V = %.1f percent' %s_v_1)\n",
+ "print('Voltage across middle unit as a percentage of string voltage , v_2/V = %.1f percent' %s_v_2)\n",
+ "print('Voltage across bottom unit as a percentage of string voltage , v_3/V = %.1f percent' %s_v_3)\n",
+ "print('\\nCase(ii) :')\n",
+ "print('String efficiency = %.2f percent' %efficiency)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(i) :\n",
+ "Voltage across top unit , v_1 = 9.677 kV\n",
+ "Voltage across middle unit , v_2 = 10.645 kV\n",
+ "Voltage across bottom unit , v_3 = 12.677 kV\n",
+ "Voltage across top unit as a percentage of string voltage , v_1/V = 29.3 percent\n",
+ "Voltage across middle unit as a percentage of string voltage , v_2/V = 32.3 percent\n",
+ "Voltage across bottom unit as a percentage of string voltage , v_3/V = 38.4 percent\n",
+ "\n",
+ "Case(ii) :\n",
+ "String efficiency = 86.77 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 5.6, Page number 160-161"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find voltage across each disc & system voltage\n",
+ "\n",
+ "#Variable declaration\n",
+ "n = 8 #Number of discs\n",
+ "m = 1.0/6 #capacitance of each link pin to self capacitance\n",
+ "V = 30.0 #Voltage(kV)\n",
+ "\n",
+ "#Calculation\n",
+ "#Case(i)\n",
+ "a_1 = 1\n",
+ "a_2 = (1+m)*a_1\n",
+ "a_3 = m*(a_1+a_2)+a_2\n",
+ "a_4 = m*(a_1+a_2+a_3)+a_3\n",
+ "a_5 = m*(a_1+a_2+a_3+a_4)+a_4\n",
+ "a_6 = m*(a_1+a_2+a_3+a_4+a_5)+a_5\n",
+ "a_7 = m*(a_1+a_2+a_3+a_4+a_5+a_6)+a_6\n",
+ "a_8 = m*(a_1+a_2+a_3+a_4+a_5+a_6+a_7)+a_7\n",
+ "v_1 = V/(a_1+a_2+a_3+a_4+a_5+a_6+a_7+a_8) #Voltage across unit 1(kV)\n",
+ "v_2 = a_2*v_1 #Voltage across unit 2(kV)\n",
+ "v_3 = a_3*v_1 #Voltage across unit 3(kV)\n",
+ "v_4 = a_4*v_1 #Voltage across unit 4(kV)\n",
+ "v_5 = a_5*v_1 #Voltage across unit 5(kV)\n",
+ "v_6 = a_6*v_1 #Voltage across unit 6(kV)\n",
+ "v_7 = a_7*v_1 #Voltage across unit 7(kV)\n",
+ "v_8 = a_8*v_1 #Voltage across unit 8(kV)\n",
+ "s_v_1 = v_1/V*100 #Voltage across unit 1 as a % of V\n",
+ "s_v_2 = v_2/V*100 #Voltage across unit 2 as a % of V\n",
+ "s_v_3 = v_3/V*100 #Voltage across unit 3 as a % of V\n",
+ "s_v_4 = v_4/V*100 #Voltage across unit 4 as a % of V\n",
+ "s_v_5 = v_5/V*100 #Voltage across unit 5 as a % of V\n",
+ "s_v_6 = v_6/V*100 #Voltage across unit 6 as a % of V\n",
+ "s_v_7 = v_7/V*100 #Voltage across unit 7 as a % of V\n",
+ "s_v_8 = v_8/V*100 #Voltage across unit 8 as a % of V\n",
+ "\n",
+ "#Case(ii)\n",
+ "V_2 = V*100/s_v_8\n",
+ "V_sys = (3**0.5)*V_2 #Permissible system voltage(kV)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(i) :')\n",
+ "print('____________________________________________________________________________________________')\n",
+ "print('Unit number 1 2 3 4 5 6 7 8\\n')\n",
+ "print('Percentage of conductor voltage %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f' %(s_v_1,s_v_2,s_v_3,s_v_4,s_v_5,s_v_6,s_v_7,s_v_8))\n",
+ "print('____________________________________________________________________________________________')\n",
+ "print('\\nCase(ii) :')\n",
+ "print('System voltage at which this string can be used = %.2f kV' %V_sys)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(i) :\n",
+ "____________________________________________________________________________________________\n",
+ "Unit number 1 2 3 4 5 6 7 8\n",
+ "\n",
+ "Percentage of conductor voltage 3.26 3.80 4.98 6.98 10.15 15.01 22.37 33.46\n",
+ "____________________________________________________________________________________________\n",
+ "\n",
+ "Case(ii) :\n",
+ "System voltage at which this string can be used = 155.29 kV\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 5.7, Page number 161-162"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find string efficiency & safety factor\n",
+ "\n",
+ "#Variable declaration\n",
+ "v_dry = 65.0 #Dry power frequency flashover voltage for each disc(kV)\n",
+ "v_wet = 43.0 #Wet power frequency flashover voltage for each disc(kV)\n",
+ "V = 110 #Voltage of system to be insulated(kV)\n",
+ "m = 1.0/6 #capacitance of each link pin to self capacitance\n",
+ "n_4 = 4 #Number of units in a string\n",
+ "n_8 = 8 #Number of units in a string\n",
+ "n_10 = 10 #Number of units in a string\n",
+ "v_dry_4 = 210.0 #Dry power frequency flashover voltage for 4 units(kV)\n",
+ "v_dry_8 = 385.0 #Dry power frequency flashover voltage for 8 units(kV)\n",
+ "v_dry_10 = 460.0 #Dry power frequency flashover voltage for 10 units(kV)\n",
+ "v_wet_4 = 150.0 #Wet power frequency flashover voltage for 4 units(kV)\n",
+ "v_wet_8 = 285.0 #Wet power frequency flashover voltage for 8 units(kV)\n",
+ "v_wet_10 = 345.0 #Wet power frequency flashover voltage for 10 units(kV)\n",
+ "\n",
+ "#Calculation\n",
+ "#For case(i)\n",
+ "eff_dry_4 = v_dry_4*100/(n_4*v_dry)\n",
+ "eff_dry_8 = v_dry_8*100/(n_8*v_dry)\n",
+ "eff_dry_10 = v_dry_10*100/(n_10*v_dry)\n",
+ "eff_wet_4 = v_wet_4*100/(n_4*v_wet)\n",
+ "eff_wet_8 = v_wet_8*100/(n_8*v_wet)\n",
+ "eff_wet_10 = v_wet_10*100/(n_10*v_wet)\n",
+ "\n",
+ "#For case(ii)\n",
+ "a_1 = 1\n",
+ "a_2 = (1+m)*a_1\n",
+ "a_3 = m*(a_1+a_2)+a_2\n",
+ "a_4 = m*(a_1+a_2+a_3)+a_3\n",
+ "a_5 = m*(a_1+a_2+a_3+a_4)+a_4\n",
+ "a_6 = m*(a_1+a_2+a_3+a_4+a_5)+a_5\n",
+ "a_7 = m*(a_1+a_2+a_3+a_4+a_5+a_6)+a_6\n",
+ "a_8 = m*(a_1+a_2+a_3+a_4+a_5+a_6+a_7)+a_7\n",
+ "v_1 = V/(a_1+a_2+a_3+a_4+a_5+a_6+a_7+a_8) #Voltage across unit 1(kV)\n",
+ "v_8 = a_8*v_1 #Voltage across unit 8(kV)\n",
+ "s_v_8 = v_8/V #Ratio of Voltage across unit 8 to string voltage\n",
+ "voltage_2 = V/(3**0.5)*s_v_8 #Voltage across the disc adjacent to conductor(kV)\n",
+ "sf_dry = v_dry/voltage_2 #Factor of safety for dry flashover\n",
+ "sf_wet = v_wet/voltage_2 #Factor of safety for wet flashover\n",
+ "\n",
+ "#Result\n",
+ "print('Case(i) :')\n",
+ "print('___________________________________________________________________________')\n",
+ "print(' No. of units Dry string efficiency(%) Wet string efficiency(%)')\n",
+ "print('___________________________________________________________________________')\n",
+ "print(' %d %.2f %.2f ' %(n_4,eff_dry_4,eff_wet_4))\n",
+ "print(' %d %.2f %.2f ' %(n_8,eff_dry_8,eff_wet_8))\n",
+ "print(' %d %.2f %.2f ' %(n_10,eff_dry_10,eff_wet_10))\n",
+ "print('___________________________________________________________________________')\n",
+ "print('\\nCase(ii) :')\n",
+ "print('Factor of safety for dry flashover = %.2f' %sf_dry)\n",
+ "print('Factor of safety for wet flashover = %.2f' %sf_wet)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(i) :\n",
+ "___________________________________________________________________________\n",
+ " No. of units Dry string efficiency(%) Wet string efficiency(%)\n",
+ "___________________________________________________________________________\n",
+ " 4 80.77 87.21 \n",
+ " 8 74.04 82.85 \n",
+ " 10 70.77 80.23 \n",
+ "___________________________________________________________________________\n",
+ "\n",
+ "Case(ii) :\n",
+ "Factor of safety for dry flashover = 3.06\n",
+ "Factor of safety for wet flashover = 2.02\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 5.8, Page number 163"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find conductor voltage & string efficiency\n",
+ "\n",
+ "#Variable declaration\n",
+ "n = 4 #Number of disc\n",
+ "v_2 = 13.2 #Voltage across second unit(kV)\n",
+ "v_3 = 18.0 #Voltage across third unit(kV)\n",
+ "\n",
+ "#Calculation\n",
+ "m = 0.198 #Obtained by solving the quadratic equation\n",
+ "a_1 = 1\n",
+ "a_2 = 1+m\n",
+ "a_3 = m*(a_1+a_2)+a_2\n",
+ "a_4 = m*(a_1+a_2+a_3)+a_3\n",
+ "v_1 = v_2/a_2 #Voltage across first unit(kV)\n",
+ "v_4 = a_4*v_1 #Voltage across second unit(kV)\n",
+ "V = v_1+v_2+v_3+v_4 #Conductor voltage(kV)\n",
+ "efficiency = V/(n*v_4)*100 #String efficiency(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Conductor voltage with respect to the cross-arm , V = %.2f kV' %V)\n",
+ "print('String efficiency = %.2f percent' %efficiency)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Conductor voltage with respect to the cross-arm , V = 68.57 kV\n",
+ "String efficiency = 65.05 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 5.9, Page number 164-165"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find voltage distribution\n",
+ "\n",
+ "#Variable declaration\n",
+ "n = 3 #Number of disc\n",
+ "\n",
+ "#Calculation\n",
+ "unit_1 = 100/3.072 #Disc voltage as % of conductor voltage of Topmost unit\n",
+ "unit_2 = 1.014/3.072*100 #Disc voltage as % of conductor voltage of second unit\n",
+ "unit_3 = 1.058/3.072*100 #Disc voltage as % of conductor voltage of bottom unit\n",
+ "efficiency = 3.072*100/(n*1.058) #String efficiency(%)\n",
+ "\n",
+ "#Without guard ring\n",
+ "unit_1g = 100/3.752 #Disc voltage as % of conductor voltage of Topmost unit\n",
+ "unit_2g = 1.18/3.752*100 #Disc voltage as % of conductor voltage of second unit\n",
+ "unit_3g = 1.5724/3.752*100 #Disc voltage as % of conductor voltage of bottom unit\n",
+ "efficiency1 = 3.752*100/(n*1.5724) #String efficiency(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Disc voltages as a percentage of the conductor voltage with guard ring are :')\n",
+ "print('Topmost unit = %.2f percent' %unit_1)\n",
+ "print('Second unit = %.2f percent' %unit_2)\n",
+ "print('Bottom unit = %.2f percent' %unit_3)\n",
+ "print('String efficiency = %.2f percent' %efficiency)\n",
+ "print('\\nDisc voltages as a percentage of the conductor voltage without guard ring are :')\n",
+ "print('Topmost unit = %.2f percent' %unit_1g)\n",
+ "print('Second unit = %.2f percent' %unit_2g)\n",
+ "print('Bottom unit = %.2f percent' %unit_3g)\n",
+ "print('String efficiency = %.2f percent' %efficiency1)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Disc voltages as a percentage of the conductor voltage with guard ring are :\n",
+ "Topmost unit = 32.55 percent\n",
+ "Second unit = 33.01 percent\n",
+ "Bottom unit = 34.44 percent\n",
+ "String efficiency = 96.79 percent\n",
+ "\n",
+ "Disc voltages as a percentage of the conductor voltage without guard ring are :\n",
+ "Topmost unit = 26.65 percent\n",
+ "Second unit = 31.45 percent\n",
+ "Bottom unit = 41.91 percent\n",
+ "String efficiency = 79.54 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 5.10, Page number 173"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find corona inception voltage\n",
+ "\n",
+ "#Variable declaration\n",
+ "v = 220.0 #Voltage(kV)\n",
+ "f = 50.0 #Frequency(Hertz)\n",
+ "p = 752.0 #Pressure(mm of Hg)\n",
+ "t = 40.0 #Temperature(\u00b0C)\n",
+ "m = 0.92 #Surface irregularity factor\n",
+ "r = 1.2 #Conductor radius(cm)\n",
+ "d = 550.0 #Spacing(cm)\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "delta = (0.392*p)/(273+t) #Air density correction factor\n",
+ "V_c = 21.1*delta*m*r*math.log(d/r) #Corona inception voltage(kv/phase)rms\n",
+ "V_c_l = 3**0.5*V_c #Line-line corona inception voltage(kV)\n",
+ "\n",
+ "#Result\n",
+ "print('Corona inception voltage , V_c = %.2f kV/phase' %V_c)\n",
+ "print('Line-to-line corona inception voltage = %.2f kV' %V_c_l)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Corona inception voltage , V_c = 134.43 kV/phase\n",
+ "Line-to-line corona inception voltage = 232.84 kV\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 5.11, Page number 173-174"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find corona loss/km\n",
+ "\n",
+ "#Variable declaration\n",
+ "v = 220.0 #Voltage(kV)\n",
+ "f = 50.0 #Frequency(Hertz)\n",
+ "v_o = 1.6 #Over voltage(p.u)\n",
+ "p = 752.0 #Pressure(mm of Hg)\n",
+ "t = 40.0 #Temperature(\u00b0C)\n",
+ "m = 0.92 #Surface irregularity factor\n",
+ "r = 1.2 #Conductor radius(cm)\n",
+ "d = 550.0 #Spacing(cm)\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "delta = (0.392*p)/(273+t) #Air density correction factor\n",
+ "V_c = 21.1*delta*m*r*math.log(d/r) #Corona inception voltage(kv/phase)rms\n",
+ "V_ph = (v * v_o)/3**0.5 #Phase voltage(kV)\n",
+ "peek = 3*(241/delta)*(f+25)*(r/d)**0.5*(V_ph-V_c)**2*10**-5 #Peek's formula(kW/km)\n",
+ "ratio = V_ph/V_c\n",
+ "F = 0.9 #Ratio of V_ph to V_c\n",
+ "peterson = 3*2.1*f*F*(V_c/math.log10(d/r))**2*10**-5 #Peterson's formula(kW/km)\n",
+ "\n",
+ "#Result\n",
+ "print('Corona loss using Peeks formula , P = %.2f kW/km' %peek)\n",
+ "print('Corona loss using Petersons formula , P = %.2f kW/km' %peterson)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Corona loss using Peeks formula , P = 127.28 kW/km\n",
+ "Corona loss using Petersons formula , P = 7.23 kW/km\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file diff --git a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_6_2.ipynb b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_6_2.ipynb new file mode 100644 index 00000000..6374fe50 --- /dev/null +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_6_2.ipynb @@ -0,0 +1,234 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "CHAPTER 6: UNDERGROUND CABLES"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 6.1, Page number 191-192"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find charging current & total charging kVAR/km\n",
+ "\n",
+ "#Variable declaration\n",
+ "C_m = 0.28 #Capacitance b/w ant 2 cores(micro-F/km)\n",
+ "f = 50.0 #Frequency(Hz)\n",
+ "V_L = 11.0 #Line voltage(kV)\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "C = 2*C_m #Capacitance b/w any conductor & shield(micro-F/km)\n",
+ "w = 2*math.pi*f #Angular frequency\n",
+ "I_c = V_L*10**3*w*C*10**-6/3**0.5 #Charging current/phase/km(A)\n",
+ "Total = 3**0.5*I_c*V_L #Total charging kVAR/km\n",
+ "\n",
+ "#Result\n",
+ "print('Charging current/phase/km , I_c = %.3f A' %I_c)\n",
+ "print('Total charging kVAR/km = %.2f ' %Total)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Charging current/phase/km , I_c = 1.117 A\n",
+ "Total charging kVAR/km = 21.29 \n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 6.2, Page number 193-194"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find internal sheath radius\n",
+ "\n",
+ "#Variable declaration\n",
+ "E_c = 100.0 #Safe working stress(kV/cm) rms\n",
+ "V = 130.0 #Operating voltage(kV) rms\n",
+ "d = 1.5 #Diameter of conductor(cm)\n",
+ "\n",
+ "#Calculation\n",
+ "#For case(i)\n",
+ "import math\n",
+ "ln_D = 2*V/(E_c*d)+math.log(d)\n",
+ "D = math.exp(ln_D)\n",
+ "thick_1 = (D-d)/2 #Insulation thickness(cm)\n",
+ "\n",
+ "#For case(ii)\n",
+ "d_2 = 2*V/E_c\n",
+ "D_2 = 2.718*d_2 #Sheath diameter(cm)\n",
+ "thick_2 = (D_2-d_2)/2 #Insulation thickness(cm)\n",
+ "\n",
+ "#Result\n",
+ "print('(i) Internal sheath radius = %.2f cm' %thick_1)\n",
+ "print('(ii) Internal sheath radius = %.2f cm' %thick_2)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "(i) Internal sheath radius = 3.49 cm\n",
+ "(ii) Internal sheath radius = 2.23 cm\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 6.3, Page number 194-196"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find thickness of each layer & conductor voltage\n",
+ "\n",
+ "#Variable declaration\n",
+ "d = 3.0 #Diameter of conductor(cm)\n",
+ "D = 8.5 #Sheath diameter(cm)\n",
+ "e_r1 = 5.0 #Permittivity of inner dielectric\n",
+ "e_r2 = 3.0 #Permittivity of outer dielectric\n",
+ "E_c = 30.0 #Safe working stress(kV/cm) rms\n",
+ "\n",
+ "#Calculation\n",
+ "#For case(i)\n",
+ "import math\n",
+ "E_i = E_c\n",
+ "D_1 = e_r1/e_r2*d\n",
+ "thick_1 = (D_1-d)/2 #Thickness of first layer(cm)\n",
+ "thick_2 = (D-D_1)/2 #Thickness of second layer(cm)\n",
+ "\n",
+ "#For case(ii)\n",
+ "V_1 = E_c*d*math.log(D_1/d)/2 #Voltage across first layer(kV)\n",
+ "V_2 = E_i*D_1*math.log(D/D_1)/2 #Voltage across second layer(kV)\n",
+ "V = V_1 + V_2 #Permissible conductor voltage(kV)\n",
+ "\n",
+ "#For case(iii)\n",
+ "V_3 = E_c*d*math.log(D/d)/2 #Permissible conductor voltage(kV) for homogeneous permittivity of 5\n",
+ "\n",
+ "#Result\n",
+ "print('Case(i) :')\n",
+ "print('Thickness of first layer = %.2f cm' %thick_1)\n",
+ "print('Thickness of second layer = %.2f cm' %thick_2)\n",
+ "print('\\nCase(ii) :')\n",
+ "print('Permissible conductor voltage = %.2f kV' %V)\n",
+ "print('\\nCase(iii) :')\n",
+ "print('Permissible conductor voltage if a homogeneous insulation of permittivity 5 is used , V = %.2f kV' %V_3)\n",
+ "print('\\nNOTE : ERROR : Relative permittivity of outer dielectric is 3 & not 9 as given in textbook')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(i) :\n",
+ "Thickness of first layer = 1.00 cm\n",
+ "Thickness of second layer = 1.75 cm\n",
+ "\n",
+ "Case(ii) :\n",
+ "Permissible conductor voltage = 62.78 kV\n",
+ "\n",
+ "Case(iii) :\n",
+ "Permissible conductor voltage if a homogeneous insulation of permittivity 5 is used , V = 46.87 kV\n",
+ "\n",
+ "NOTE : ERROR : Relative permittivity of outer dielectric is 3 & not 9 as given in textbook\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 6.4, Page number 196-197"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find safe working voltage with & without intersheath\n",
+ "\n",
+ "#Variable declaration\n",
+ "E = 40.0 #Safe working stress(kV/cm) rms\n",
+ "d = 1.5 #Conductor diameter(cm)\n",
+ "D = 6.7 #Sheath diameter(cm)\n",
+ "t = 0.1 #Thickness of lead tube(cm)\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "r = d/2 #Conductor radius(cm)\n",
+ "R = D/2 #Sheath radius(cm)\n",
+ "r_i = r+((R-r)/2)-t/2 #Internal radius of intersheath(cm)\n",
+ "r_e = r_i + t #External radius of intersheath(cm)\n",
+ "V_1 = E*r*math.log(r_i/r) #Voltage across conductor & intersheath(kV)\n",
+ "V_2 = E*r_e*math.log(R/r_e) #Voltage across intersheath & earthed sheath(kV)\n",
+ "V = V_1 + V_2 #Safe working voltage with intersheath(kV)\n",
+ "V_no = E*r*math.log(R/r) #Safe working voltage without intersheath(kV)\n",
+ "\n",
+ "#Result\n",
+ "print('Safe working voltage with intersheath , V = %.2f kV' %V)\n",
+ "print('Safe working voltage without intersheath , V = %.2f kV' %V_no)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Safe working voltage with intersheath , V = 68.65 kV\n",
+ "Safe working voltage without intersheath , V = 44.90 kV\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file diff --git a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_7_2.ipynb b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_7_2.ipynb new file mode 100644 index 00000000..f7c5fe02 --- /dev/null +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_7_2.ipynb @@ -0,0 +1,489 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "CHAPTER 7: SUBSTATION AND DISTRIBUTION SYSTEM"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 7.1, Page number 238-239"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find overall cross-sectional area\n",
+ "\n",
+ "#Variable declaration\n",
+ "V = 400.0 #Voltage supplied(V)\n",
+ "f = 50.0 #Frequency(Hz)\n",
+ "P_1 = 75.0 #Power of induction motor at middle of distributor(kVA)\n",
+ "pf_1 = 0.8 #Power factor of induction motor at middle of distributor\n",
+ "P_2 = 50.0 #Power of induction motor at far end(kVA)\n",
+ "pf_2 = 0.85 #Power factor of induction motor at far end\n",
+ "demand_f = 1.0 #Demand factor\n",
+ "diver_f = 1.2 #Diversity factor\n",
+ "L = 150.0 #Length of line(m)\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "import cmath\n",
+ "theta_1 = math.acos(pf_1) #Power factor angle for 75 kVA(radians)\n",
+ "theta_2 = math.acos(pf_2) #Power factor angle for 50 kVA(radians)\n",
+ "load = P_1*cmath.exp(1j*theta_1)+P_2*cmath.exp(1j*theta_2) #Total connected load(kVA)\n",
+ "pf_r = math.cos(cmath.phase(load)) #Resultant power factor\n",
+ "I_max = abs(load)*1000/(3**0.5*V*diver_f) #Maximum distributor current per phase(A)\n",
+ "L_1 = L/2\n",
+ "V_per = 0.06*V/3**0.5 #Permissible voltage drop(V)\n",
+ "\n",
+ "#From table 7.1 page number 235\n",
+ "#For Ferret\n",
+ "R_f = 0.734*10**-3 #Resistance(ohm/m)\n",
+ "X_f = 0.336*10**-3 #Reactance(ohm/m)\n",
+ "I_2f = P_2*10**3/(3**0.5*V)\n",
+ "I_1f = P_1*10**3/(3**0.5*V)\n",
+ "V_f = I_1f*L_1*(R_f*pf_1+X_f*math.sin(theta_1))+I_2f*L*(R_f*pf_2+X_f*math.sin(theta_2))\n",
+ "d_f = 9.0 #Overall conductor diameter(mm)\n",
+ "area_f = math.pi*d_f**2/4 #Area of ferret conductor(mm^2)\n",
+ "\n",
+ "#For Rabbit\n",
+ "R_R = 0.587*10**-3 #Resistance(ohm/m)\n",
+ "X_R = 0.333*10**-3 #Reactance(ohm/m)\n",
+ "I_2R = P_2*10**3/(3**0.5*V)\n",
+ "I_1R = P_1*10**3/(3**0.5*V)\n",
+ "V_R = I_1R*L_1*(R_R*pf_1+X_R*math.sin(theta_1))+I_2R*L*(R_R*pf_2+X_R*math.sin(theta_2))\n",
+ "d_R = 10.0 #Overall conductor diameter(mm)\n",
+ "area_R = math.pi*d_R**2/4 #Area of rabbit conductor(mm^2)\n",
+ "\n",
+ "#Result\n",
+ "if(V_f > V_per):\n",
+ " print('Overall cross-sectional area of the 7/3.35 mm Rabbit ACSR conductors having overall conductor diameter of 10.0 mm = %.2f mm^2' %area_R)\n",
+ "else:\n",
+ " print('Overall cross-sectional area of the 7/3.00 mm Ferret ACSR conductors having overall conductor diameter of 9.0 mm = %.2f mm^2' %area_f)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Overall cross-sectional area of the 7/3.35 mm Rabbit ACSR conductors having overall conductor diameter of 10.0 mm = 78.54 mm^2\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 7.2, Page number 240"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find overall cross-sectional area\n",
+ "\n",
+ "#Variable declaration\n",
+ "V = 400.0 #Voltage supplied(V)\n",
+ "i = 0.5 #Current per meter(A)\n",
+ "demand_f = 1.0 #Demand factor\n",
+ "diver_f = 1.0 #Diversity factor\n",
+ "L = 275.0 #Length of line(m)\n",
+ "pf = 0.9 #Power factor lagging\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "I = i*L #Current in distributor/phase(A)\n",
+ "theta = math.acos(pf) #Power factor angle\n",
+ "V_per = 0.06*V/3**0.5 #Permissible voltage drop(V)\n",
+ "\n",
+ "#For Weasel\n",
+ "r_w = 0.985 #Resistance(ohm/km)\n",
+ "x_w = 0.341 #Reactance(ohm/km)\n",
+ "V_w = 0.5*i*(r_w*pf+x_w*math.sin(theta))*L**2*10**-3 #Voltage drop for Weasel(V)\n",
+ "d_w = 7.77 #Diameter of weasel conductor(mm)\n",
+ "area_w = math.pi*d_w**2/4 #Area of weasel conductor(mm^2)\n",
+ "\n",
+ "#For Ferret\n",
+ "r_f = 0.734 #Resistance(ohm/km)\n",
+ "x_f = 0.336 #Reactance(ohm/km)\n",
+ "V_f = 0.5*i*(r_f*pf+x_f*math.sin(theta))*L**2*10**-3 #Voltage drop for Ferret(V)\n",
+ "d_f = 9.00 #Diameter of Ferret conductor(mm)\n",
+ "area_f = math.pi*d_f**2/4 #Area of Ferret conductor(mm^2)\n",
+ "\n",
+ "#For Rabbit\n",
+ "r_r = 0.587 #Resistance(ohm/km)\n",
+ "x_r = 0.333 #Reactance(ohm/km)\n",
+ "V_r = 0.5*i*(r_r*pf+x_r*math.sin(theta))*L**2*10**-3 #Voltage drop for Rabbit(V)\n",
+ "d_r = 10.0 #Diameter of Rabbit conductor(mm)\n",
+ "area_r = math.pi*d_r**2/4 #Area of Rabbit conductor(mm^2)\n",
+ "\n",
+ "#Result\n",
+ "if(V_w < V_per):\n",
+ " print('Overall cross-sectional area of the 7/2.59 mm Weasel ACSR conductors having overall conductor diameter of 7.77 mm = %.2f mm^2' %area_w)\n",
+ "elif(V_f < V_per):\n",
+ " print('Overall cross-sectional area of the 7/3.00 mm Ferret ACSR conductors having overall conductor diameter of 9.0 mm = %.2f mm^2' %area_f)\n",
+ "else:\n",
+ " print('Overall cross-sectional area of the 7/3.35 mm Rabbit ACSR conductors having overall conductor diameter of 10.0 mm = %.2f mm^2' %area_r)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Overall cross-sectional area of the 7/3.35 mm Rabbit ACSR conductors having overall conductor diameter of 10.0 mm = 78.54 mm^2\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 7.3, Page number 240-241"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find size of ACSR conductor\n",
+ "\n",
+ "#Variable declaration\n",
+ "V = 400.0 #Voltage supplied(V)\n",
+ "f = 50.0 #Frequency(Hz)\n",
+ "L = 300.0 #Length of line(m)\n",
+ "I_1 = 50.0 #Current at 100 m from feeding point(A)\n",
+ "pf_1 = 0.8 #Power factor at 100 m from feeding point\n",
+ "L_1 = 100.0 #Length of line upto feeding point(m)\n",
+ "I_2 = 25.0 #Current at 100 m from feeding point(A)\n",
+ "pf_2 = 0.78 #Power factor at 100 m from feeding point\n",
+ "L_2 = 200.0 #Length of line from feeding point to far end(m)\n",
+ "i = 0.2 #Distributed load current(A/metre)\n",
+ "v_drop = 15.0 #Permissible voltage drop\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "import cmath\n",
+ "theta_1 = math.acos(pf_1) #Power factor angle for 50 A(radians)\n",
+ "theta_2 = math.acos(pf_2) #Power factor angle for 25 A(radians)\n",
+ "\n",
+ "#For Ferret conductor\n",
+ "r_f = 0.734*10**-3 #Resistance(ohm/m)\n",
+ "x_f = 0.336*10**-3 #Reactance(ohm/m)\n",
+ "V_con_f = I_1*L_1*(r_f*pf_1+x_f*math.sin(theta_1))+I_2*L*(r_f*pf_2+x_f*math.sin(theta_2)) #Voltage drop at B due to concentrated loading(V)\n",
+ "V_dis_f = 0.5*i*r_f*(L_1+L_2)**2 #Voltage drop at B due to distributed loading(V)\n",
+ "V_f = V_con_f+V_dis_f #Total voltage drop(V)\n",
+ "\n",
+ "#For Rabbit conductor\n",
+ "r_r = 0.587*10**-3 #Resistance(ohm/m)\n",
+ "x_r = 0.333*10**-3 #Reactance(ohm/m)\n",
+ "V_con_r = I_1*L_1*(r_r*pf_1+x_r*math.sin(theta_1))+I_2*L*(r_r*pf_2+x_r*math.sin(theta_2)) #Voltage drop at B due to concentrated loading(V)\n",
+ "V_dis_r = 0.5*i*r_r*(L_1+L_2)**2 #Voltage drop at B due to distributed loading(V)\n",
+ "V_r = V_con_r+V_dis_r #Total voltage drop(V)\n",
+ "\n",
+ "#Result\n",
+ "if(V_f < v_drop):\n",
+ " print('Ferret ACSR conductors of size 7/3.00 mm having an overall conductor diameter of 9.0 mm is to be used')\n",
+ " print('Total voltage drop = %.2f V, which is within limit' %V_f)\n",
+ "else:\n",
+ " print('Rabbit ACSR conductors of size 7/3.35 mm having an overall conductor diameter of 10.0 mm is to be used')\n",
+ " print('Total voltage drop = %.2f V, which is within limit' %V_r)\n",
+ "print('\\nNOTE : ERROR : In distributed load : current is 0.2 A/meter and not 0.25 A/meter as given in problem statement')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Rabbit ACSR conductors of size 7/3.35 mm having an overall conductor diameter of 10.0 mm is to be used\n",
+ "Total voltage drop = 13.63 V, which is within limit\n",
+ "\n",
+ "NOTE : ERROR : In distributed load : current is 0.2 A/meter and not 0.25 A/meter as given in problem statement\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 7.4, Page number 244-245"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find kVAR rating & capacitance value\n",
+ "\n",
+ "#Variable declaration\n",
+ "P = 5.0 #Power of substation(MVA)\n",
+ "V_hv = 33.0 #High voltage(kV)\n",
+ "V_lv = 11.0 #Low voltage(kV)\n",
+ "f = 50.0 #Frequency(Hz)\n",
+ "P_1 = 0.5 #Minimum load(MW)\n",
+ "pf_1 = 0.85 #Lagging power factor of minimum load\n",
+ "P_2 = 2.8 #Maximum load(MW)\n",
+ "pf_2 = 0.78 #Lagging power factor of maximum load\n",
+ "pf_i = 0.9 #Lagging power factor of incoming current\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "theta_1 = math.acos(pf_1)\n",
+ "theta_2 = math.acos(pf_2)\n",
+ "theta_i = math.acos(pf_i)\n",
+ "\n",
+ "#Minimum load condition\n",
+ "load_react = P_1*math.tan(theta_1)*1000 #Load reactive power(kVAR)\n",
+ "line_react = P_1*math.tan(theta_i)*1000 #Reactive power supplied by line(kVAR)\n",
+ "rating_fix = load_react - line_react #kVAR rating of fixed capacitor bank(kVAR)\n",
+ "\n",
+ "#Maximum load condition\n",
+ "bank_react = P_2*(math.tan(theta_2)-math.tan(theta_i))*1000 #Reactive power to be supplied by capacitor banks(kVAR)\n",
+ "rating_swi = bank_react - rating_fix #Reactive power rating of switched unit(kVAR)\n",
+ "\n",
+ "#Capacitor value\n",
+ "C_fix = rating_fix*10**-3/(3**0.5*V_lv**2*2*math.pi*f) #Capacitance for fixed bank\n",
+ "C_swi = rating_swi*10**-3/(3**0.5*V_lv**2*2*math.pi*f) #Capacitance for switched bank\n",
+ "\n",
+ "#Result\n",
+ "print('kVAR rating of fixed capacitors = %.1f kVAR' %rating_fix)\n",
+ "print('kVAR rating of switched capacitors = %.1f kVAR' %rating_swi)\n",
+ "print('Capacitance of fixed bank , C = %.2e F/phase' %C_fix)\n",
+ "print('Capacitance of switched bank , C = %.2e F/phase' %C_swi)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "kVAR rating of fixed capacitors = 67.7 kVAR\n",
+ "kVAR rating of switched capacitors = 822.6 kVAR\n",
+ "Capacitance of fixed bank , C = 1.03e-06 F/phase\n",
+ "Capacitance of switched bank , C = 1.25e-05 F/phase\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 7.5, Page number 245"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find kVAR rating,line current & capacitance of bank\n",
+ "\n",
+ "#Variable declaration\n",
+ "V = 400.0 #Voltage of induction motor(V)\n",
+ "f = 50.0 #Frequency(Hz)\n",
+ "I = 40.0 #Line current(A)\n",
+ "pf_1 = 0.78 #Lagging power factor of motor\n",
+ "pf_2 = 0.95 #Raised lagging power factor\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "import cmath\n",
+ "theta_1 = math.acos(pf_1) #Motor power factor angle(radians)\n",
+ "P_act_m = 3**0.5*V*I*pf_1*10**-3 #Active power demand of motor(kW)\n",
+ "P_rea_m = P_act_m*math.tan(theta_1) #Reactive power demand of motor(kVAR)\n",
+ "theta_2 = math.acos(pf_2) #Improved power factor angle(radians)\n",
+ "P_act_l = 3**0.5*V*I*pf_1*10**-3 #Active power supplied by line(kW)\n",
+ "P_rea_l = P_act_m*math.tan(theta_2) #Reactive power supplied by line to motor(kVAR)\n",
+ "rating = P_rea_m - P_rea_l #kVAR rating of capacitor bank(kVAR per phase)\n",
+ "I_C = rating*1000/(3**0.5*V) #Current drawn by capacitor bank(A)\n",
+ "I_L = I*cmath.exp(1j*-theta_1)+I_C*cmath.exp(1j*90*math.pi/180) #Line current(A)\n",
+ "I_phase = I_C/3**0.5 #Phase current of delta connected capacitor bank(A)\n",
+ "C = I_phase/(V*2*math.pi*f) #Per phase capacitance of bank(micro-F/phase)\n",
+ "\n",
+ "#Result\n",
+ "print('kVAR rating of the bank = %.2f kVAR per phase' %rating)\n",
+ "print('Line current = %.2f\u2220%.2f\u00b0 A' %(abs(I_L),cmath.phase(I_L)*180/math.pi))\n",
+ "print('Per phase capacitance of the bank , C = %.2e F/phase' %C)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "kVAR rating of the bank = 10.24 kVAR per phase\n",
+ "Line current = 32.84\u2220-18.19\u00b0 A\n",
+ "Per phase capacitance of the bank , C = 6.79e-05 F/phase\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 7.6, Page number 245-246"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find feeder power factor & load at unity power factor\n",
+ "\n",
+ "#Variable declaration\n",
+ "P_1 = 250.0 #Load at unity power factor(kW)\n",
+ "pf_1 = 1 #Power factor\n",
+ "P_2 = 1500.0 #Load at 0.9 power factor(kW)\n",
+ "pf_2 = 0.9 #Lagging power factor\n",
+ "P_3 = 1000.0 #Load at 0.8 power factor(kW)\n",
+ "pf_3 = 0.8 #Lagging power factor\n",
+ "P_4 = 700.0 #Load at 0.78 power factor(kW)\n",
+ "pf_4 = 0.76 #Lagging power factor\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "import cmath\n",
+ "theta_1 = math.acos(pf_1)\n",
+ "theta_2 = math.acos(pf_2)\n",
+ "theta_3 = math.acos(pf_3)\n",
+ "theta_4 = math.acos(pf_4)\n",
+ "kW_T = P_1+P_2+P_3+P_4 #Total kW carried by feeder(kW)\n",
+ "kVAR_T = P_1*math.tan(theta_1)+P_2*math.tan(theta_2)+P_3*math.tan(theta_3)+P_4*math.tan(theta_4)\n",
+ "pf_feed = math.cos(math.atan(kVAR_T/kW_T))\n",
+ "feeder_KVA = (kW_T**2+kVAR_T**2)**0.5 #Feeder kVA\n",
+ "feeder_kW = feeder_KVA #Load at unity pf(kW)\n",
+ "\n",
+ "#Result\n",
+ "print('Feeder power factor = %.3f lagging' %pf_feed)\n",
+ "print('Load at unity power factor = %.f kW' %feeder_kW)\n",
+ "print('\\nNOTE : ERROR : The load data should be 700 kW at 0.76 pf lagging instead of 700 kW at 0.78 lagging')"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Feeder power factor = 0.857 lagging\n",
+ "Load at unity power factor = 4026 kW\n",
+ "\n",
+ "NOTE : ERROR : The load data should be 700 kW at 0.76 pf lagging instead of 700 kW at 0.78 lagging\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 7.8, Page number 247-249"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find line power factor during lean period\n",
+ "\n",
+ "#Variable declaration\n",
+ "V = 400.0 #Voltage(V)\n",
+ "f = 50.0 #Frequency(Hz)\n",
+ "HP_1 = 75.0 #Power(H.P)\n",
+ "HP_2 = 25.0 #Power(H.P)\n",
+ "HP_3 = 10.0 #Power(H.P)\n",
+ "pf_1 = 0.75 #Power factor at 3/4 load\n",
+ "pf_2 = 0.78 #Power factor at 4/5 load\n",
+ "pf_3 = 0.8 #Power factor at full load\n",
+ "pf_4 = 0.9 #Lagging power factor improved\n",
+ "pf_5 = 0.74 #Power factor of 2nd motor at 2/3 of full load\n",
+ "pf_6 = 0.8 #Power factor of 3rd motor at full load\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Peak season\n",
+ "theta_1 = math.acos(pf_1)\n",
+ "theta_2 = math.acos(pf_2)\n",
+ "theta_3 = math.acos(pf_3)\n",
+ "S_1P = (0.75*HP_1*746*10**-3/pf_1)*cmath.exp(1j*theta_1) #kVA demanded by first motor(kVA)\n",
+ "S_2P = (0.8*HP_2*746*10**-3/pf_2)*cmath.exp(1j*theta_2) #kVA demanded by second motor(kVA)\n",
+ "S_3P = (HP_3*746*10**-3/pf_3)*cmath.exp(1j*theta_3) #kVA demanded by third motor(kVA)\n",
+ "S_TP = S_1P + S_2P + S_3P #Total kVA demanded by all loads(kVA)\n",
+ "pf_l_wc = math.cos(cmath.phase(S_TP)) #Line power factor without capacitive correction\n",
+ "kW_T = S_TP.real #Total kW demanded by load(kW)\n",
+ "kVAR_T = S_TP.imag #Total lagging kVAR demanded by loads(kVAR)\n",
+ "theta_4 = math.acos(pf_4)\n",
+ "P_react = kW_T*math.tan(theta_4) #Reactive power supplied by line for 0.9 pf(kVAR)\n",
+ "power = kVAR_T - P_react #Reactive power supplied by capacitor bank(kVAR)\n",
+ "\n",
+ "#Lean season\n",
+ "theta_5 = math.acos(pf_5)\n",
+ "theta_6 = math.acos(pf_6)\n",
+ "S_2L = (2*HP_2*746*10**-3/(3*pf_5))*cmath.exp(1j*theta_5) #kVA demanded by second motor(kVA)\n",
+ "S_3L = (HP_3*746*10**-3/pf_3)*cmath.exp(1j*theta_3) #kVA demanded by third motor(kVA)\n",
+ "S_TL = S_2L + S_3L #Total kVA demanded during lean period(kVA)\n",
+ "S_line = S_TL.real - complex(0,(power-S_TL.imag)) #kVA supplied by line(kVA)\n",
+ "pf_line = math.cos(cmath.phase(S_line)) #Line power factor\n",
+ "\n",
+ "#Result\n",
+ "print('Line power factor with capacitor bank connected during lean period = %.2f leading' %pf_line)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Line power factor with capacitor bank connected during lean period = 0.95 leading\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file diff --git a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_8_2.ipynb b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_8_2.ipynb new file mode 100644 index 00000000..e6edc8d5 --- /dev/null +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_8_2.ipynb @@ -0,0 +1,447 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "CHAPTER 8: ELEMENTS OF ELECTRIC POWER GENERATION"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 8.1, Page number 260-261"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find overall efficiency\n",
+ "\n",
+ "#Variable declaration\n",
+ "w = 0.8 #Coal to be burnt for every kWh of electric energy(kg)\n",
+ "C = 5000 #Calorific value of coal(kilo-calories/kg)\n",
+ "\n",
+ "#Calculation\n",
+ "heat_energy = C*w/860 #Heat energy of combustion of given coal(kWh)\n",
+ "efficiency = 1/heat_energy #Overall efficiency\n",
+ "\n",
+ "#Result\n",
+ "print('Overall efficiency of the plant = %.3f' %efficiency)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Overall efficiency of the plant = 0.215\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 8.2, Page number 261"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find out daily coal requirement\n",
+ "\n",
+ "#Variable declaration\n",
+ "P = 250.0 #Power(MW)\n",
+ "C = 6100.0 #Calorific value(kcal/kg)\n",
+ "n_1 = 0.9 #Plant runs at full load\n",
+ "h_1 = 20.0 #Time for full load(hour)\n",
+ "n_2 = 0.75 #Plant runs at full load\n",
+ "h_2 = 4.0 #Time for full load(hour)\n",
+ "n_t = 0.3 #Thermal efficiency\n",
+ "n_g = 0.93 #Generator efficiency\n",
+ "\n",
+ "#Calculation\n",
+ "E_T = (P*n_1*h_1+P*n_2*h_2)*1000 #Total electric energy produced by plant in a day(kWh)\n",
+ "efficiency = n_t * n_g #Overall efficiency of the plant\n",
+ "heat_energy = E_T*860/efficiency #Heat energy of combustion of coal(kcal)\n",
+ "coal_requ = heat_energy/C #Daily coal requirement(kg)\n",
+ "coal_requ_ton = coal_requ*10**-3 #Daily coal requirement(tonnes)\n",
+ "\n",
+ "#Result\n",
+ "print('Daily coal requirement = %.2e kg = %.f tonnes' %(coal_requ,coal_requ_ton))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Daily coal requirement = 2.65e+06 kg = 2653 tonnes\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 8.3, Page number 266"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find electric power available & energy\n",
+ "\n",
+ "#Variable declaration\n",
+ "Q = 1.0 #Water discharge(m^3/sec)\n",
+ "h = 200.0 #Height(m)\n",
+ "n_h = 0.85 #Hydraulic efficiency\n",
+ "n_e = 0.95 #Electric efficiency\n",
+ "\n",
+ "#Calculation\n",
+ "n = n_h*n_e #Overall efficiency\n",
+ "P = (736.0/75)*Q*h*n #Electrical power available(kW)\n",
+ "E = P*1.0 #Energy available in an hour(kWh)\n",
+ "\n",
+ "#Result\n",
+ "print('Electrical power available = %.2f kW' %P)\n",
+ "print('Energy available in an hour = %.2f kWh' %E)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Electrical power available = 1584.85 kW\n",
+ "Energy available in an hour = 1584.85 kWh\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 8.4, Page number 266-267"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find percentage fall in reservoir level\n",
+ "\n",
+ "#Variable declaration\n",
+ "Ad = 6.0*10**6 #Reservoir capacity(m^3)\n",
+ "h = 150.0 #Head(m)\n",
+ "n = 0.78 #Overall efficiency\n",
+ "P = 25.0*10**6 #Power(Watt)\n",
+ "t = 4.0 #Supply time(hour)\n",
+ "\n",
+ "#Calculation\n",
+ "AX = P*75*3600*t/(736*h*n*1000) #unit(m^3)\n",
+ "X_d = AX/Ad*100 #Fall in reservoir level(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Percentage fall in reservoir level = %.2f percent' %X_d)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Percentage fall in reservoir level = 5.23 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 8.5, Page number 288-289"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find excitation voltage,current,power factor,power angle,pull out power & electrical stiffness\n",
+ "\n",
+ "#Variable declaration\n",
+ "X_s = 1.0 #Synchronous reactance of generator(p.u)\n",
+ "V_b = 1.0 #Terminal voltage of generator=voltage of infinite bus(p.u)\n",
+ "P_G = 0.5 #Real power output at unity pf(p.u)\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Case(a)\n",
+ "I = P_G/V_b #Generator current(p.u)\n",
+ "E = complex(V_b,I*X_s) #Excitation emf of finite machine(p.u)\n",
+ "delta = cmath.phase(E)*180/math.pi #Power angle = angle b/w E & V_b(degree)\n",
+ "\n",
+ "#Case(b)\n",
+ "P_Gn = P_G/2 #Real power o/p when steam i/p is halved(p.u)\n",
+ "sin_delta_n = P_Gn*X_s/(abs(E)*V_b)\n",
+ "delta_n = math.asin(sin_delta_n) #New power angle(radian)\n",
+ "E_n = abs(E)*cmath.exp(1j*delta_n) #Excitation emf of finite machine with new angle(p.u)\n",
+ "I_n = (E_n-V_b)/complex(0,X_s) #Current when steam i/p is halved(p.u)\n",
+ "pf_n = math.cos(cmath.phase(I_n)) #Power factor when steam i/p is halved\n",
+ "\n",
+ "#Case(c)\n",
+ "P_po = abs(E)*V_b/X_s #Pull out power(p.u)\n",
+ "\n",
+ "#Case(d)\n",
+ "stiff_a = abs(E)*V_b/X_s*math.cos(cmath.phase(E)) #Electrical stiffness in case(a) (p.u/radian)\n",
+ "stiff_b = abs(E)*V_b/X_s*math.cos(cmath.phase(I_n)) #Electrical stiffness in case(b) (p.u/radian)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a) :')\n",
+ "print('Excitation voltage of finite machine , E = %.2f\u2220%.2f\u00b0 p.u' %(abs(E),delta))\n",
+ "print('Power angle = %.2f\u00b0' %delta)\n",
+ "print('\\nCase(b) :')\n",
+ "print('Current if steam input is reduced to half , I_n = %.3f\u2220%.2f\u00b0 p.u' %(abs(I_n),cmath.phase(I_n)*180/math.pi))\n",
+ "print('Power factor if steam input is reduced to half = %.2f lagging' %pf_n)\n",
+ "print('Power angle if steam input is reduced to half = %.2f\u00b0' %(delta_n*180/math.pi))\n",
+ "print('\\nCase(c) :')\n",
+ "print('Pull out power = %.2f p.u' %P_po)\n",
+ "print('\\nCase(d) :')\n",
+ "print('Electrical stiffness for case(a) = %.1f p.u/radian' %stiff_a)\n",
+ "print('Electrical stiffness for case(b) = %.3f p.u/radian' %stiff_b)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a) :\n",
+ "Excitation voltage of finite machine , E = 1.12\u222026.57\u00b0 p.u\n",
+ "Power angle = 26.57\u00b0\n",
+ "\n",
+ "Case(b) :\n",
+ "Current if steam input is reduced to half , I_n = 0.266\u2220-19.74\u00b0 p.u\n",
+ "Power factor if steam input is reduced to half = 0.94 lagging\n",
+ "Power angle if steam input is reduced to half = 12.92\u00b0\n",
+ "\n",
+ "Case(c) :\n",
+ "Pull out power = 1.12 p.u\n",
+ "\n",
+ "Case(d) :\n",
+ "Electrical stiffness for case(a) = 1.0 p.u/radian\n",
+ "Electrical stiffness for case(b) = 1.052 p.u/radian\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 8.6, Page number 289-290"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find power angle,reactive power output,active power & power angle\n",
+ "\n",
+ "#Variable declaration\n",
+ "X_s = 1.1 #Synchronous reactance of generator(p.u)\n",
+ "V_b = 1.0 #Terminal voltage of generator=voltage of infinite bus(p.u)\n",
+ "E = 1.25 #Excitation emf of finite machine(p.u)\n",
+ "P_G = 0.3 #Active power output(p.u)\n",
+ "dec = 0.25 #Excitation is decreased\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Case(a)\n",
+ "sin_delta = P_G*X_s/(E*V_b)\n",
+ "delta = math.asin(sin_delta) #Power angle(radian)\n",
+ "Q_G = V_b/X_s*(E*math.cos(delta)-V_b) #Reactive power output(p.u)\n",
+ "\n",
+ "#Case(b)\n",
+ "E_n = (1-dec)*E #New excitation emf of finite machine(p.u)\n",
+ "P_Gn = P_G #New active power output(p.u)\n",
+ "sin_delta_n = P_G*X_s/(E_n*V_b)\n",
+ "delta_n = math.asin(sin_delta_n) #New power angle(radian)\n",
+ "Q_Gn = V_b/X_s*(E_n*math.cos(delta_n)-V_b) #New reactive power output(p.u)\n",
+ "\n",
+ "#Result\n",
+ "print('Case(a) :')\n",
+ "print('Power angle = %.2f\u00b0' %(delta*180/math.pi))\n",
+ "print('Reactive power output , Q_G = %.3f p.u' %Q_G)\n",
+ "print('\\nCase(b) :')\n",
+ "print('Active power if excitation is decreased , P_Gn = %.1f p.u' %P_Gn)\n",
+ "print('Reactive power if excitation is decreased , Q_Gn = %.3f p.u' %Q_Gn)\n",
+ "print('Power angle if excitation is decreased = %.2f\u00b0' %(delta_n*180/math.pi))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Case(a) :\n",
+ "Power angle = 15.31\u00b0\n",
+ "Reactive power output , Q_G = 0.187 p.u\n",
+ "\n",
+ "Case(b) :\n",
+ "Active power if excitation is decreased , P_Gn = 0.3 p.u\n",
+ "Reactive power if excitation is decreased , Q_Gn = -0.111 p.u\n",
+ "Power angle if excitation is decreased = 20.61\u00b0\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 8.7, Page number 290"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find change in active & reactive power\n",
+ "\n",
+ "#Variable declaration\n",
+ "X_s = 1.05 #Synchronous reactance of generator(p.u)\n",
+ "V_b = 0.95 #Terminal voltage of generator=voltage of infinite bus(p.u)\n",
+ "X_L = 0.1 #Reactance of link(p.u)\n",
+ "E = 1.2 #Excitation emf of finite machine(p.u)\n",
+ "P_G = 0.15 #Active power output(p.u)\n",
+ "inc = 1 #Turbine torque increased\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "import cmath\n",
+ "\n",
+ "#Initial condition\n",
+ "sin_delta = P_G*(X_s+X_L)/(E*V_b)\n",
+ "delta = math.asin(sin_delta) #Power angle(radian)\n",
+ "Q_G = V_b/(X_s+X_L)*(E*math.cos(delta)-V_b) #Reactive power output(p.u)\n",
+ "\n",
+ "#Changed condition\n",
+ "P_Gn = (1+inc)*P_G #New active power output(p.u)\n",
+ "sin_delta_n = P_Gn*(X_s+X_L)/(E*V_b)\n",
+ "delta_n = math.asin(sin_delta_n) #Power angle(radian)\n",
+ "Q_Gn = V_b/(X_s+X_L)*(E*math.cos(delta_n)-V_b) #Reactive power output(p.u)\n",
+ "P_change = (P_Gn-P_G)/P_G*100 #Change in active power output(%)\n",
+ "Q_change = (Q_Gn-Q_G)/Q_G*100 #Change in reactive power output(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Change in active power supplied by generator = %.f percent' %P_change)\n",
+ "print('Change in reactive power supplied by generator = %.2f percent' %Q_change)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Change in active power supplied by generator = 100 percent\n",
+ "Change in reactive power supplied by generator = -17.97 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 8.8, Page number 291"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find percentage change excitation voltage\n",
+ "\n",
+ "#Variable declaration\n",
+ "X_s = 6.0 #Synchronous reactance of alternator(ohms/phase)\n",
+ "pf = 0.8 #Lagging power factor\n",
+ "P_G = 5.0 #Power delivered(MW)\n",
+ "V = 11.0 #Voltage of infinite bus(kV)\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "import cmath\n",
+ "delta = math.acos(pf)\n",
+ "I = P_G*1000/(3**0.5*V*pf)*(pf - complex(0,math.sin(delta))) #Alternator current(A)\n",
+ "V_b = V*10**3/3**0.5 #Voltage of infinite bus(V/phase)\n",
+ "E = complex(V_b,I*X_s) #Initial excitation voltage(V)\n",
+ "pf_n = 1.0 #New power factor\n",
+ "P_Gn = P_G #New power delivered(MW)\n",
+ "I_n = P_Gn*1000/(3**0.5*V*pf_n) #Alternator current(A)\n",
+ "E_n = complex(V_b,I_n*X_s) #New excitation voltage(V)\n",
+ "excitation_change = (abs(E)-abs(E_n))/abs(E)*100 #Percentage change in excitation(%)\n",
+ "\n",
+ "#Result\n",
+ "print('Percentage change in excitation = %.2f percent' %excitation_change)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Percentage change in excitation = 14.96 percent\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file diff --git a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_9_2.ipynb b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_9_2.ipynb new file mode 100644 index 00000000..862e3df0 --- /dev/null +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_9_2.ipynb @@ -0,0 +1,211 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "heading",
+ "level": 1,
+ "metadata": {},
+ "source": [
+ "CHAPTER 9: LOAD FLOW STUDIES"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 9.1, Page number 307-308"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find Y bus matrix\n",
+ "\n",
+ "#Variable declaration\n",
+ "Y_s12 = complex(2.96,-20.16) #Line admittance b/w buses 1 & 2(*10^-3 mho)\n",
+ "Y_p12 = complex(0,0.152) #Line admittance b/w buses 1 & 2(*10^-3 mho)\n",
+ "Y_s15 = complex(2.72,-18.32) #Line admittance b/w buses 1 & 5(*10^-3 mho)\n",
+ "Y_p15 = complex(0,0.185) #Line admittance b/w buses 1 & 5(*10^-3 mho)\n",
+ "Y_s23 = complex(3.0,-22.8) #Line admittance b/w buses 2 & 3(*10^-3 mho)\n",
+ "Y_p23 = complex(0,0.110) #Line admittance b/w buses 2 & 3(*10^-3 mho)\n",
+ "Y_s25 = complex(1.48,-10.30) #Line admittance b/w buses 2 & 5(*10^-3 mho)\n",
+ "Y_p25 = complex(0,0.312) #Line admittance b/w buses 2 & 5(*10^-3 mho)\n",
+ "Y_s34 = complex(2.96,-20.16) #Line admittance b/w buses 3 & 4(*10^-3 mho)\n",
+ "Y_p34 = complex(0,0.152) #Line admittance b/w buses 3 & 4(*10^-3 mho)\n",
+ "Y_s45 = complex(3.0,-22.8) #Line admittance b/w buses 4 & 5(*10^-3 mho)\n",
+ "Y_p45 = complex(0,0.110) #Line admittance b/w buses 4 & 5(*10^-3 mho)\n",
+ "\n",
+ "#Calculation\n",
+ "import scipy\n",
+ "from numpy import *\n",
+ "\n",
+ "#I row\n",
+ "Y_s13 = complex(0,0) #Line admittance b/w buses 1 & 3(*10^-3 mho)\n",
+ "Y_p13 = complex(0,0) #Line admittance b/w buses 1 & 3(*10^-3 mho)\n",
+ "Y_s14 = complex(0,0) #Line admittance b/w buses 1 & 4(*10^-3 mho)\n",
+ "Y_p14 = complex(0,0) #Line admittance b/w buses 1 & 4(*10^-3 mho)\n",
+ "Y_11 = (Y_s12+Y_s13+Y_s14+Y_s15)+(Y_p12+Y_p13+Y_p14+Y_p15)\n",
+ "Y_12 = -Y_s12\n",
+ "Y_13 = -Y_s13\n",
+ "Y_14 = -Y_s14\n",
+ "Y_15 = -Y_s15\n",
+ "\n",
+ "#II row\n",
+ "Y_s21 = Y_s12\n",
+ "Y_p21 = Y_p12\n",
+ "Y_s24 = complex(0,0) #Line admittance b/w buses 2 & 4(*10^-3 mho)\n",
+ "Y_p24 = complex(0,0) #Line admittance b/w buses 2 & 4(*10^-3 mho)\n",
+ "Y_21 = Y_12\n",
+ "Y_22 = (Y_s21+Y_s23+Y_s24+Y_s25)+(Y_p21+Y_p23+Y_p24+Y_p25)\n",
+ "Y_23 = -Y_s23\n",
+ "Y_24 = -Y_s24\n",
+ "Y_25 = -Y_s25\n",
+ "\n",
+ "#III row\n",
+ "Y_s31 = Y_s13\n",
+ "Y_p31 = Y_p13\n",
+ "Y_s32 = Y_s23\n",
+ "Y_p32 = Y_p23\n",
+ "Y_s35 = complex(0,0) #Line admittance b/w buses 2 & 4(*10^-3 mho)\n",
+ "Y_p35 = complex(0,0) #Line admittance b/w buses 2 & 4(*10^-3 mho)\n",
+ "Y_33 = (Y_s31+Y_s32+Y_s34+Y_s35)+(Y_p31+Y_p32+Y_p34+Y_p35)\n",
+ "Y_34 = -Y_s34\n",
+ "Y_35 = -Y_s35\n",
+ "Y_31 = Y_13\n",
+ "Y_32 = Y_23\n",
+ "Y_33 = (Y_s31+Y_s32+Y_s34+Y_s35)+(Y_p31+Y_p32+Y_p34+Y_p35)\n",
+ "Y_34 = -Y_s34\n",
+ "Y_35 = -Y_s35\n",
+ "\n",
+ "#IV row\n",
+ "Y_s41 = Y_s14\n",
+ "Y_p41 = Y_p14\n",
+ "Y_s42 = Y_s24\n",
+ "Y_p42 = Y_p24\n",
+ "Y_s43 = Y_s34\n",
+ "Y_p43 = Y_p34\n",
+ "Y_41 = Y_14\n",
+ "Y_42 = Y_24\n",
+ "Y_43 = Y_34\n",
+ "Y_44 = (Y_s41+Y_s42+Y_s43+Y_s45)+(Y_p41+Y_p42+Y_p43+Y_p45)\n",
+ "Y_45 = -Y_s45\n",
+ "\n",
+ "#V row\n",
+ "Y_s51 = Y_s15\n",
+ "Y_p51 = Y_p15\n",
+ "Y_s52 = Y_s25\n",
+ "Y_p52 = Y_p25\n",
+ "Y_s53 = Y_s35\n",
+ "Y_p53 = Y_p35\n",
+ "Y_s54 = Y_s45\n",
+ "Y_p54 = Y_p45\n",
+ "Y_51 = Y_15\n",
+ "Y_52 = Y_25\n",
+ "Y_53 = Y_35\n",
+ "Y_54 = Y_45\n",
+ "Y_55 = (Y_s51+Y_s52+Y_s53+Y_s54)+(Y_p51+Y_p52+Y_p53+Y_p54)\n",
+ "\n",
+ "Y_bus = [[Y_11, Y_12, Y_13, Y_14, Y_15],\n",
+ " [Y_21, Y_22, Y_23, Y_24, Y_25],\n",
+ " [Y_31, Y_32, Y_33, Y_34, Y_35],\n",
+ " [Y_41, Y_42, Y_43, Y_44, Y_45],\n",
+ " [Y_51, Y_52, Y_53, Y_54, Y_55]]\n",
+ "\n",
+ "#Result\n",
+ "print('The Y bus matrix for the five-bus system is :\\n')\n",
+ "print(array(Y_bus))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "The Y bus matrix for the five-bus system is :\n",
+ "\n",
+ "[[ 5.68-38.143j -2.96+20.16j -0.00 -0.j -0.00 -0.j -2.72+18.32j ]\n",
+ " [-2.96+20.16j 7.44-52.686j -3.00+22.8j -0.00 -0.j -1.48+10.3j ]\n",
+ " [-0.00 -0.j -3.00+22.8j 5.96-42.698j -2.96+20.16j -0.00 -0.j ]\n",
+ " [-0.00 -0.j -0.00 -0.j -2.96+20.16j 5.96-42.698j -3.00+22.8j ]\n",
+ " [-2.72+18.32j -1.48+10.3j -0.00 -0.j -3.00+22.8j 7.20-50.813j]]\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 9.2, Page number 313-314"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "#Find voltage,generated power,real & reactive power loss\n",
+ "\n",
+ "#Variable declaration\n",
+ "V_1 = complex(1.04,0) #Voltage at bus 1(p.u)\n",
+ "S_D1 = complex(0.55,0.15) #Power at bus 1(p.u)\n",
+ "S_D2 = complex(1.0,0.3) #Power at bus 2(p.u)\n",
+ "Y_11 = complex(0.988,-9.734) #Admittance at bus 1(p.u)\n",
+ "Y_22 = Y_11 #Admittance at bus 2(p.u)\n",
+ "Y_12 = complex(-0.988,9.9) #Admittance b/w bus 1 & 2(p.u)\n",
+ "Y_21 = Y_12 #Admittance b/w bus 2 & 1(p.u)\n",
+ "\n",
+ "#Calculation\n",
+ "import math\n",
+ "import cmath\n",
+ "V_2_0 = complex(1,0) #Initial value of V_2 \n",
+ "S_2 = complex(-1,0.3) #P_2+j*Q_2\n",
+ "V_2_1 = (1/Y_22)*((S_2/V_2_0.conjugate())-Y_21*V_1)\n",
+ "V_2_2 = (1/Y_22)*((S_2/V_2_1.conjugate())-Y_21*V_1)\n",
+ "V_2_3 = (1/Y_22)*((S_2/V_2_2.conjugate())-Y_21*V_1)\n",
+ "V_2_4 = (1/Y_22)*((S_2/V_2_3.conjugate())-Y_21*V_1)\n",
+ "V_2_5 = (1/Y_22)*((S_2/V_2_4.conjugate())-Y_21*V_1)\n",
+ "V_2 = V_2_5 #Voltage 2(p.u)\n",
+ "S_1_con = V_1.conjugate()*Y_11*V_1 + V_1.conjugate()*Y_12*V_2 #Conjugate of slack bus net power\n",
+ "S_1 = S_1_con.conjugate()\n",
+ "S_G1 = S_1 + S_D1 #Generated power at bus 1(p.u)\n",
+ "P_L = S_G1.real - (S_D1.real + S_D2.real) #Real power loss(p.u)\n",
+ "Q_L = S_G1.imag - (S_D1.imag + S_D2.imag) #Reactive power loss(p.u)\n",
+ "\n",
+ "#Result\n",
+ "print('Voltage at bus 2 , V_2 = %.4f\u2220%.2f\u00b0 p.u' %(abs(V_2),(cmath.phase(V_2)*180/math.pi)))\n",
+ "print('Generated power at bus 1 , S_G1 = (%.2f + j%.3f) p.u' %(S_G1.real,S_G1.imag))\n",
+ "print('Real power loss in the system = %.2f p.u' %P_L)\n",
+ "print('Reactive power loss in the system = %.3f p.u' %Q_L)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Voltage at bus 2 , V_2 = 1.0128\u2220-5.38\u00b0 p.u\n",
+ "Generated power at bus 1 , S_G1 = (1.56 + j0.199) p.u\n",
+ "Real power loss in the system = 0.01 p.u\n",
+ "Reactive power loss in the system = -0.251 p.u\n"
+ ]
+ }
+ ],
+ "prompt_number": 1
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file diff --git a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/README.txt b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/README.txt new file mode 100644 index 00000000..6e8a4b95 --- /dev/null +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/README.txt @@ -0,0 +1,10 @@ +Contributed By: KAVAN A B +Course: be +College/Institute/Organization: SRI JAYACHAMARAJENDRA COLLEGE OF ENGINEERING +Department/Designation: ELECTRICAL & ELECTRONICS +Book Title: Electrical Power Systems: Concepts, Theory and Practice +Author: Subir Ray +Publisher: Prentice Hall of India Private Limited(PHI), New Delhi-110001 +Year of publication: 2007 +Isbn: 9788120329898 +Edition: 1
\ No newline at end of file diff --git a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/screenshots/1.png b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/screenshots/1.png Binary files differnew file mode 100644 index 00000000..f40cf8e9 --- /dev/null +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/screenshots/1.png diff --git a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/screenshots/1_1.png b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/screenshots/1_1.png Binary files differnew file mode 100644 index 00000000..f40cf8e9 --- /dev/null +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/screenshots/1_1.png diff --git a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/screenshots/1_2.png b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/screenshots/1_2.png Binary files differnew file mode 100644 index 00000000..8fd3190d --- /dev/null +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/screenshots/1_2.png diff --git a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/screenshots/2.png b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/screenshots/2.png Binary files differnew file mode 100644 index 00000000..033d3704 --- /dev/null +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/screenshots/2.png diff --git a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/screenshots/2_1.png b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/screenshots/2_1.png Binary files differnew file mode 100644 index 00000000..033d3704 --- /dev/null +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/screenshots/2_1.png diff --git a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/screenshots/2_2.png b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/screenshots/2_2.png Binary files differnew file mode 100644 index 00000000..f40cf8e9 --- /dev/null +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/screenshots/2_2.png diff --git a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/screenshots/3.png b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/screenshots/3.png Binary files differnew file mode 100644 index 00000000..8fd3190d --- /dev/null +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/screenshots/3.png diff --git a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/screenshots/3_1.png b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/screenshots/3_1.png Binary files differnew file mode 100644 index 00000000..8fd3190d --- /dev/null +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/screenshots/3_1.png diff --git a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/screenshots/3_2.png b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/screenshots/3_2.png Binary files differnew file mode 100644 index 00000000..033d3704 --- /dev/null +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/screenshots/3_2.png |
