Example #1
0
 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.case.sort_generators() # ext2int
     self.opf = OPF(self.case, dc=False)
     self.om = self.opf._construct_opf_model(self.case)
     self.solver = PIPSSolver(self.om)
Example #2
0
class PIPSSolverTest(unittest.TestCase):
    """ Defines a test case for the PIPS AC OPF solver.
    """

    def __init__(self, methodName='runTest'):
        super(PIPSSolverTest, self).__init__(methodName)

        self.case_name = "case6ww"
        self.case = None
        self.opf = None
        self.om = None
        self.solver = 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.case.sort_generators() # ext2int
        self.opf = OPF(self.case, dc=False)
        self.om = self.opf._construct_opf_model(self.case)
        self.solver = PIPSSolver(self.om)


    def test_constraints(self):
        """ Test equality and inequality constraints.
        """
        msg = self.case_name
        AA, ll, uu = self.solver._linear_constraints(self.om)

        if AA is not None:
            mpA = mmread(join(DATA_DIR, self.case_name, "opf", "A_AC.mtx"))
            mpl = mmread(join(DATA_DIR, self.case_name, "opf", "l_AC.mtx"))
            mpu = mmread(join(DATA_DIR, self.case_name, "opf", "u_AC.mtx"))

            self.assertTrue(mfeq2(AA, mpA.tocsr()), msg)
            self.assertTrue(mfeq1(ll, mpl.flatten()), msg)
            self.assertTrue(mfeq1(uu, mpu.flatten()), msg)


    def test_var_bounds(self):
        """ Test bounds on optimisation variables.
        """
        msg = self.case_name
        _, xmin, xmax = self.solver._var_bounds()

        mpxmin = mmread(join(DATA_DIR, self.case_name, "opf", "xmin_AC.mtx"))
        mpxmax = mmread(join(DATA_DIR, self.case_name, "opf", "xmax_AC.mtx"))

        self.assertTrue(mfeq1(xmin, mpxmin.flatten()), msg)
        self.assertTrue(mfeq1(xmax, mpxmax.flatten()), msg)


    def test_initial_point(self):
        """ Test selection of an initial interior point.
        """
        b, l, g, _ = self.solver._unpack_model(self.om)
        _, LB, UB = self.solver._var_bounds()
        _, _, _, _, _, ny, _ = self.solver._dimension_data(b, l, g)
        x0 = self.solver._initial_interior_point(b, g, LB, UB, ny)

        mpx0 = mmread(join(DATA_DIR, self.case_name, "opf", "x0_AC.mtx"))

        self.assertTrue(mfeq1(x0, mpx0.flatten()), self.case_name)


    def test_solution(self):
        """ Test AC OPF solution.
        """
        msg = self.case_name
        solution = self.solver.solve()
        lmbda = solution["lmbda"]

        f = mmread(join(DATA_DIR, self.case_name, "opf", "f_AC.mtx"))
        x = mmread(join(DATA_DIR, self.case_name, "opf", "x_AC.mtx"))

        diff = 1e-4

        # FIXME: Improve accuracy.
        self.assertAlmostEqual(solution["f"], f[0], places=3)
        self.assertTrue(mfeq1(solution["x"], x.flatten(), diff))

        if len(lmbda["mu_l"]) > 0:
            mu_l = mmread(join(DATA_DIR, self.case_name, "opf", "mu_l_AC.mtx"))
            self.assertTrue(mfeq1(lmbda["mu_l"], mu_l.flatten(), diff), msg)

        if len(lmbda["mu_u"]) > 0:
            mu_u = mmread(join(DATA_DIR, self.case_name, "opf", "mu_u_AC.mtx"))
            self.assertTrue(mfeq1(lmbda["mu_u"], mu_u.flatten(), diff), msg)

        if len(lmbda["lower"]) > 0:
            muLB = mmread(join(DATA_DIR, self.case_name, "opf", "muLB_AC.mtx"))
            # FIXME: Improve accuracy.
            self.assertTrue(mfeq1(lmbda["lower"], muLB.flatten(), diff), msg)

        if len(lmbda["upper"]) > 0:
            muUB = mmread(join(DATA_DIR, self.case_name, "opf", "muUB_AC.mtx"))
            # FIXME: Improve accuracy.
            self.assertTrue(mfeq1(lmbda["upper"], muUB.flatten(), diff), msg)

#        if len(lmbda["nl_mu_l"]) > 0:
#            nl_mu_l = mmread(
#                join(DATA_DIR, self.case_name, "opf", "nl_mu_l.mtx"))
#            self.assertTrue(
#                mfeq1(lmbda["nl_mu_l"], nl_mu_l.flatten()), msg)
#
#        if len(lmbda["nl_mu_l"]) > 0:
#            nl_mu_u = mmread(
#                join(DATA_DIR, self.case_name, "opf", "nl_mu_u.mtx"))
#            self.assertTrue(
#                mfeq1(lmbda["nl_mu_u"], nl_mu_u.flatten()), msg)


    def test_integrate_solution(self):
        """ Test integration of AC OPF solution.
        """
        self.solver.solve()

        bus = mmread(join(DATA_DIR, self.case_name, "opf", "Bus_AC.mtx"))
        gen = mmread(join(DATA_DIR, self.case_name, "opf", "Gen_AC.mtx"))
        branch = mmread(join(DATA_DIR, self.case_name, "opf", "Branch_AC.mtx"))

        # FIXME: Improve accuracy.
        pl = 4

        # bus_i type Pd Qd Gs Bs area Vm Va baseKV zone Vmax Vmin lam_P lam_Q mu_Vmax mu_Vmin
        for i, bs in enumerate(self.case.buses):
            self.assertAlmostEqual(bs.v_magnitude, bus[i, 7], pl) # Vm
            self.assertAlmostEqual(bs.v_angle, bus[i, 8], pl) # Va
            self.assertAlmostEqual(bs.p_lmbda, bus[i, 13], pl) # lam_P
            self.assertAlmostEqual(bs.q_lmbda, bus[i, 14], pl) # lam_Q
            # FIXME: Improve accuracy
            self.assertAlmostEqual(bs.mu_vmax, bus[i, 15], pl) # mu_Vmax
            self.assertAlmostEqual(bs.mu_vmin, bus[i, 16], pl) # mu_Vmin

        # bus Pg Qg Qmax Qmin Vg mBase status Pmax Pmin Pc1 Pc2 Qc1min Qc1max
        # Qc2min Qc2max ramp_agc ramp_10 ramp_30 ramp_q apf mu_Pmax mu_Pmin
        # mu_Qmax mu_Qmin
        for i, gn in enumerate(self.case.generators):
            # FIXME: Improve accuracy
            self.assertAlmostEqual(gn.p, gen[i, 1], pl) # Pg
            self.assertAlmostEqual(gn.q, gen[i, 2], pl) # Qg
            self.assertAlmostEqual(gn.v_magnitude, gen[i, 5], pl) # Vg
            self.assertAlmostEqual(gn.mu_pmax, gen[i, 21], pl) # mu_Pmax
            self.assertAlmostEqual(gn.mu_pmin, gen[i, 22], pl) # mu_Pmin
            self.assertAlmostEqual(gn.mu_qmax, gen[i, 23], pl) # mu_Qmax
            self.assertAlmostEqual(gn.mu_qmin, gen[i, 24], pl) # mu_Qmin

        # fbus tbus r x b rateA rateB rateC ratio angle status angmin angmax
        # Pf Qf Pt Qt mu_Sf mu_St mu_angmin mu_angmax
        for i, ln in enumerate(self.case.branches):
            self.assertAlmostEqual(ln.p_from, branch[i, 13], pl) # Pf
            self.assertAlmostEqual(ln.q_from, branch[i, 14], pl) # Qf
            self.assertAlmostEqual(ln.p_to, branch[i, 15], pl) # Pt
            self.assertAlmostEqual(ln.q_to, branch[i, 16], pl) # Qt
            self.assertAlmostEqual(ln.mu_s_from, branch[i, 17], pl) # mu_Sf
            self.assertAlmostEqual(ln.mu_s_to, branch[i, 18], pl) # mu_St
            self.assertAlmostEqual(ln.mu_angmin, branch[i, 19], pl)
            self.assertAlmostEqual(ln.mu_angmax, branch[i, 20], pl)
Example #3
0
class PIPSSolverTest(unittest.TestCase):
    """ Defines a test case for the PIPS AC OPF solver.
    """

    def __init__(self, methodName='runTest'):
        super(PIPSSolverTest, self).__init__(methodName)

        self.case_name = "case6ww"
        self.case = None
        self.opf = None
        self.om = None
        self.solver = 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.case.sort_generators() # ext2int
        self.opf = OPF(self.case, dc=False)
        self.om = self.opf._construct_opf_model(self.case)
        self.solver = PIPSSolver(self.om)


    def test_constraints(self):
        """ Test equality and inequality constraints.
        """
        msg = self.case_name
        AA, ll, uu = self.solver._linear_constraints(self.om)

        if AA is not None:
            mpA = mmread(join(DATA_DIR, self.case_name, "opf", "A_AC.mtx"))
            mpl = mmread(join(DATA_DIR, self.case_name, "opf", "l_AC.mtx"))
            mpu = mmread(join(DATA_DIR, self.case_name, "opf", "u_AC.mtx"))

            self.assertTrue(mfeq2(AA, mpA.tocsr()), msg)
            self.assertTrue(mfeq1(ll, mpl.flatten()), msg)
            self.assertTrue(mfeq1(uu, mpu.flatten()), msg)


    def test_var_bounds(self):
        """ Test bounds on optimisation variables.
        """
        msg = self.case_name
        _, xmin, xmax = self.solver._var_bounds()

        mpxmin = mmread(join(DATA_DIR, self.case_name, "opf", "xmin_AC.mtx"))
        mpxmax = mmread(join(DATA_DIR, self.case_name, "opf", "xmax_AC.mtx"))

        self.assertTrue(mfeq1(xmin, mpxmin.flatten()), msg)
        self.assertTrue(mfeq1(xmax, mpxmax.flatten()), msg)


    def test_initial_point(self):
        """ Test selection of an initial interior point.
        """
        b, l, g, _ = self.solver._unpack_model(self.om)
        _, LB, UB = self.solver._var_bounds()
        _, _, _, _, _, ny, _ = self.solver._dimension_data(b, l, g)
        x0 = self.solver._initial_interior_point(b, g, LB, UB, ny)

        mpx0 = mmread(join(DATA_DIR, self.case_name, "opf", "x0_AC.mtx"))

        self.assertTrue(mfeq1(x0, mpx0.flatten()), self.case_name)


    def test_solution(self):
        """ Test AC OPF solution.
        """
        msg = self.case_name
        solution = self.solver.solve()
        lmbda = solution["lmbda"]

        f = mmread(join(DATA_DIR, self.case_name, "opf", "f_AC.mtx"))
        x = mmread(join(DATA_DIR, self.case_name, "opf", "x_AC.mtx"))

        diff = 1e-4

        # FIXME: Improve accuracy.
        self.assertAlmostEqual(solution["f"], f[0], places=3)
        self.assertTrue(mfeq1(solution["x"], x.flatten(), diff))

        if len(lmbda["mu_l"]) > 0:
            mu_l = mmread(join(DATA_DIR, self.case_name, "opf", "mu_l_AC.mtx"))
            self.assertTrue(mfeq1(lmbda["mu_l"], mu_l.flatten(), diff), msg)

        if len(lmbda["mu_u"]) > 0:
            mu_u = mmread(join(DATA_DIR, self.case_name, "opf", "mu_u_AC.mtx"))
            self.assertTrue(mfeq1(lmbda["mu_u"], mu_u.flatten(), diff), msg)

        if len(lmbda["lower"]) > 0:
            muLB = mmread(join(DATA_DIR, self.case_name, "opf", "muLB_AC.mtx"))
            # FIXME: Improve accuracy.
            self.assertTrue(mfeq1(lmbda["lower"], muLB.flatten(), diff), msg)

        if len(lmbda["upper"]) > 0:
            muUB = mmread(join(DATA_DIR, self.case_name, "opf", "muUB_AC.mtx"))
            # FIXME: Improve accuracy.
            self.assertTrue(mfeq1(lmbda["upper"], muUB.flatten(), diff), msg)

#        if len(lmbda["nl_mu_l"]) > 0:
#            nl_mu_l = mmread(
#                join(DATA_DIR, self.case_name, "opf", "nl_mu_l.mtx"))
#            self.assertTrue(
#                mfeq1(lmbda["nl_mu_l"], nl_mu_l.flatten()), msg)
#
#        if len(lmbda["nl_mu_l"]) > 0:
#            nl_mu_u = mmread(
#                join(DATA_DIR, self.case_name, "opf", "nl_mu_u.mtx"))
#            self.assertTrue(
#                mfeq1(lmbda["nl_mu_u"], nl_mu_u.flatten()), msg)


    def test_integrate_solution(self):
        """ Test integration of AC OPF solution.
        """
        self.solver.solve()

        bus = mmread(join(DATA_DIR, self.case_name, "opf", "Bus_AC.mtx"))
        gen = mmread(join(DATA_DIR, self.case_name, "opf", "Gen_AC.mtx"))
        branch = mmread(join(DATA_DIR, self.case_name, "opf", "Branch_AC.mtx"))

        # FIXME: Improve accuracy.
        pl = 4

        # bus_i type Pd Qd Gs Bs area Vm Va baseKV zone Vmax Vmin lam_P lam_Q mu_Vmax mu_Vmin
        for i, bs in enumerate(self.case.buses):
            self.assertAlmostEqual(bs.v_magnitude, bus[i, 7], pl) # Vm
            self.assertAlmostEqual(bs.v_angle, bus[i, 8], pl) # Va
            self.assertAlmostEqual(bs.p_lmbda, bus[i, 13], pl) # lam_P
            self.assertAlmostEqual(bs.q_lmbda, bus[i, 14], pl) # lam_Q
            # FIXME: Improve accuracy
            self.assertAlmostEqual(bs.mu_vmax, bus[i, 15], pl) # mu_Vmax
            self.assertAlmostEqual(bs.mu_vmin, bus[i, 16], pl) # mu_Vmin

        # bus Pg Qg Qmax Qmin Vg mBase status Pmax Pmin Pc1 Pc2 Qc1min Qc1max
        # Qc2min Qc2max ramp_agc ramp_10 ramp_30 ramp_q apf mu_Pmax mu_Pmin
        # mu_Qmax mu_Qmin
        for i, gn in enumerate(self.case.generators):
            # FIXME: Improve accuracy
            self.assertAlmostEqual(gn.p, gen[i, 1], pl) # Pg
            self.assertAlmostEqual(gn.q, gen[i, 2], pl) # Qg
            self.assertAlmostEqual(gn.v_magnitude, gen[i, 5], pl) # Vg
            self.assertAlmostEqual(gn.mu_pmax, gen[i, 21], pl) # mu_Pmax
            self.assertAlmostEqual(gn.mu_pmin, gen[i, 22], pl) # mu_Pmin
            self.assertAlmostEqual(gn.mu_qmax, gen[i, 23], pl) # mu_Qmax
            self.assertAlmostEqual(gn.mu_qmin, gen[i, 24], pl) # mu_Qmin