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)