class DCOPFTest(unittest.TestCase):
""" Defines a test case for DC OPF.
"""
def __init__(self, methodName='runTest'):
super(DCOPFTest, self).__init__(methodName)
#: Name of the folder in which the MatrixMarket data exists.
self.case_name = "case6ww"
self.case = None
self.opf = None
def setUp(self):
""" The test runner will execute this method prior to each test.
"""
self.case = Case.load(join(DATA_DIR, self.case_name,
self.case_name + ".pkl"))
self.opf = OPF(self.case, dc=True)
def testVa(self):
""" Test voltage angle variable.
"""
msg = self.case_name
bs, _, _ = self.opf._remove_isolated(self.case)
_, refs = self.opf._ref_check(self.case)
Va = self.opf._get_voltage_angle_var(refs, bs)
mpVa0 = mmread(join(DATA_DIR, self.case_name, "opf", "Va0.mtx"))
mpVal = mmread(join(DATA_DIR, self.case_name, "opf", "Val.mtx"))
mpVau = mmread(join(DATA_DIR, self.case_name, "opf", "Vau.mtx"))
self.assertTrue(mfeq1(Va.v0, mpVa0.flatten()), msg)
self.assertTrue(mfeq1(Va.vl, mpVal.flatten()), msg)
self.assertTrue(mfeq1(Va.vu, mpVau.flatten()), msg)
def testVm(self):
""" Test voltage magnitude variable.
"""
bs, _, gn = self.opf._remove_isolated(self.case)
Vm = self.opf._get_voltage_magnitude_var(bs, gn)
mpVm0 = mmread(join(DATA_DIR, self.case_name, "opf", "Vm0.mtx"))
self.assertTrue(mfeq1(Vm.v0, mpVm0.flatten()), self.case_name)
def testPg(self):
""" Test active power variable.
"""
msg = self.case_name
self.case.sort_generators() # ext2int
_, _, gn = self.opf._remove_isolated(self.case)
Pg = self.opf._get_pgen_var(gn, self.case.base_mva)
mpPg0 = mmread(join(DATA_DIR, self.case_name, "opf", "Pg0.mtx"))
mpPmin = mmread(join(DATA_DIR, self.case_name, "opf", "Pmin.mtx"))
mpPmax = mmread(join(DATA_DIR, self.case_name, "opf", "Pmax.mtx"))
self.assertTrue(mfeq1(Pg.v0, mpPg0.flatten()), msg)
self.assertTrue(mfeq1(Pg.vl, mpPmin.flatten()), msg)
self.assertTrue(mfeq1(Pg.vu, mpPmax.flatten()), msg)
def testQg(self):
""" Test reactive power variable.
"""
msg = self.case_name
self.case.sort_generators() # ext2int
_, _, gn = self.opf._remove_isolated(self.case)
Qg = self.opf._get_qgen_var(gn, self.case.base_mva)
mpQg0 = mmread(join(DATA_DIR, self.case_name, "opf", "Qg0.mtx"))
mpQmin = mmread(join(DATA_DIR, self.case_name, "opf", "Qmin.mtx"))
mpQmax = mmread(join(DATA_DIR, self.case_name, "opf", "Qmax.mtx"))
self.assertTrue(mfeq1(Qg.v0, mpQg0.flatten()), msg)
self.assertTrue(mfeq1(Qg.vl, mpQmin.flatten()), msg)
# self.assertTrue(mfeq1(Qg.vu, mpQmax.flatten()), msg)
self.assertTrue(mfeq1(Qg.vu, mpQmax.flatten()), msg)
def testPmis(self):
""" Test active power mismatch constraints.
"""
msg = self.case_name
case = self.case
case.sort_generators() # ext2int
B, _, Pbusinj, _ = case.Bdc
bs, _, gn = self.opf._remove_isolated(case)
Pmis = self.opf._power_mismatch_dc(bs, gn, B, Pbusinj, case.base_mva)
mpAmis = mmread(join(DATA_DIR, self.case_name, "opf", "Amis.mtx"))
mpbmis = mmread(join(DATA_DIR, self.case_name, "opf", "bmis.mtx"))
self.assertTrue(mfeq2(Pmis.A, mpAmis.tocsr(), 1e-12), msg)
self.assertTrue(mfeq1(Pmis.l, mpbmis.flatten()), msg)
self.assertTrue(mfeq1(Pmis.u, mpbmis.flatten()), msg)
def testPfPt(self):
""" Test branch flow limit constraints.
"""
msg = self.case_name
_, ln, _ = self.opf._remove_isolated(self.case)
_, Bf, _, Pfinj = self.case.Bdc
Pf, Pt = self.opf._branch_flow_dc(ln, Bf, Pfinj, self.case.base_mva)
lpf = mmread(join(DATA_DIR, self.case_name, "opf", "lpf.mtx"))
upf = mmread(join(DATA_DIR, self.case_name, "opf", "upf.mtx"))
upt = mmread(join(DATA_DIR, self.case_name, "opf", "upt.mtx"))
self.assertTrue(mfeq1(Pf.l, lpf.flatten()), msg)
self.assertTrue(mfeq1(Pf.u, upf.flatten()), msg)
self.assertTrue(mfeq1(Pt.l, lpf.flatten()), msg)
self.assertTrue(mfeq1(Pt.u, upt.flatten()), msg)
def testVang(self):
""" Test voltage angle difference limit constraint.
"""
msg = self.case_name
self.opf.ignore_ang_lim = False
bs, ln, _ = self.opf._remove_isolated(self.case)
ang = self.opf._voltage_angle_diff_limit(bs, ln)
if ang.A.shape[0] != 0:
Aang = mmread(join(DATA_DIR, self.case_name, "opf", "Aang.mtx"))
else:
Aang = None
lang = mmread(join(DATA_DIR, self.case_name, "opf", "lang.mtx"))
uang = mmread(join(DATA_DIR, self.case_name, "opf", "uang.mtx"))
if Aang is not None:
self.assertTrue(mfeq2(ang.A, Aang.tocsr()), msg)
self.assertTrue(mfeq1(ang.l, lang.flatten()), msg)
self.assertTrue(mfeq1(ang.u, uang.flatten()), msg)
def testVLConstPF(self):
""" Test dispatchable load, constant power factor constraints.
"""
msg = self.case_name
_, _, gn = self.opf._remove_isolated(self.case)
vl = self.opf._const_pf_constraints(gn, self.case.base_mva)
if vl.A.shape[0] != 0:
Avl = mmread(join(DATA_DIR, self.case_name, "opf", "Avl.mtx"))
self.assertTrue(mfeq2(vl.A, Avl.tocsr()), msg)
lvl = mmread(join(DATA_DIR, self.case_name, "opf", "lang.mtx"))
self.assertTrue(mfeq1(vl.l, lvl.flatten()), msg)
uvl = mmread(join(DATA_DIR, self.case_name, "opf", "uang.mtx"))
self.assertTrue(mfeq1(vl.u, uvl.flatten()), msg)
# def testPQ(self):
# """ Test generator PQ capability curve constraints.
# """
## Apqh = mmread(join(DATA_DIR, self.case_name, "opf", "Apqh.mtx"))
## ubpqh = mmread(join(DATA_DIR, self.case_name, "opf", "ubpqh.mtx"))
## Apql = mmread(join(DATA_DIR, self.case_name, "opf", "Apql.mtx"))
## ubpql = mmread(join(DATA_DIR, self.case_name, "opf", "ubpql.mtx"))
# self.fail("Generator PQ capability curve constraints not implemented.")
def testAy(self):
""" Test basin constraints for piece-wise linear gen cost variables.
"""
msg = self.case_name
self.case.sort_generators() # ext2int
_, _, gn = self.opf._remove_isolated(self.case)
_, ycon = self.opf._pwl_gen_costs(gn, self.case.base_mva)
if ycon is not None:
Ay = mmread(join(DATA_DIR, self.case_name, "opf", "Ay_DC.mtx"))
by = mmread(join(DATA_DIR, self.case_name, "opf", "by_DC.mtx"))
self.assertTrue(mfeq2(ycon.A, Ay.tocsr()), msg)
self.assertTrue(mfeq1(ycon.u, by.flatten()), msg)
