diff options
| author | debashisdeb | 2014-06-20 15:42:42 +0530 |
|---|---|---|
| committer | debashisdeb | 2014-06-20 15:42:42 +0530 |
| commit | 83c1bfceb1b681b4bb7253b47491be2d8b2014a1 (patch) | |
| tree | f54eab21dd3d725d64a495fcd47c00d37abed004 /Electrical_Power_Systems:_Concepts,_Theory_and_Practice | |
| parent | a78126bbe4443e9526a64df9d8245c4af8843044 (diff) | |
| download | Python-Textbook-Companions-83c1bfceb1b681b4bb7253b47491be2d8b2014a1.tar.gz Python-Textbook-Companions-83c1bfceb1b681b4bb7253b47491be2d8b2014a1.tar.bz2 Python-Textbook-Companions-83c1bfceb1b681b4bb7253b47491be2d8b2014a1.zip | |
removing problem statements
Diffstat (limited to 'Electrical_Power_Systems:_Concepts,_Theory_and_Practice')
13 files changed, 0 insertions, 398 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 index 2a9ddf10..3ce6918a 100644 --- a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_10_2.ipynb +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_10_2.ipynb @@ -27,23 +27,19 @@ "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",
@@ -71,9 +67,7 @@ "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",
@@ -89,12 +83,9 @@ "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",
@@ -103,7 +94,6 @@ "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))"
],
@@ -133,9 +123,7 @@ "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",
@@ -144,7 +132,6 @@ "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",
@@ -154,7 +141,6 @@ "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",
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 index 825a19ae..1ea7e5cb 100644 --- a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_12_2.ipynb +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_12_2.ipynb @@ -27,14 +27,11 @@ "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",
@@ -42,7 +39,6 @@ "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",
@@ -76,15 +72,12 @@ "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",
@@ -92,7 +85,6 @@ "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)"
@@ -124,14 +116,11 @@ "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",
@@ -139,7 +128,6 @@ "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",
@@ -173,20 +161,16 @@ "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",
@@ -214,14 +198,11 @@ "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",
@@ -232,7 +213,6 @@ "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",
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 index 84e2db43..a76135e2 100644 --- a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_13_2.ipynb +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_13_2.ipynb @@ -27,9 +27,7 @@ "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",
@@ -42,7 +40,6 @@ "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",
@@ -50,7 +47,6 @@ "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",
@@ -62,7 +58,6 @@ "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",
@@ -72,7 +67,6 @@ "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",
@@ -115,9 +109,7 @@ "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",
@@ -129,7 +121,6 @@ "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",
@@ -141,7 +132,6 @@ "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')"
],
@@ -172,15 +162,12 @@ "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",
@@ -192,7 +179,6 @@ "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)"
],
@@ -222,9 +208,7 @@ "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",
@@ -241,7 +225,6 @@ "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",
@@ -259,7 +242,6 @@ "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')"
@@ -292,12 +274,9 @@ "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",
@@ -305,7 +284,6 @@ "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')"
],
@@ -336,9 +314,7 @@ "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",
@@ -348,9 +324,7 @@ "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",
@@ -360,20 +334,16 @@ "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",
@@ -415,21 +385,17 @@ "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))"
@@ -461,16 +427,13 @@ "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",
@@ -481,7 +444,6 @@ "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",
@@ -498,7 +460,6 @@ "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",
@@ -515,7 +476,6 @@ "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",
@@ -532,7 +492,6 @@ "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",
@@ -605,15 +564,12 @@ "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",
@@ -629,7 +585,6 @@ "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')"
@@ -662,9 +617,7 @@ "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",
@@ -681,7 +634,6 @@ "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",
@@ -693,7 +645,6 @@ "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",
@@ -701,7 +652,6 @@ "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",
@@ -709,7 +659,6 @@ "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",
@@ -758,9 +707,7 @@ "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",
@@ -780,7 +727,6 @@ "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",
@@ -799,7 +745,6 @@ "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)"
],
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 index 7e9e089f..4187d366 100644 --- a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_14_2.ipynb +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_14_2.ipynb @@ -27,21 +27,17 @@ "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",
@@ -69,9 +65,7 @@ "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",
@@ -80,40 +74,34 @@ "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",
@@ -174,20 +162,16 @@ "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",
@@ -215,22 +199,18 @@ "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",
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 index 5631893f..4bf91cd7 100644 --- a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_15_2.ipynb +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_15_2.ipynb @@ -27,9 +27,7 @@ "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",
@@ -37,7 +35,6 @@ "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",
@@ -53,7 +50,6 @@ "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)"
],
@@ -83,9 +79,7 @@ "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",
@@ -94,7 +88,6 @@ "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",
@@ -103,7 +96,6 @@ "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",
@@ -137,16 +129,13 @@ "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",
@@ -169,7 +158,6 @@ "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",
@@ -208,16 +196,13 @@ "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",
@@ -245,7 +230,6 @@ "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",
@@ -283,9 +267,7 @@ "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",
@@ -295,7 +277,6 @@ "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",
@@ -305,7 +286,6 @@ "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)"
],
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 index 1ac5ff1b..caca2a2c 100644 --- a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_2_2.ipynb +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_2_2.ipynb @@ -27,16 +27,13 @@ "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",
@@ -48,7 +45,6 @@ "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",
@@ -82,21 +78,17 @@ "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",
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 index a6c97b20..7b594528 100644 --- a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_3_2.ipynb +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_3_2.ipynb @@ -27,9 +27,7 @@ "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",
@@ -38,15 +36,12 @@ "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",
@@ -56,7 +51,6 @@ "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",
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 index 87e5269f..038d3cb9 100644 --- a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_4_2.ipynb +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_4_2.ipynb @@ -27,27 +27,21 @@ "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)"
],
@@ -77,18 +71,14 @@ "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",
@@ -116,21 +106,17 @@ "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",
@@ -158,9 +144,7 @@ "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",
@@ -169,21 +153,18 @@ "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",
@@ -217,9 +198,7 @@ "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",
@@ -236,7 +215,6 @@ "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",
@@ -246,7 +224,6 @@ "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",
@@ -274,21 +251,17 @@ "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)"
],
@@ -318,9 +291,7 @@ "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",
@@ -337,7 +308,6 @@ "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",
@@ -346,7 +316,6 @@ "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",
@@ -374,21 +343,17 @@ "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",
@@ -416,20 +381,16 @@ "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)"
@@ -461,9 +422,7 @@ "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",
@@ -473,30 +432,24 @@ "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",
@@ -508,7 +461,6 @@ "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",
@@ -547,16 +499,13 @@ "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",
@@ -572,7 +521,6 @@ "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",
@@ -607,9 +555,7 @@ "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",
@@ -621,7 +567,6 @@ "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",
@@ -633,7 +578,6 @@ "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",
@@ -647,7 +591,6 @@ "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",
@@ -662,7 +605,6 @@ "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",
@@ -679,7 +621,6 @@ "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",
@@ -696,7 +637,6 @@ "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",
@@ -768,9 +708,7 @@ "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",
@@ -780,11 +718,9 @@ "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",
@@ -792,13 +728,11 @@ "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)"
],
@@ -828,9 +762,7 @@ "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",
@@ -838,7 +770,6 @@ "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",
@@ -846,19 +777,16 @@ "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)"
],
@@ -888,9 +816,7 @@ "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",
@@ -900,11 +826,9 @@ "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",
@@ -912,14 +836,12 @@ "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",
@@ -960,9 +882,7 @@ "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",
@@ -972,26 +892,20 @@ "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",
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 index 52614bb8..424e036e 100644 --- a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_5_2.ipynb +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_5_2.ipynb @@ -27,9 +27,7 @@ "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",
@@ -40,15 +38,12 @@ "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",
@@ -56,7 +51,6 @@ "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",
@@ -66,7 +60,6 @@ "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",
@@ -117,9 +110,7 @@ "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",
@@ -129,26 +120,20 @@ "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",
@@ -185,16 +170,13 @@ "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",
@@ -202,7 +184,6 @@ "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)"
],
@@ -232,15 +213,11 @@ "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",
@@ -251,10 +228,8 @@ "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",
@@ -299,15 +274,11 @@ "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",
@@ -333,11 +304,9 @@ "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",
@@ -379,9 +348,7 @@ "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",
@@ -396,8 +363,6 @@ "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",
@@ -405,7 +370,6 @@ "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",
@@ -421,7 +385,6 @@ "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",
@@ -470,14 +433,11 @@ "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",
@@ -488,7 +448,6 @@ "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)"
],
@@ -518,24 +477,19 @@ "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",
@@ -582,9 +536,7 @@ "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",
@@ -593,13 +545,11 @@ "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)"
],
@@ -629,9 +579,7 @@ "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",
@@ -641,7 +589,6 @@ "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",
@@ -651,7 +598,6 @@ "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)"
],
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 index 6374fe50..f73c195c 100644 --- a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_6_2.ipynb +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_6_2.ipynb @@ -27,21 +27,17 @@ "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)"
],
@@ -71,26 +67,20 @@ "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)"
],
@@ -120,32 +110,25 @@ "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",
@@ -190,15 +173,12 @@ "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",
@@ -209,7 +189,6 @@ "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)"
],
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 index f7c5fe02..a2411da4 100644 --- a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_7_2.ipynb +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_7_2.ipynb @@ -27,9 +27,7 @@ "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",
@@ -40,7 +38,6 @@ "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",
@@ -51,8 +48,6 @@ "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",
@@ -61,7 +56,6 @@ "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",
@@ -70,7 +64,6 @@ "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",
@@ -101,9 +94,7 @@ "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",
@@ -111,34 +102,29 @@ "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",
@@ -171,9 +157,7 @@ "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",
@@ -186,27 +170,23 @@ "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",
@@ -243,9 +223,7 @@ "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",
@@ -256,26 +234,21 @@ "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",
@@ -309,16 +282,13 @@ "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",
@@ -333,7 +303,6 @@ "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)"
@@ -365,9 +334,7 @@ "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",
@@ -377,7 +344,6 @@ "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",
@@ -390,7 +356,6 @@ "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')"
@@ -423,9 +388,7 @@ "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",
@@ -438,11 +401,9 @@ "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",
@@ -457,7 +418,6 @@ "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",
@@ -466,7 +426,6 @@ "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",
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 index e6edc8d5..4fd4268d 100644 --- a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_8_2.ipynb +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_8_2.ipynb @@ -27,17 +27,13 @@ "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",
@@ -65,9 +61,7 @@ "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",
@@ -77,14 +71,12 @@ "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",
@@ -112,20 +104,16 @@ "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)"
],
@@ -155,20 +143,16 @@ "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",
@@ -196,23 +180,18 @@ "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",
@@ -220,14 +199,11 @@ "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",
@@ -280,32 +256,26 @@ "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",
@@ -346,9 +316,7 @@ "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",
@@ -356,16 +324,13 @@ "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",
@@ -373,7 +338,6 @@ "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)"
],
@@ -403,15 +367,12 @@ "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",
@@ -424,7 +385,6 @@ "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",
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 index 862e3df0..deaf5ff4 100644 --- a/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_9_2.ipynb +++ b/Electrical_Power_Systems:_Concepts,_Theory_and_Practice/CHAPTER_9_2.ipynb @@ -27,9 +27,7 @@ "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",
@@ -43,11 +41,9 @@ "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",
@@ -58,7 +54,6 @@ "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",
@@ -69,7 +64,6 @@ "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",
@@ -85,7 +79,6 @@ "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",
@@ -98,7 +91,6 @@ "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",
@@ -119,7 +111,6 @@ " [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))"
],
@@ -154,9 +145,7 @@ "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",
@@ -165,7 +154,6 @@ "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",
@@ -182,7 +170,6 @@ "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",
|