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)