def test_parserraw_keep_all_lossless(self): try: for case in test_cases.CASES: if os.path.splitext(case)[-1] != '.raw': continue parser = pf.ParserRAW() parser.set('keep_all_out_of_service', 1) net1 = parser.parse(case) parser = pf.ParserRAW() parser.write(net1, 'foo.raw') parser = pf.ParserRAW() parser.set('keep_all_out_of_service', 1) net2 = parser.parse('foo.raw') pf.tests.utils.compare_networks(self, net1, net2, eps=1e-9) finally: if os.path.isfile('foo.raw'): os.remove('foo.raw')
def test_parserraw_write(self): tested = False for case in test_cases.CASES: if os.path.splitext(case)[-1] != '.raw': continue parser = pf.ParserRAW() parser.set('output_level', 0) net1 = parser.parse(case, num_periods=2) try: parser.write(net1, 'foo.raw') net2 = parser.parse('foo.raw', num_periods=2) new_parser = pf.ParserRAW() net3 = parser.parse('foo.raw', num_periods=2) finally: if os.path.isfile('foo.raw'): os.remove('foo.raw') pf.tests.utils.compare_networks(self, net1, net2, eps=1e-9) pf.tests.utils.compare_networks(self, net1, net3, eps=1e-9) tested = True
def test_type_parsers(self): for case in test_cases.CASES: if case.split('.')[-1] == 'mat': self.assertRaises(pf.ParserError,pf.ParserJSON().parse,case) self.assertRaises(pf.ParserError,pf.PyParserMAT().parse,case) if pf.has_raw_parser(): self.assertRaises(pf.ParserError,pf.ParserRAW().parse,case) net = pf.ParserMAT().parse(case) self.assertGreater(net.num_buses,0) if case.split('.')[-1] == 'm': self.assertRaises(pf.ParserError,pf.ParserJSON().parse,case) self.assertRaises(pf.ParserError,pf.ParserMAT().parse,case) if pf.has_raw_parser(): self.assertRaises(pf.ParserError,pf.ParserRAW().parse,case) net = pf.PyParserMAT().parse(case) self.assertGreater(net.num_buses,0)
class TestParser(unittest.TestCase): def setUp(self): pass def test_parserraw_zi_lines(self): case = os.path.join('data', 'psse_sample_case.raw') if os.path.isfile(case): # Parsed net net1 = pf.ParserRAW().parse(case) # Copied net2 = net1.get_copy() # Extracted net (including) net3 = net1.extract_subnetwork([net1.get_bus_from_number(153), net1.get_bus_from_number(154), net1.get_bus_from_number(3005)]) self.assertEqual(net3.num_buses, 3) # Extracted net (not including) net4 = net1.extract_subnetwork([net1.get_bus_from_number(101), net1.get_bus_from_number(102), net1.get_bus_from_number(151)]) self.assertEqual(net4.num_buses, 3) self.assertRaises(pf.NetworkError, net4.get_bus_from_number, 153) self.assertRaises(pf.NetworkError, net4.get_bus_from_number, 3006) # Serialized net try: pf.ParserJSON().write(net1, 'foo.json') net5 = pf.ParserJSON().parse('foo.json') finally: if os.path.isfile('foo.json'): os.remove('foo.json') # Test for net in [net1, net2, net3, net5]: self.assertEqual(net.get_num_redundant_buses(), 1) bus1 = net.get_bus_from_number(3006) bus2 = net.get_bus_from_number(153) self.assertTrue(bus1.is_equal(bus2)) load1 = net.get_load_from_name_and_bus_number('1', 3006) load2 = net.get_load_from_name_and_bus_number('1', 153) self.assertTrue(load1.is_equal(load2)) br1 = net.get_branch_from_name_and_bus_numbers('2', 3006, 154) br2 = net.get_branch_from_name_and_bus_numbers('2', 153, 154) self.assertTrue(br1.is_equal(br2)) br3 = net.get_branch_from_name_and_bus_numbers('1', 3006, 3005) br4 = net.get_branch_from_name_and_bus_numbers('1', 153, 3005) self.assertTrue(br3.is_equal(br4))
def test_ACPF_keep_all(self): for case in utils.test_cases: if os.path.splitext(case)[1] == '.raw': parser = pf.ParserRAW() parser.set('output_level', 0) net = parser.parse(case) parser.set('keep_all_out_of_service', True) net_oos = parser.parse(case) if (net.num_buses == net_oos.num_buses and net.num_generators == net_oos.num_generators and net.num_loads == net_oos.num_loads and net.num_shunts == net_oos.num_shunts and net.num_branches == net_oos.num_branches): continue method = gopt.power_flow.ACPF() method.set_parameters({'solver': 'augl', 'quiet': True, 'v_mag_warm_ref': True}) method.solve(net) r = method.get_results() method.solve(net_oos) r_oos = method.get_results() self.assertEqual(r['solver status'], r_oos['solver status']) self.assertEqual(r['solver iterations'], r_oos['solver iterations']) self.assertEqual(r['network snapshot'].bus_v_max, r_oos['network snapshot'].bus_v_max) self.assertEqual(r['network snapshot'].bus_v_min, r_oos['network snapshot'].bus_v_min) self.assertEqual(r['network snapshot'].bus_P_mis, r_oos['network snapshot'].bus_P_mis) self.assertEqual(r['network snapshot'].bus_Q_mis, r_oos['network snapshot'].bus_Q_mis) self.assertRaises(AssertionError, pf.tests.utils.compare_networks, self, r['network snapshot'], r_oos['network snapshot'])
class TestLoads(unittest.TestCase): def test_GSO_5bus_vloads_case(self): T = 4 case = os.path.join('data', 'GSO_5bus_vloads.raw') if not os.path.isfile(case): raise unittest.SkipTest('file not available') net = pf.ParserRAW().parse(case, T) self.assertEqual(net.num_loads, 3) self.assertEqual(net.get_num_vdep_loads(), 2) load1 = net.get_load_from_name_and_bus_number('1', 2) load2 = net.get_load_from_name_and_bus_number('1', 3) for t in range(T): self.assertEqual(load1.P[t], (500. + 200. + 100.) / net.base_power) self.assertEqual(load1.Q[t], (180. + 50. - 50.) / net.base_power) self.assertEqual(load1.comp_cp[t], 500. / net.base_power) self.assertEqual(load1.comp_cq[t], 180. / net.base_power) self.assertEqual(load1.comp_ci[t], 200. / net.base_power) self.assertEqual(load1.comp_cj[t], 50. / net.base_power) self.assertEqual(load1.comp_cg, 100. / net.base_power) self.assertEqual(load1.comp_cb, 50. / net.base_power) self.assertEqual(load2.P[t], (40. + 20. + 20.) / net.base_power) self.assertEqual(load2.Q[t], (20. + 10. - 10.) / net.base_power) self.assertEqual(load2.comp_cp[t], 40. / net.base_power) self.assertEqual(load2.comp_cq[t], 20. / net.base_power) self.assertEqual(load2.comp_ci[t], 20. / net.base_power) self.assertEqual(load2.comp_cj[t], 10. / net.base_power) self.assertEqual(load2.comp_cg, 20. / net.base_power) self.assertEqual(load2.comp_cb, 10. / net.base_power)
raise unittest.SkipTest('epc file not available') parser = pf.ParserEPC() parser.set('output_level', 0) net = parser.parse(case) self.assertEqual(net.num_buses, 56) def test_parserraw_star_bus_area_zone(self): case = os.path.join('data', 'psse_sample_case.raw') if not os.path.isfile(case): raise unittest.SkipTest('raw file not available') parser = pf.ParserRAW() parser.set('keep_all_out_of_service', True) net = parser.parse(case) counter = 0 for bus in net.buses: if bus.is_star(): neighbors = [] for br in bus.branches: if bus.index == br.bus_k.index: neighbors.append(br.bus_m) else: neighbors.append(br.bus_k) self.assertEqual(len(neighbors), 3) for b in neighbors: self.assertEqual(b.area, bus.area)
def test_ieee25_raw(self): for case in test_cases.CASES: if case == './data/ieee25.raw': net = pf.ParserRAW().parse(case) self.assertEqual(net.num_buses, 25) self.assertTrue(101 in [bus.number for bus in net.buses]) self.assertTrue(104 in [bus.number for bus in net.buses]) self.assertTrue(106 in [bus.number for bus in net.buses]) self.assertTrue(222 in [bus.number for bus in net.buses]) tested_101 = False tested_104 = False tested_106 = False tested_222 = False for bus in net.buses: # base kv if bus.number >= 101 and bus.number <= 110: self.assertEqual(bus.v_base, 138.) else: self.assertLessEqual(bus.number, 225) self.assertGreaterEqual(bus.number, 211) self.assertEqual(bus.v_base, 230.) # names if bus.number == 101: self.assertEqual(bus.name, 'COAL-A') self.assertEqual(len(bus.generators), 3) self.assertEqual([g.name for g in bus.generators], ['5', '4', '3']) tested_101 = True if bus.number == 104: self.assertEqual(len(bus.loads), 1) self.assertEqual(bus.loads[0].name, '1') tested_104 = True if bus.number == 106: self.assertEqual(len(bus.shunts), 2) self.assertEqual([s.name for s in bus.shunts], ['', '1']) tested_106 = True if bus.number == 222: self.assertEqual(bus.name, 'HYDRO') self.assertEqual(len(bus.generators), 10) self.assertEqual( [g.name for g in bus.generators], ['A', '9', '8', '7', '6', '5', '4', '3', '2', '1']) tested_222 = True brs = [] for branch in net.branches: if (branch.bus_k.number, branch.bus_m.number) == (215, 221): brs.append(branch) if (branch.bus_k.number, branch.bus_m.number) == (103, 224): self.assertEqual(branch.name, '1') self.assertEqual(len(brs), 2) self.assertEqual([br.name for br in brs], ['2', '1']) self.assertTrue(tested_101) self.assertTrue(tested_104) self.assertTrue(tested_106) self.assertTrue(tested_222)
class TestParser(unittest.TestCase): def setUp(self): pass def test_ieee25_raw(self): for case in test_cases.CASES: if case == './data/ieee25.raw': net = pf.ParserRAW().parse(case) self.assertEqual(net.num_buses, 25) self.assertTrue(101 in [bus.number for bus in net.buses]) self.assertTrue(104 in [bus.number for bus in net.buses]) self.assertTrue(106 in [bus.number for bus in net.buses]) self.assertTrue(222 in [bus.number for bus in net.buses]) tested_101 = False tested_104 = False tested_106 = False tested_222 = False for bus in net.buses: # base kv if bus.number >= 101 and bus.number <= 110: self.assertEqual(bus.v_base, 138.) else: self.assertLessEqual(bus.number, 225) self.assertGreaterEqual(bus.number, 211) self.assertEqual(bus.v_base, 230.) # names if bus.number == 101: self.assertEqual(bus.name, 'COAL-A') self.assertEqual(len(bus.generators), 3) self.assertEqual([g.name for g in bus.generators], ['5', '4', '3']) tested_101 = True if bus.number == 104: self.assertEqual(len(bus.loads), 1) self.assertEqual(bus.loads[0].name, '1') tested_104 = True if bus.number == 106: self.assertEqual(len(bus.shunts), 2) self.assertEqual([s.name for s in bus.shunts], ['', '1']) tested_106 = True if bus.number == 222: self.assertEqual(bus.name, 'HYDRO') self.assertEqual(len(bus.generators), 10) self.assertEqual( [g.name for g in bus.generators], ['A', '9', '8', '7', '6', '5', '4', '3', '2', '1']) tested_222 = True brs = [] for branch in net.branches: if (branch.bus_k.number, branch.bus_m.number) == (215, 221): brs.append(branch) if (branch.bus_k.number, branch.bus_m.number) == (103, 224): self.assertEqual(branch.name, '1') self.assertEqual(len(brs), 2) self.assertEqual([br.name for br in brs], ['2', '1']) self.assertTrue(tested_101) self.assertTrue(tested_104) self.assertTrue(tested_106) self.assertTrue(tested_222) def test_sys_problem2(self): for case in test_cases.CASES: if case == './data/sys_problem2.mat': net = pf.ParserMAT().parse(case) self.assertEqual(net.base_power, 100.) self.assertEqual(net.num_buses, 3) self.assertEqual(net.num_generators, 4) self.assertEqual(net.num_loads, 3) self.assertEqual(net.num_branches, 3) bus1 = net.get_bus_from_number(1) bus2 = net.get_bus_from_number(2) bus3 = net.get_bus_from_number(3) for bus in net.buses: self.assertEqual(bus.v_base, 220.) self.assertEqual(bus1.number, 1) self.assertEqual(bus2.number, 2) self.assertEqual(bus3.number, 3) branch13 = net.get_branch(0) branch23 = net.get_branch(1) branch12 = net.get_branch(2) self.assertEqual(len(bus1.generators), 2) self.assertEqual(len(bus2.generators), 1) self.assertEqual(len(bus3.generators), 1) self.assertEqual(len(bus1.loads), 1) self.assertEqual(len(bus2.loads), 1) self.assertEqual(len(bus3.loads), 1) gen0 = net.get_generator(3) gen1 = net.get_generator(2) gen2 = net.get_generator(1) gen3 = net.get_generator(0) load0 = net.get_load(2) load1 = net.get_load(1) load2 = net.get_load(0) self.assertEqual(load0.bus, bus1) self.assertEqual(load1.bus, bus2) self.assertEqual(load2.bus, bus3) self.assertEqual(gen0.P, 50 / 100.) self.assertEqual(gen1.P, 40 / 100.) self.assertEqual(gen2.P, 30 / 100.) self.assertEqual(gen3.P, 20 / 100.) self.assertEqual(gen0.P_max, 50) self.assertEqual(gen1.P_max, 50) self.assertEqual(gen2.P_max, 25) self.assertEqual(gen3.P_max, 19) self.assertEqual(gen0.bus, bus1) self.assertEqual(gen1.bus, bus1) self.assertEqual(gen2.bus, bus2) self.assertEqual(gen3.bus, bus3) for gen in net.generators: self.assertEqual(gen.P_min, 0.) self.assertEqual(branch13.bus_k.number, bus1.number) self.assertEqual(branch13.bus_m.number, bus3.number) self.assertEqual(branch23.bus_k.number, bus2.number) self.assertEqual(branch23.bus_m.number, bus3.number) self.assertEqual(branch12.bus_k.number, bus1.number) self.assertEqual(branch12.bus_m.number, bus2.number) self.assertEqual(branch13.g, 0) self.assertLess(abs(branch13.b + 1. / 0.1), 1e-10) self.assertEqual(branch13.ratingA, 30.95) self.assertEqual(branch13.ratingB, 30.95) self.assertEqual(branch13.ratingC, 30.95) self.assertEqual(branch23.g, 0) self.assertLess(abs(branch23.b + 1. / 0.2), 1e-10) self.assertEqual(branch23.ratingA, 13) self.assertEqual(branch23.ratingB, 13) self.assertEqual(branch23.ratingC, 13) self.assertEqual(branch12.g, 0) self.assertLess(abs(branch12.b + 1. / 0.2), 1e-10) self.assertEqual(branch12.ratingA, 15) self.assertEqual(branch12.ratingB, 15) self.assertEqual(branch12.ratingC, 15) self.assertEqual(gen0.cost_coeff_Q0, 0) self.assertEqual(gen0.cost_coeff_Q1, 6. * net.base_power) self.assertEqual(gen0.cost_coeff_Q2, 0.03 * (net.base_power**2.)) self.assertEqual(gen1.cost_coeff_Q0, 0) self.assertEqual(gen1.cost_coeff_Q1, 5. * net.base_power) self.assertEqual(gen1.cost_coeff_Q2, 0.02 * (net.base_power**2.)) self.assertEqual(gen2.cost_coeff_Q0, 0) self.assertEqual(gen2.cost_coeff_Q1, 12. * net.base_power) self.assertEqual(gen2.cost_coeff_Q2, 0.06 * (net.base_power**2.)) self.assertEqual(gen3.cost_coeff_Q0, 0) self.assertEqual(gen3.cost_coeff_Q1, 10. * net.base_power) self.assertEqual(gen3.cost_coeff_Q2, 0.08 * (net.base_power**2.)) # Load utility self.assertEqual(load0.util_coeff_Q0, 0) self.assertEqual(load0.util_coeff_Q1, 400. * net.base_power) self.assertEqual(load0.util_coeff_Q2, -0.03 * (net.base_power**2.)) self.assertEqual(load1.util_coeff_Q0, 0) self.assertEqual(load1.util_coeff_Q1, 450. * net.base_power) self.assertEqual(load1.util_coeff_Q2, -0.02 * (net.base_power**2.)) self.assertEqual(load2.util_coeff_Q0, 0) self.assertEqual(load2.util_coeff_Q1, 300. * net.base_power) self.assertEqual(load2.util_coeff_Q2, -0.03 * (net.base_power**2.)) def test_sys_problem3(self): for case in test_cases.CASES: if case == './data/sys_problem3.mat': net = pf.ParserMAT().parse(case) self.assertEqual(net.base_power, 100.) # numbers self.assertEqual(net.num_buses, 10) self.assertEqual(net.num_generators, 5) self.assertEqual(net.num_loads, 10) self.assertEqual(net.num_shunts, 0) self.assertEqual(net.num_var_generators, 0) self.assertEqual(net.num_branches, 13) # buses bus1 = net.get_bus_from_number(1) bus2 = net.get_bus_from_number(2) bus3 = net.get_bus_from_number(3) bus4 = net.get_bus_from_number(4) bus5 = net.get_bus_from_number(5) bus6 = net.get_bus_from_number(6) bus7 = net.get_bus_from_number(7) bus8 = net.get_bus_from_number(8) bus9 = net.get_bus_from_number(9) bus10 = net.get_bus_from_number(10) for bus in net.buses: self.assertEqual(bus.v_base, 69.) # loads for bus in net.buses: self.assertEqual(len(bus.loads), 1) load1 = bus1.loads[0] load2 = bus2.loads[0] load3 = bus3.loads[0] load4 = bus4.loads[0] load5 = bus5.loads[0] load6 = bus6.loads[0] load7 = bus7.loads[0] load8 = bus8.loads[0] load9 = bus9.loads[0] load10 = bus10.loads[0] self.assertEqual(load1.bus, bus1) self.assertEqual(load2.bus, bus2) self.assertEqual(load3.bus, bus3) self.assertEqual(load4.bus, bus4) self.assertEqual(load5.bus, bus5) self.assertEqual(load6.bus, bus6) self.assertEqual(load7.bus, bus7) self.assertEqual(load8.bus, bus8) self.assertEqual(load9.bus, bus9) self.assertEqual(load10.bus, bus10) self.assertEqual(load1.P, 55. / 100.) self.assertEqual(load2.P, 55 / 100.) self.assertEqual(load3.P, 1300 / 100.) self.assertEqual(load4.P, 650 / 100.) self.assertEqual(load5.P, 650 / 100.) self.assertEqual(load6.P, 200 / 100.) self.assertEqual(load7.P, 2600 / 100.) self.assertEqual(load8.P, 3600 / 100.) self.assertEqual(load9.P, 1100 / 100.) self.assertEqual(load10.P, 1900 / 100.) for load in net.loads: self.assertEqual(load.P_max, load.P) self.assertEqual(load.P_min, load.P) # generators self.assertEqual(len(bus1.generators), 0) self.assertEqual(len(bus2.generators), 1) self.assertEqual(len(bus3.generators), 1) self.assertEqual(len(bus4.generators), 0) self.assertEqual(len(bus5.generators), 1) self.assertEqual(len(bus6.generators), 0) self.assertEqual(len(bus7.generators), 1) self.assertEqual(len(bus8.generators), 1) self.assertEqual(len(bus9.generators), 0) self.assertEqual(len(bus10.generators), 0) gen1 = bus2.generators[0] gen2 = bus3.generators[0] gen3 = bus5.generators[0] gen4 = bus7.generators[0] gen5 = bus8.generators[0] self.assertEqual(gen1.bus, bus2) self.assertEqual(gen2.bus, bus3) self.assertEqual(gen3.bus, bus5) self.assertEqual(gen4.bus, bus7) self.assertEqual(gen5.bus, bus8) self.assertEqual(gen1.P, 50. / 100.) self.assertEqual(gen1.P_min, 0) self.assertEqual(gen1.P_max, 1200. / 100.) self.assertEqual(gen1.cost_coeff_Q0, 0) self.assertEqual(gen1.cost_coeff_Q1, 6.9 * 100) self.assertEqual(gen1.cost_coeff_Q2, 0.00067 * (100**2.)) self.assertEqual(gen2.P, 40. / 100.) self.assertEqual(gen2.P_min, 0) self.assertEqual(gen2.P_max, 8000. / 100.) self.assertEqual(gen2.cost_coeff_Q0, 0) self.assertEqual(gen2.cost_coeff_Q1, 24.3 * 100) self.assertEqual(gen2.cost_coeff_Q2, 0.00040 * (100**2.)) self.assertEqual(gen3.P, 30. / 100.) self.assertEqual(gen3.P_min, 0) self.assertEqual(gen3.P_max, 3000. / 100.) self.assertEqual(gen3.cost_coeff_Q0, 0) self.assertEqual(gen3.cost_coeff_Q1, 29.1 * 100) self.assertEqual(gen3.cost_coeff_Q2, 0.00006 * (100**2.)) self.assertEqual(gen4.P, 20. / 100.) self.assertEqual(gen4.P_min, 0) self.assertEqual(gen4.P_max, 800. / 100.) self.assertEqual(gen4.cost_coeff_Q0, 0) self.assertEqual(gen4.cost_coeff_Q1, 6.9 * 100) self.assertEqual(gen4.cost_coeff_Q2, 0.00026 * (100**2.)) self.assertEqual(gen5.P, 10. / 100.) self.assertEqual(gen5.P_min, 0) self.assertEqual(gen5.P_max, 2000. / 100.) self.assertEqual(gen5.cost_coeff_Q0, 0) self.assertEqual(gen5.cost_coeff_Q1, 50. * 100) self.assertEqual(gen5.cost_coeff_Q2, 0.0015 * (100**2.)) # branches branch1 = net.get_branch(12) branch2 = net.get_branch(11) branch3 = net.get_branch(10) branch4 = net.get_branch(9) branch5 = net.get_branch(8) branch6 = net.get_branch(7) branch7 = net.get_branch(6) branch8 = net.get_branch(5) branch9 = net.get_branch(4) branch10 = net.get_branch(3) branch11 = net.get_branch(2) branch12 = net.get_branch(1) branch13 = net.get_branch(0) self.assertEqual(branch1.bus_k, bus1) self.assertEqual(branch1.bus_m, bus3) self.assertLess(abs(branch1.b + 1. / 0.1), 1e-10) self.assertEqual(branch1.ratingA, 3000. / 100.) self.assertEqual(branch1.ratingB, 3000. / 100.) self.assertEqual(branch1.ratingC, 3000. / 100.) self.assertEqual(branch2.bus_k, bus1) self.assertEqual(branch2.bus_m, bus10) self.assertLess(abs(branch2.b + 1. / 0.27), 1e-10) self.assertEqual(branch2.ratingA, 2000. / 100.) self.assertEqual(branch2.ratingB, 2000. / 100.) self.assertEqual(branch2.ratingC, 2000. / 100.) self.assertEqual(branch3.bus_k, bus2) self.assertEqual(branch3.bus_m, bus3) self.assertLess(abs(branch3.b + 1. / 0.12), 1e-10) self.assertEqual(branch3.ratingA, 6500. / 100.) self.assertEqual(branch3.ratingB, 6500. / 100.) self.assertEqual(branch3.ratingC, 6500. / 100.) self.assertEqual(branch4.bus_k, bus2) self.assertEqual(branch4.bus_m, bus9) self.assertLess(abs(branch4.b + 1. / 0.07), 1e-10) self.assertEqual(branch4.ratingA, 5500. / 100.) self.assertEqual(branch4.ratingB, 5500. / 100.) self.assertEqual(branch4.ratingC, 5500. / 100.) self.assertEqual(branch5.bus_k, bus2) self.assertEqual(branch5.bus_m, bus10) self.assertLess(abs(branch5.b + 1. / 0.14), 1e-10) self.assertEqual(branch5.ratingA, 5500. / 100.) self.assertEqual(branch5.ratingB, 5500. / 100.) self.assertEqual(branch5.ratingC, 5500. / 100.) self.assertEqual(branch6.bus_k, bus3) self.assertEqual(branch6.bus_m, bus4) self.assertLess(abs(branch6.b + 1. / 0.1), 1e-10) self.assertEqual(branch6.ratingA, 3000. / 100.) self.assertEqual(branch6.ratingB, 3000. / 100.) self.assertEqual(branch6.ratingC, 3000. / 100.) self.assertEqual(branch7.bus_k, bus3) self.assertEqual(branch7.bus_m, bus5) self.assertLess(abs(branch7.b + 1. / 0.17), 1e-10) self.assertEqual(branch7.ratingA, 4000. / 100.) self.assertEqual(branch7.ratingB, 4000. / 100.) self.assertEqual(branch7.ratingC, 4000. / 100.) self.assertEqual(branch8.bus_k, bus4) self.assertEqual(branch8.bus_m, bus5) self.assertLess(abs(branch8.b + 1. / 0.17), 1e-10) self.assertEqual(branch8.ratingA, 4000. / 100.) self.assertEqual(branch8.ratingB, 4000. / 100.) self.assertEqual(branch8.ratingC, 4000. / 100.) self.assertEqual(branch9.bus_k, bus5) self.assertEqual(branch9.bus_m, bus6) self.assertLess(abs(branch9.b + 1. / 0.17), 1e-10) self.assertEqual(branch9.ratingA, 5000. / 100.) self.assertEqual(branch9.ratingB, 5000. / 100.) self.assertEqual(branch9.ratingC, 5000. / 100.) self.assertEqual(branch10.bus_k, bus6) self.assertEqual(branch10.bus_m, bus7) self.assertLess(abs(branch10.b + 1. / 0.16), 1e-10) self.assertEqual(branch10.ratingA, 2000. / 100.) self.assertEqual(branch10.ratingB, 2000. / 100.) self.assertEqual(branch10.ratingC, 2000. / 100.) self.assertEqual(branch11.bus_k, bus7) self.assertEqual(branch11.bus_m, bus8) self.assertLess(abs(branch11.b + 1. / 0.25), 1e-10) self.assertEqual(branch11.ratingA, 3000. / 100.) self.assertEqual(branch11.ratingB, 3000. / 100.) self.assertEqual(branch11.ratingC, 3000. / 100.) self.assertEqual(branch12.bus_k, bus8) self.assertEqual(branch12.bus_m, bus9) self.assertLess(abs(branch12.b + 1. / 0.25), 1e-10) self.assertEqual(branch12.ratingA, 2500. / 100.) self.assertEqual(branch12.ratingB, 2500. / 100.) self.assertEqual(branch12.ratingC, 2500. / 100.) self.assertEqual(branch13.bus_k, bus8) self.assertEqual(branch13.bus_m, bus10) self.assertLess(abs(branch13.b + 1. / 0.07), 1e-10) self.assertEqual(branch13.ratingA, 4000. / 100.) self.assertEqual(branch13.ratingB, 4000. / 100.) self.assertEqual(branch13.ratingC, 4000. / 100.) def test_cas32art(self): for case in test_cases.CASES: if case == './data/case32.art': net = pf.ParserART().parse(case) self.assertEqual(net.num_buses, 31) self.assertEqual(net.num_batteries, 3) b1 = net.get_battery(0) b2 = net.get_battery(1) b3 = net.get_battery(2) self.assertRaises(pf.NetworkError, net.get_battery, 3) self.assertEqual(b1.bus.name, "N18") self.assertEqual(b1.index, 0) self.assertTrue( all( list( map(lambda y: isinstance(y, pf.Battery), b1.bus.batteries)))) self.assertEqual(len(b1.bus.batteries), 2) self.assertEqual( list(map(lambda y: y.index, b1.bus.batteries)), [b1.index, b2.index]) self.assertEqual(b1.P, 6. / net.base_power) self.assertEqual(b1.P_min, -7. / net.base_power) self.assertEqual(b1.P_max, 8. / net.base_power) self.assertEqual(b1.E, 14. / net.base_power) self.assertEqual(b1.E_max, 22. / net.base_power) self.assertEqual(b1.eta_c, 0.93) self.assertEqual(b1.eta_d, 0.97) self.assertEqual(b2.bus.name, "N18") self.assertEqual(b2.index, 1) self.assertTrue( all( list( map(lambda y: isinstance(y, pf.Battery), b2.bus.batteries)))) self.assertEqual(len(b2.bus.batteries), 2) self.assertEqual( list(map(lambda y: y.index, b2.bus.batteries)), [b1.index, b2.index]) self.assertEqual(b2.P, 3. / net.base_power) self.assertEqual(b2.P_min, -3. / net.base_power) self.assertEqual(b2.P_max, 9. / net.base_power) self.assertEqual(b2.E, 12. / net.base_power) self.assertEqual(b2.E_max, 21. / net.base_power) self.assertEqual(b2.eta_c, 0.94) self.assertEqual(b2.eta_d, 0.92) self.assertEqual(b3.bus.name, "N15") self.assertEqual(b3.index, 2) self.assertTrue( all( list( map(lambda y: isinstance(y, pf.Battery), b3.bus.batteries)))) self.assertEqual(len(b3.bus.batteries), 1) self.assertEqual( list(map(lambda y: y.index, b3.bus.batteries)), [b3.index]) self.assertEqual(b3.P, 2. / net.base_power) self.assertEqual(b3.P_min, -4. / net.base_power) self.assertEqual(b3.P_max, 5. / net.base_power) self.assertEqual(b3.E, 10. / net.base_power) self.assertEqual(b3.E_max, 20. / net.base_power) self.assertEqual(b3.eta_c, 0.95) self.assertEqual(b3.eta_d, 0.93) def test_ieee14_gen_cost(self): for case in test_cases.CASES: if case == './data/ieee14.mat': net = pf.ParserMAT().parse(case) self.assertEqual(net.base_power, 100.) self.assertEqual(net.num_buses, 14) self.assertEqual(net.num_generators, 5) gen0 = net.get_generator(net.num_generators - 1) gen1 = net.get_generator(net.num_generators - 2) self.assertEqual(gen0.P, 232.4 / 100.) self.assertEqual(gen0.cost_coeff_Q2, (4.3029259900e-02) * (net.base_power**2.)) self.assertEqual(gen0.cost_coeff_Q1, 20. * net.base_power) self.assertEqual(gen1.P, 40. / 100.) self.assertEqual(gen1.cost_coeff_Q2, 0.25 * (net.base_power**2.)) self.assertEqual(gen1.cost_coeff_Q1, 20. * net.base_power) def test_type_parsers(self): for case in test_cases.CASES: if case.split('.')[-1] == 'mat': self.assertRaises(pf.ParserError, pf.ParserART().parse, case) self.assertRaises(pf.ParserError, pf.ParserJSON().parse, case) if pf.info['raw_parser']: self.assertRaises(pf.ParserError, pf.ParserRAW().parse, case) net = pf.ParserMAT().parse(case) self.assertGreater(net.num_buses, 0) elif case.split('.')[-1] == 'art': self.assertRaises(pf.ParserError, pf.ParserMAT().parse, case) self.assertRaises(pf.ParserError, pf.ParserJSON().parse, case) if pf.info['raw_parser']: self.assertRaises(pf.ParserError, pf.ParserRAW().parse, case) net = pf.ParserART().parse(case) self.assertGreater(net.num_buses, 0) elif case.split('.')[-1] == 'raw': self.assertRaises(pf.ParserError, pf.ParserMAT().parse, case) self.assertRaises(pf.ParserError, pf.ParserART().parse, case) self.assertRaises(pf.ParserError, pf.ParserJSON().parse, case) if pf.info['raw_parser']: net = pf.ParserRAW().parse(case) self.assertGreater(net.num_buses, 0)
def main(): # Power Flow Case rawFile = r"D:\Box Sync\Box Sync\VCA\RTS_33.raw" #rawFile = r"D:\Box Sync\Box Sync\VCA\2383wp_psse.raw" #rawFile = r"D:\Box Sync\Box Sync\VCA\2383_gen_fix.raw" # Output CSV file outFile = r"D:\Box Sync\Box Sync\VCA\SI_QRES\si_rts_redo.csv" #outFile = r"D:\Box Sync\Box Sync\VCA\SI_QRES\si_2383fix.csv" # Initalizing gridopt solver method = gridopt.power_flow.new_method('ACPF') method.set_parameters({'solver': 'nr', 'limit_vars': True, 'quiet': True}) # Parse RAW file to PFNET network parser_raw = pfnet.ParserRAW() net_o = parser_raw.parse(rawFile) # Load VCA Solutions vcaFile = r"D:\Box Sync\Box Sync\VCA\RTS_33_sklearn-spectral_3_8_500.csv" #vcaFile = r"D:\Box Sync\Box Sync\VCA\PolandWinterVCASample.csv" #solNum = 5 # Remember zero indexing! vcaSol = pd.read_csv(vcaFile) #for solNum in range(1): for solNum in range(len(vcaSol.index)): # Create a list of buses in each VCAaa numVcas = vcaSol['num vcas'][solNum] vcaBuses = [] for vca_k in range(numVcas): vcas_k = [] for bus_i in net_o.buses: iNum = bus_i.number if vcaSol[str(iNum)][solNum] == vca_k: vcas_k.append(bus_i.index) vcaBuses.append(vcas_k) # Solve original network method.solve(net_o) method.update_network(net_o) # Calculate the generator reactive power injections (original) Q_o = [] for gen_i in net_o.generators: Q_o.append(gen_i.Q) # Determining initial paramerters for binary search maxStress = 0 for gen_i in net_o.generators: maxStress = maxStress + gen_i.P_max lambda_l = 1.0 mu_l = 1.0 lambda_g = 1.0 Rmin = [] R = [] SI = [] critBus = [] for k in range(numVcas): # Initialize binary search variables S_u = maxStress S_l = 0 S_err = 0.35 / net_o.base_power # Find largest contingency (largest generator in VCA) max = 0 for gen_i in net_o.generators: if (vcaSol[str(gen_i.bus.number)][solNum] == k): if gen_i.P_max > max: max = gen_i.P_max contInd = gen_i.index critBus.append(net_o.get_generator(contInd).bus.number) # Running binary search to find maximum stress with contingency while abs(S_u - S_l) > S_err: # Set S to the floored integer (S_u+S_l)/2 S = (S_u + S_l) / 2 # Create a new case to run stresses net_c = parser_raw.parse(rawFile) # Update load/generator values based on stress (S) for load_i in net_o.loads: if (vcaSol[str(load_i.bus.number)][solNum] == k): iNum = load_i.index cLoad = net_c.get_load(iNum) cLoad.P = load_i.P + lambda_l * S cLoad.Q = load_i.Q + mu_l * S for gen_i in net_o.generators: if (vcaSol[str(gen_i.bus.number)][solNum] == k): iNum = gen_i.index cGen = net_c.get_generator(iNum) cGen.P = gen_i.P + lambda_g * S if cGen.P > cGen.P_max: cGen.P = cGen.P_max elif cGen.P < cGen.P_min: cGen.P = cGen.P_min # Create contingency contGen = net_c.get_generator(contInd) contGen.outage = True # Run contingency try: method.solve(net_c) except: S_u = S - S_err success = 0 else: if method.results['solver status'] == 'solved': # If S converges, set S_l to (S_u+S_l)/2+1 method.update_network(net_c) S_l = S + S_err success = 1 else: # If S does not converge, set S_u to (S_u+S_l)/2-1 S_u = S - S_err success = 0 # Continuing binary search while not converged while success == 0 and S_u > 0: # Set S to the floored integer (S_u+S_l)/2 S = (S_u + S_l) / 2 # Create a new case to run stresses net_c = parser_raw.parse(rawFile) # Update load/generator values based on stress (S) for load_i in net_o.loads: if (vcaSol[str(load_i.bus.number)][solNum] == k): iNum = load_i.index cLoad = net_c.get_load(iNum) cLoad.P = load_i.P + lambda_l * S cLoad.Q = load_i.Q + mu_l * S for gen_i in net_o.generators: if (vcaSol[str(gen_i.bus.number)][solNum] == k): iNum = gen_i.index cGen = net_c.get_generator(iNum) cGen.P = gen_i.P + lambda_g * S if cGen.P > cGen.P_max: cGen.P = cGen.P_max elif cGen.P < cGen.P_min: cGen.P = cGen.P_min # Create contingency contGen = net_c.get_generator(contInd) contGen.outage = True # Run contingency try: method.solve(net_c) except: S_u = S - S_err success = 0 else: if method.results['solver status'] == 'solved': # If S converges, set S_l to (S_u+S_l)/2+1 method.update_network(net_c) S_l = S + S_err success = 1 else: # If S does not converge, set S_u to (S_u+S_l)/2-1 S_u = S - S_err success = 0 if success == 1: # Calculating pre-contingency reactive power production # Create a new case to run stresses net_c = parser_raw.parse(rawFile) # Creating pre-contingency load/generator values based on stress (S) for load_i in net_o.loads: if (vcaSol[str(load_i.bus.number)][solNum] == k): iNum = load_i.index cLoad = net_c.get_load(iNum) cLoad.P = load_i.P + lambda_l * S cLoad.Q = load_i.Q + mu_l * S for gen_i in net_o.generators: if (vcaSol[str(gen_i.bus.number)][solNum] == k): iNum = gen_i.index cGen = net_c.get_generator(iNum) cGen.P = gen_i.P + lambda_g * S if cGen.P > cGen.P_max: cGen.P = cGen.P_max elif cGen.P < cGen.P_min: cGen.P = cGen.P_min method.solve(net_c) method.update_network(net_c) # Calculate the generator reactive power injections Q_pre = [] for gen_i in net_c.generators: Q_pre.append(gen_i.Q) # Calculating post-contingency reactive power production contGen = net_c.get_generator(contInd) contGen.outage = True method.solve(net_c) method.update_network(net_c) # Calculate the generator reactive power injections Q_post = [] for gen_i in net_c.generators: Q_post.append(gen_i.Q) # Set the tolerance of change that the generators must have cTol = 5.0 / net_o.base_power # Previous 20.0 # Sum reactive reserves pre and post contingency to find Rmin Rmin_k = 0 m = 0 for gen_i in net_o.generators: if (vcaSol[str(gen_i.bus.number)][solNum] == k): if (Q_post[m] - Q_pre[m]) > cTol: Rmin_k = Rmin_k + (Q_post[m] - Q_pre[m]) m = m + 1 Rmin.append(Rmin_k) # Find reactive reserves (R) for original case R_k = 0 m = 0 for gen_i in net_o.generators: if (vcaSol[str(gen_i.bus.number)][solNum] == k): if (Q_post[m] - Q_pre[m]) > cTol: R_k = R_k + (Q_post[m] - Q_o[m]) m = m + 1 R.append(R_k) # Finding overall security index using R and Rmin try: SI.append((R[k] - Rmin[k]) / Rmin[k]) except: SI.append('NAN') else: Rmin.append(0) R.append(0) SI.append('U') print(SI) with open(outFile, 'ab') as f: outLines = [] outLines.append(critBus) outLines.append(Rmin) outLines.append(R) outLines.append(SI) writer = csv.writer(f) writer.writerows(outLines) writer.writerow("")
class TestFACTS(unittest.TestCase): def test_psse_sample_raw_case(self): T = 4 case = os.path.join('data', 'psse_sample_case.raw') if not os.path.isfile(case): raise unittest.SkipTest('file not available') p = pf.ParserRAW() net = p.parse(case, T) # Network self.assertEqual(net.num_buses - net.get_num_star_buses(), 41) self.assertEqual(net.num_facts, 3) f1 = net.get_facts(0) # 153/3006 - 155 (upfc) f2 = net.get_facts(1) # 153/3006 - 0 (statcom) f3 = net.get_facts(2) # 153/3006 - 155 (sssc) self.assertTrue(isinstance(f1, pf.Facts)) self.assertTrue(isinstance(f2, pf.Facts)) self.assertTrue(isinstance(f3, pf.Facts)) self.assertEqual(len(net.facts), 3) self.assertTrue(net.facts[0].is_equal(f1)) self.assertTrue(net.facts[1].is_equal(f2)) self.assertTrue(net.facts[2].is_equal(f3)) self.assertEqual(f2.bus_k.number, 3006) # zi with 153 f = net.get_facts_from_name_and_bus_numbers('FACTS_DVCE_1', 3006, 0) self.assertTrue(f.is_equal(f2)) self.assertFalse(f.is_equal(f1)) self.assertEqual(f.name, 'FACTS_DVCE_1') f = net.get_facts_from_name_and_bus_numbers('FACTS_DVCE_2', 3006, 155) self.assertTrue(f.is_equal(f1)) self.assertFalse(f.is_equal(f2)) self.assertEqual(f.name, 'FACTS_DVCE_2') f = net.get_facts_from_name_and_bus_numbers('FACTS_DVCE_3', 3006, 155) self.assertTrue(f.is_equal(f3)) self.assertFalse(f.is_equal(f2)) self.assertEqual(f.name, 'FACTS_DVCE_3') self.assertEqual(net.get_num_buses_reg_by_facts(), 1) # Types self.assertTrue(f2.is_STATCOM()) self.assertFalse(f2.is_SSSC()) self.assertFalse(f2.is_UPFC()) self.assertFalse(f1.is_STATCOM()) self.assertFalse(f1.is_SSSC()) self.assertTrue(f1.is_UPFC()) self.assertFalse(f3.is_STATCOM()) self.assertTrue(f3.is_SSSC()) self.assertFalse(f3.is_UPFC()) self.assertTrue(f1.is_regulator()) self.assertTrue(f2.is_regulator()) self.assertFalse(f3.is_regulator()) # Bus bus1 = net.get_bus_from_number(3006) bus2 = net.get_bus_from_number(155) self.assertTrue(bus1.is_regulated_by_facts()) self.assertFalse(bus2.is_regulated_by_facts()) self.assertEqual(len(bus1.facts_k), 3) self.assertEqual(len(bus2.facts_k), 0) self.assertEqual(len(bus1.facts_m), 0) self.assertEqual(len(bus2.facts_m), 2) self.assertEqual(len(bus1.facts), 3) self.assertEqual(len(bus2.facts), 2) self.assertTrue(bus1.facts[0].is_equal(f1)) self.assertTrue(bus1.facts[1].is_equal(f2)) self.assertTrue(bus1.facts[2].is_equal(f3)) self.assertTrue(bus2.facts[0].is_equal(f1)) self.assertTrue(bus2.facts[1].is_equal(f3)) self.assertEqual(len(bus1.reg_facts), 2) self.assertEqual(len(bus2.reg_facts), 0) self.assertTrue(bus1.reg_facts[0].is_equal(f1)) self.assertTrue(bus1.reg_facts[1].is_equal(f2)) for t in range(T): self.assertEqual(bus1.v_set[t], 1.015) self.assertEqual(bus2.v_set[t], 1.000) # Facts 153/3006 - 155 (UPFC) self.assertEqual(f1.name, 'FACTS_DVCE_2') self.assertFalse(f1.is_series_link_disabled()) self.assertFalse(f1.is_series_link_bypassed()) self.assertTrue(f1.is_in_normal_series_mode()) self.assertFalse(f1.is_in_constant_series_z_mode()) self.assertFalse(f1.is_in_constant_series_v_mode()) self.assertEqual(f1.num_periods, T) self.assertEqual(f1.obj_type, 'facts') self.assertEqual(f1.index, 0) for t in range(T): self.assertEqual(f1.v_mag_s[t], 0.01) self.assertEqual(f1.v_ang_s[t], 0.01) self.assertEqual(f1.P_k[t], -3.5) self.assertEqual(f1.P_m[t], 3.5) self.assertEqual(f1.Q_k[t], -0.4) self.assertEqual(f1.Q_m[t], 0.4) self.assertEqual(f1.Q_sh[t], 0.) self.assertEqual(f1.Q_s[t], 0.) self.assertEqual(f1.P_dc[t], 0.) self.assertEqual(f1.P_set[t], 3.5) self.assertEqual(f1.Q_set[t], 0.4) self.assertEqual(f1.Q_par, 1.) self.assertEqual(f1.v_max_s, 1.) self.assertEqual(f1.g, 0.) self.assertEqual(f1.b, 0.) self.assertEqual(f1.i_max_s, 0.) self.assertEqual(f1.Q_max_s, pf.FACTS_INF_Q) self.assertEqual(f1.Q_min_s, -pf.FACTS_INF_Q) self.assertEqual(f1.i_max_sh, 0.25) self.assertEqual(f1.Q_max_sh, 0.25) self.assertEqual(f1.Q_min_sh, -0.25) self.assertEqual(f1.P_max_dc, 99.99) self.assertEqual(f1.v_min_m, 0.9) self.assertEqual(f1.v_max_m, 1.1) self.assertEqual(f1.bus_k.number, 3006) self.assertEqual(f1.bus_m.number, 155) # Facts 153/3006 - 0 (STATCOM) self.assertEqual(f2.name, 'FACTS_DVCE_1') self.assertTrue(f2.is_series_link_disabled()) self.assertFalse(f2.is_series_link_bypassed()) self.assertFalse(f2.is_in_normal_series_mode()) self.assertFalse(f2.is_in_constant_series_z_mode()) self.assertFalse(f2.is_in_constant_series_v_mode()) self.assertEqual(f2.num_periods, T) self.assertEqual(f2.obj_type, 'facts') self.assertEqual(f2.index, 1) for t in range(T): self.assertEqual(f2.v_mag_s[t], 0.01) self.assertEqual(f2.v_ang_s[t], 0.01) self.assertEqual(f2.P_k[t], 0.) self.assertEqual(f2.P_m[t], 0.) self.assertEqual(f2.Q_k[t], 0.) self.assertEqual(f2.Q_m[t], 0.) self.assertEqual(f2.Q_sh[t], 0.) self.assertEqual(f2.Q_s[t], 0.) self.assertEqual(f2.P_dc[t], 0.) self.assertEqual(f2.P_set[t], 0.) self.assertEqual(f2.Q_set[t], 0.) self.assertEqual(f2.Q_par, 1.) self.assertEqual(f2.v_max_s, 1.) self.assertEqual(f2.g, 0.) self.assertEqual(f2.b, 0.) self.assertEqual(f2.i_max_s, 0.) self.assertEqual(f2.i_max_sh, 0.5) self.assertEqual(f2.P_max_dc, 1.) self.assertEqual(f2.v_min_m, 0.9263) self.assertEqual(f2.v_max_m, 1.134) self.assertEqual(f2.bus_k.number, 3006) self.assertTrue(f2.bus_m is None) # Facts 153/3006 - 155 (SSSC) self.assertEqual(f3.name, 'FACTS_DVCE_3') self.assertFalse(f3.is_series_link_disabled()) self.assertFalse(f3.is_series_link_bypassed()) self.assertTrue(f3.is_in_normal_series_mode()) self.assertFalse(f3.is_in_constant_series_z_mode()) self.assertFalse(f3.is_in_constant_series_v_mode()) self.assertEqual(f3.num_periods, T) self.assertEqual(f3.obj_type, 'facts') self.assertEqual(f3.index, 2) self.assertEqual(f3.i_max_sh, 0.) self.assertEqual(f3.P_max_dc, 0.)
def test_psse_sample_raw_case(self): T = 4 case = os.path.join('data', 'psse_sample_case.raw') if os.path.isfile(case): p = pf.ParserRAW() net = p.parse(case, T) self.assertGreater(net.num_buses, 0) self.assertEqual( len([br for br in net.branches if br.has_y_correction()]), 4) star_bus = None for bus in net.buses: if not bus.is_star(): continue for br in bus.branches: if br.bus_k.number == 3010 or br.bus_m.number == 3010: star_bus = bus self.assertTrue(star_bus is not None) br1 = net.get_branch_from_name_and_bus_numbers( 'T4', # ratio-based 152, 3021) br2 = net.get_branch_from_name_and_bus_numbers( 'T7', # phase-based 203, 202) br3 = net.get_branch_from_name_and_bus_numbers( '11', # ratio-based 3008, 3018) br4 = net.get_branch_from_name_and_bus_numbers( '2', # phase-based 3010, star_bus.number) for br in [br1, br2, br3, br4]: self.assertTrue(br.has_y_correction()) ycorr1 = br1.y_correction ycorr2 = br2.y_correction ycorr3 = br3.y_correction ycorr4 = br4.y_correction for ycorr in [ycorr1, ycorr2, ycorr3, ycorr4]: self.assertTrue(isinstance(ycorr, pf.BranchYCorrection)) self.assertEqual(ycorr.max_num_values, 20) self.assertTrue(isinstance(ycorr.values, np.ndarray)) self.assertTrue(isinstance(ycorr.corrections, np.ndarray)) self.assertEqual(ycorr.num_values, 11) self.assertEqual(ycorr.values.size, 11) self.assertEqual(ycorr.corrections.size, 11) for ycorr in [ycorr2, ycorr4]: self.assertTrue(ycorr.is_based_on_phase_shift()) self.assertFalse(ycorr.is_based_on_tap_ratio()) for ycorr in [ycorr1, ycorr3]: self.assertFalse(ycorr.is_based_on_phase_shift()) self.assertTrue(ycorr.is_based_on_tap_ratio()) self.assertEqual(ycorr1.name, 'Y Correction 2') self.assertEqual(ycorr2.name, 'Y Correction 1') self.assertEqual(ycorr3.name, 'Y Correction 2') self.assertEqual(ycorr4.name, 'Y Correction 1') raw1_val = [ -30.00, -24.00, -18.00, -12.00, -6.00, 0.00, 6.00, 12.00, 18.00, 24.00, 30.00 ] raw1_cor = [ 1.10000, 1.09100, 1.08400, 1.06300, 1.03200, 1.00000, 1.03000, 1.06000, 1.08000, 1.09000, 1.11000 ] raw2_val = [ 0.60000, 0.70000, 0.80000, 0.90000, 0.95000, 1.00000, 1.05000, 1.10000, 1.20000, 1.30000, 1.40000 ] raw2_cor = [ 1.06000, 1.05000, 1.04000, 1.03000, 1.02000, 1.01000, 0.99000, 0.98000, 0.97000, 0.96000, 0.95000 ] for ycorr in [ycorr2, ycorr4]: for i in range(10): self.assertTrue(ycorr.values[i] < ycorr.values[i + 1]) for i in range(11): self.assertLess( np.abs(ycorr.values[i] * 180. / np.pi - raw1_val[i]), 1e-8) self.assertLess( np.abs(ycorr.corrections[i] - 1. / raw1_cor[i]), 1e-8) for ycorr in [ycorr1, ycorr3]: t2 = 1. for i in range(10): self.assertTrue(ycorr.values[i] < ycorr.values[i + 1]) for i in range(11): self.assertLess( np.abs(ycorr.corrections[i] - 1. / raw2_cor[11 - i - 1]), 1e-8) self.assertLess( np.abs(ycorr.values[i] - t2 / raw2_val[11 - i - 1]), 1e-8)
def test_aeso_raw_case(self): T = 4 case = os.path.join('data', 'aesoSL2014.raw') if os.path.isfile(case): net = pf.ParserRAW().parse(case, T) self.assertGreater(net.num_buses, 0) self.assertEqual( len([br for br in net.branches if br.has_y_correction()]), 3) br1 = net.get_branch_from_name_and_bus_numbers('PS', 421, 420) br2 = net.get_branch_from_name_and_bus_numbers('PS', 1602, 1288) br3 = net.get_branch_from_name_and_bus_numbers('PS', 656, 229) for br in [br1, br2, br3]: self.assertTrue(br.has_y_correction()) ycorr1 = br1.y_correction ycorr2 = br2.y_correction ycorr3 = br3.y_correction for ycorr in [ycorr1, ycorr2, ycorr3]: self.assertTrue(isinstance(ycorr, pf.BranchYCorrection)) self.assertTrue(ycorr.is_based_on_phase_shift()) self.assertEqual(ycorr.max_num_values, 20) self.assertTrue(isinstance(ycorr.values, np.ndarray)) self.assertTrue(isinstance(ycorr.corrections, np.ndarray)) self.assertEqual(ycorr1.name, 'Y Correction 12') self.assertEqual(ycorr2.name, 'Y Correction 12') self.assertEqual(ycorr3.name, 'Y Correction 13') raw12_val = [ -30.00, -22.90, -18.90, -8.40, -4.20, 0.00, 6.30, 10.50, 18.90, 22.90, 30.00 ] raw12_cor = [ 1.28000, 1.17000, 1.11000, 1.04000, 1.00900, 1.00000, 1.02600, 1.06000, 1.11000, 1.17000, 1.28000 ] raw13_val = [-60.00, -39.70, -24.40, 0.00, 24.40, 39.70, 60.00] raw13_cor = [ 1.57174, 1.26912, 1.10920, 1.00000, 1.11282, 1.27373, 1.57165 ] self.assertEqual(ycorr1.num_values, 11) self.assertEqual(ycorr2.num_values, 11) self.assertEqual(ycorr3.num_values, 7) self.assertEqual(ycorr1.values.size, 11) self.assertEqual(ycorr1.corrections.size, 11) self.assertEqual(ycorr2.values.size, 11) self.assertEqual(ycorr2.corrections.size, 11) self.assertEqual(ycorr3.values.size, 7) self.assertEqual(ycorr3.corrections.size, 7) for i in range(11): self.assertLess( np.abs(ycorr1.values[i] * 180. / np.pi - raw12_val[i]), 1e-8) self.assertLess( np.abs(ycorr1.corrections[i] - 1. / raw12_cor[i]), 1e-8) self.assertLess( np.abs(ycorr2.values[i] * 180. / np.pi - raw12_val[i]), 1e-8) self.assertLess( np.abs(ycorr2.corrections[i] - 1. / raw12_cor[i]), 1e-8) for i in range(7): self.assertLess( np.abs(ycorr3.values[i] * 180. / np.pi - raw13_val[i]), 1e-8) self.assertLess( np.abs(ycorr3.corrections[i] - 1. / raw13_cor[i]), 1e-8)
class TestHVDC(unittest.TestCase): def test_ieee300_raw_case(self): T = 4 case = os.path.join('data', 'ieee300.raw') if not os.path.isfile(case): raise unittest.SkipTest('file not available') net = pf.ParserRAW().parse(case, T) # Buses # Branches # Converters self.assertEqual(net.num_csc_converters, 2) convR = net.csc_converters[0] convI = net.csc_converters[1] self.assertTrue(convR.is_rectifier()) self.assertFalse(convR.is_inverter()) self.assertFalse(convI.is_rectifier()) self.assertTrue(convI.is_inverter()) self.assertEqual(convR.name, "1") self.assertEqual(convI.name, "1") ac_busR = convR.ac_bus dc_busR = convR.dc_bus self.assertEqual(ac_busR.number, 119) self.assertEqual(dc_busR.name, "TTDC 1 bus 0") self.assertEqual(len(ac_busR.csc_converters), 1) self.assertEqual(len(dc_busR.csc_converters), 1) self.assertTrue(ac_busR.csc_converters[0].is_equal(convR)) self.assertTrue(dc_busR.csc_converters[0].is_equal(convR)) self.assertFalse(ac_busR.csc_converters[0].is_equal(convI)) self.assertFalse(dc_busR.csc_converters[0].is_equal(convI)) ac_busI = convI.ac_bus dc_busI = convI.dc_bus self.assertEqual(ac_busI.number, 120) self.assertEqual(dc_busI.name, "TTDC 1 bus 1") self.assertEqual(len(ac_busI.csc_converters), 1) self.assertEqual(len(dc_busI.csc_converters), 1) self.assertTrue(ac_busI.csc_converters[0].is_equal(convI)) self.assertTrue(dc_busI.csc_converters[0].is_equal(convI)) self.assertFalse(ac_busI.csc_converters[0].is_equal(convR)) self.assertFalse(dc_busI.csc_converters[0].is_equal(convR)) self.assertTrue( convR.is_equal( net.get_csc_converter_from_name_and_ac_bus_number( convR.name, ac_busR.number))) self.assertTrue( convR.is_equal( net.get_csc_converter_from_name_and_dc_bus_name( convR.name, dc_busR.name))) self.assertTrue( convI.is_equal( net.get_csc_converter_from_name_and_ac_bus_number( convI.name, ac_busI.number))) self.assertTrue( convI.is_equal( net.get_csc_converter_from_name_and_dc_bus_name( convI.name, dc_busI.name))) self.assertTrue(convR.is_in_P_dc_mode()) self.assertFalse(convR.is_in_i_dc_mode()) self.assertFalse(convR.is_in_v_dc_mode()) self.assertFalse(convI.is_in_P_dc_mode()) self.assertFalse(convI.is_in_i_dc_mode()) self.assertTrue(convI.is_in_v_dc_mode()) for t in range(T): v_base = dc_busR.v_base idc = (dc_busR.v[t] - dc_busI.v[t]) * v_base / 6.2 # kA self.assertLess(np.abs(idc * dc_busI.v[t] * v_base - 100.), 1e-10) self.assertLess( np.abs(convR.P_dc_set[t] * net.base_power - idc * dc_busR.v[t] * v_base), 1e-10) self.assertEqual(convR.i_dc_set[t], 0.) self.assertEqual(convR.v_dc_set[t], 0.) self.assertEqual(convI.P_dc_set[t], 0.) idc = -convI.i_dc_set[t] / (1. - 0.1) # p.u. rcomp = 0.0 / (dc_busI.v_base**2. / net.base_power) vschd = (convI.v_dc_set[t] + idc * rcomp) * dc_busI.v_base self.assertEqual(vschd, 460.) self.assertLess(np.abs(convR.P[t] + dc_busR.v[t] * idc), 1e-10) self.assertLess(np.abs(convI.P[t] - dc_busI.v[t] * idc), 1e-10) self.assertLess( np.abs( np.tan(np.arccos(np.minimum(dc_busR.v[t], 1.))) * convR.P[t] - convR.Q[t]), 1e-10) self.assertLess( np.abs( np.tan(np.arccos(np.minimum(dc_busI.v[t], 1.))) * convI.P[t] + convI.Q[t]), 1e-10)
np.tan(np.arccos(np.minimum(dc_busR.v[t], 1.))) * convR.P[t] - convR.Q[t]), 1e-10) self.assertLess( np.abs( np.tan(np.arccos(np.minimum(dc_busI.v[t], 1.))) * convI.P[t] + convI.Q[t]), 1e-10) def test_GSO_5bus_ttdc_case(self): T = 4 case = os.path.join('data', 'GSO_5bus_ttdc.raw') if not os.path.isfile(case): raise unittest.SkipTest('file not available') net = pf.ParserRAW().parse(case, T) # Buses self.assertEqual(net.num_dc_buses, 2) self.assertEqual(net.get_num_dc_buses(), 2) self.assertEqual(len(net.dc_buses), 2) bus1 = net.dc_buses[0] bus2 = net.dc_buses[1] self.assertEqual(bus1.index, 0) self.assertEqual(bus2.index, 1) self.assertEqual(bus1.number, 0) self.assertEqual(bus2.number, 1)
br2 = net.get_branch_from_name_and_bus_numbers('2', 153, 154) self.assertTrue(br1.is_equal(br2)) br3 = net.get_branch_from_name_and_bus_numbers('1', 3006, 3005) br4 = net.get_branch_from_name_and_bus_numbers('1', 153, 3005) self.assertTrue(br3.is_equal(br4)) else: raise unittest.SkipTest('no .raw file') def test_aeso(self): case = os.path.join('data', 'aesoSL2014.raw') if not os.path.isfile(case): raise unittest.SkipTest('no .raw file') parser = pf.ParserRAW() net1 = parser.parse(case) for bus in net1.buses: bus.v_mag = bus.v_mag + 0.1 net1_copy = net1.get_copy() net1_copy.update_properties() pf.tests.utils.compare_networks(self, net1, net1_copy) self.assertEqual(net1.num_buses, 2495) self.assertEqual(net1.num_branches, 2823) self.assertEqual(net1.get_num_zero_impedance_lines(), 42) self.assertEqual(net1.get_num_ZI_lines(), 42)