def t_opf_dc_gurobi(quiet=False): """Tests for DC optimal power flow using Gurobi solver. """ algs = [0, 1, 2, 3, 4] num_tests = 23 * len(algs) t_begin(num_tests, quiet) tdir = dirname(__file__) casefile = join(tdir, 't_case9_opf') if quiet: verbose = False else: verbose = False ppopt = ppoption('OUT_ALL', 0, 'VERBOSE', verbose) ppopt = ppoption(ppopt, 'OPF_ALG_DC', 700) ## run DC OPF if have_fcn('gurobipy'): for k in range(len(algs)): ppopt = ppoption(ppopt, 'GRB_METHOD', algs[k]) methods = [ 'automatic', 'primal simplex', 'dual simplex', 'barrier', 'concurrent', 'deterministic concurrent', ] t0 = 'DC OPF (Gurobi %s): ' % methods[k] ## set up indices ib_data = r_[arange(BUS_AREA + 1), arange(BASE_KV, VMIN + 1)] ib_voltage = arange(VM, VA + 1) ib_lam = arange(LAM_P, LAM_Q + 1) ib_mu = arange(MU_VMAX, MU_VMIN + 1) ig_data = r_[[GEN_BUS, QMAX, QMIN], arange(MBASE, APF + 1)] ig_disp = array([PG, QG, VG]) ig_mu = arange(MU_PMAX, MU_QMIN + 1) ibr_data = arange(ANGMAX + 1) ibr_flow = arange(PF, QT + 1) ibr_mu = array([MU_SF, MU_ST]) #ibr_angmu = array([MU_ANGMIN, MU_ANGMAX]) ## get solved DC power flow case from MAT-file ## defines bus_soln, gen_soln, branch_soln, f_soln soln9_dcopf = loadmat(join(tdir, 'soln9_dcopf.mat'), struct_as_record=True) bus_soln, gen_soln, branch_soln, f_soln = \ soln9_dcopf['bus_soln'], soln9_dcopf['gen_soln'], \ soln9_dcopf['branch_soln'], soln9_dcopf['f_soln'] ## run OPF t = t0 r = rundcopf(casefile, ppopt) bus, gen, branch, f, success = \ r['bus'], r['gen'], r['branch'], r['f'], r['success'] t_ok(success, [t, 'success']) t_is(f, f_soln, 3, [t, 'f']) t_is(bus[:, ib_data], bus_soln[:, ib_data], 10, [t, 'bus data']) t_is(bus[:, ib_voltage], bus_soln[:, ib_voltage], 3, [t, 'bus voltage']) t_is(bus[:, ib_lam], bus_soln[:, ib_lam], 3, [t, 'bus lambda']) t_is(bus[:, ib_mu], bus_soln[:, ib_mu], 2, [t, 'bus mu']) t_is(gen[:, ig_data], gen_soln[:, ig_data], 10, [t, 'gen data']) t_is(gen[:, ig_disp], gen_soln[:, ig_disp], 3, [t, 'gen dispatch']) t_is(gen[:, ig_mu], gen_soln[:, ig_mu], 3, [t, 'gen mu']) t_is(branch[:, ibr_data], branch_soln[:, ibr_data], 10, [t, 'branch data']) t_is(branch[:, ibr_flow], branch_soln[:, ibr_flow], 3, [t, 'branch flow']) t_is(branch[:, ibr_mu], branch_soln[:, ibr_mu], 2, [t, 'branch mu']) ##----- run OPF with extra linear user constraints & costs ----- ## two new z variables ## 0 <= z1, P2 - P1 <= z1 ## 0 <= z2, P2 - P3 <= z2 ## with A and N sized for DC opf ppc = loadcase(casefile) row = [0, 0, 0, 1, 1, 1] col = [9, 10, 12, 10, 11, 13] ppc['A'] = sparse(([-1, 1, -1, 1, -1, -1], (row, col)), (2, 14)) ppc['u'] = array([0, 0]) ppc['l'] = array([-Inf, -Inf]) ppc['zl'] = array([0, 0]) ppc['N'] = sparse(([1, 1], ([0, 1], [12, 13])), (2, 14)) ## new z variables only ppc['fparm'] = ones((2, 1)) * array([[1, 0, 0, 1]]) ## w = r = z ppc['H'] = sparse((2, 2)) ## no quadratic term ppc['Cw'] = array([1000, 1]) t = ''.join([t0, 'w/extra constraints & costs 1 : ']) r = rundcopf(ppc, ppopt) t_ok(r['success'], [t, 'success']) t_is(r['gen'][0, PG], 116.15974, 4, [t, 'Pg1 = 116.15974']) t_is(r['gen'][1, PG], 116.15974, 4, [t, 'Pg2 = 116.15974']) t_is(r['var']['val']['z'], [0, 0.3348], 4, [t, 'user vars']) t_is(r['cost']['usr'], 0.3348, 3, [t, 'user costs']) ## with A and N sized for AC opf ppc = loadcase(casefile) row = [0, 0, 0, 1, 1, 1] col = [18, 19, 24, 19, 20, 25] ppc['A'] = sparse(([-1, 1, -1, 1, -1, -1], (row, col)), (2, 26)) ppc['u'] = array([0, 0]) ppc['l'] = array([-Inf, -Inf]) ppc['zl'] = array([0, 0]) ppc['N'] = sparse(([1, 1], ([0, 1], [24, 25])), (2, 26)) ## new z variables only ppc['fparm'] = ones((2, 1)) * array([[1, 0, 0, 1]]) ## w = r = z ppc['H'] = sparse((2, 2)) ## no quadratic term ppc['Cw'] = array([1000, 1]) t = ''.join([t0, 'w/extra constraints & costs 2 : ']) r = rundcopf(ppc, ppopt) t_ok(r['success'], [t, 'success']) t_is(r['gen'][0, PG], 116.15974, 4, [t, 'Pg1 = 116.15974']) t_is(r['gen'][1, PG], 116.15974, 4, [t, 'Pg2 = 116.15974']) t_is(r['var']['val']['z'], [0, 0.3348], 4, [t, 'user vars']) t_is(r['cost']['usr'], 0.3348, 3, [t, 'user costs']) t = ''.join([t0, 'infeasible : ']) ## with A and N sized for DC opf ppc = loadcase(casefile) ppc['A'] = sparse(([1, 1], ([0, 0], [9, 10])), (1, 14)) ## Pg1 + Pg2 ppc['u'] = array([Inf]) ppc['l'] = array([600]) r = rundcopf(ppc, ppopt) t_ok(not r['success'], [t, 'no success']) else: t_skip(num_tests, 'Gurobi not available') t_end()
def t_is(got, expected, prec=5, msg=''): """Tests if two matrices are identical to some tolerance. Increments the global test count and if the maximum difference between corresponding elements of C{got} and C{expected} is less than 10**(-C{prec}) then it increments the passed tests count, otherwise increments the failed tests count. Prints 'ok' or 'not ok' followed by the MSG, unless the global variable t_quiet is true. Intended to be called between calls to C{t_begin} and C{t_end}. @author: Ray Zimmerman (PSERC Cornell) @author: Richard Lincoln """ if isinstance(got, int) or isinstance(got, float): got = array([got], float) elif isinstance(got, list) or isinstance(got, tuple): got = array(got, float) if isinstance(expected, int) or isinstance(expected, float): expected = array([expected], float) elif isinstance(expected, list) or isinstance(expected, tuple): expected = array(expected, float) if (got.shape == expected.shape) or (expected.shape == (0,)): got_minus_expected = got - expected max_diff = max(max(abs(got_minus_expected))) condition = ( max_diff < 10**(-prec) ) else: condition = False max_diff = 0 t_ok(condition, msg) if (not condition and not TestGlobals.t_quiet): s = '' if max_diff != 0: idx = nonzero(not abs(got_minus_expected) < 10**(-prec)) if len(idx) == 1: # 1D array idx = (idx[0], zeros( len(got_minus_expected) )) i, j = idx k = i + (j-1) * expected.shape[0] got = got.flatten() expected = expected.flatten() got_minus_expected = got_minus_expected.flatten() kk = argmax( abs(got_minus_expected[ k.astype(int) ]) ) s += ' row col got expected got - exp\n' s += '------- ------ ---------------- ---------------- ----------------' for u in range(len(i)): s += '\n%6d %6d %16g %16g %16g' % \ (i[u], j[u], got[k[u]], expected[k[u]], got_minus_expected[k[u]]) if u == kk: s += ' *' s += '\nmax diff @ (%d,%d) = %g > allowed tol of %g\n\n' % \ (i[kk], j[kk], max_diff, 10**(-prec)) else: s += ' dimension mismatch:\n' if len(got.shape) == 1: # 1D array s += ' got: %d\n' % got.shape else: s += ' got: %d x %d\n' % got.shape if len(expected.shape) == 1: # 1D array s += ' expected: %d\n' % expected.shape else: s += ' expected: %d x %d\n' % expected.shape print(s)
def t_pf(quiet=False): """Tests for power flow solvers. @author: Ray Zimmerman (PSERC Cornell) """ t_begin(33, quiet) tdir = dirname(__file__) casefile = join(tdir, 't_case9_pf') verbose = not quiet ppopt = ppoption(VERBOSE=verbose, OUT_ALL=0) ## get solved AC power flow case from MAT-file ## defines bus_soln, gen_soln, branch_soln soln9_pf = loadmat(join(tdir, 'soln9_pf.mat'), struct_as_record=False) bus_soln = soln9_pf['bus_soln'] gen_soln = soln9_pf['gen_soln'] branch_soln = soln9_pf['branch_soln'] ## run Newton PF t = 'Newton PF : ' ppopt = ppoption(ppopt, PF_ALG=1) results, success = runpf(casefile, ppopt) bus, gen, branch = results['bus'], results['gen'], results['branch'] t_ok(success, [t, 'success']) t_is(bus, bus_soln, 6, [t, 'bus']) t_is(gen, gen_soln, 6, [t, 'gen']) t_is(branch, branch_soln, 6, [t, 'branch']) ## run fast-decoupled PF (XB version) t = 'Fast Decoupled (XB) PF : ' ppopt = ppoption(ppopt, PF_ALG=2) results, success = runpf(casefile, ppopt) bus, gen, branch = results['bus'], results['gen'], results['branch'] t_ok(success, [t, 'success']) t_is(bus, bus_soln, 6, [t, 'bus']) t_is(gen, gen_soln, 6, [t, 'gen']) t_is(branch, branch_soln, 6, [t, 'branch']) ## run fast-decoupled PF (BX version) t = 'Fast Decoupled (BX) PF : ' ppopt = ppoption(ppopt, PF_ALG=3) results, success = runpf(casefile, ppopt) bus, gen, branch = results['bus'], results['gen'], results['branch'] t_ok(success, [t, 'success']) t_is(bus, bus_soln, 6, [t, 'bus']) t_is(gen, gen_soln, 6, [t, 'gen']) t_is(branch, branch_soln, 6, [t, 'branch']) ## run Gauss-Seidel PF t = 'Gauss-Seidel PF : ' ppopt = ppoption(ppopt, PF_ALG=4) results, success = runpf(casefile, ppopt) bus, gen, branch = results['bus'], results['gen'], results['branch'] t_ok(success, [t, 'success']) t_is(bus, bus_soln, 5, [t, 'bus']) t_is(gen, gen_soln, 5, [t, 'gen']) t_is(branch, branch_soln, 5, [t, 'branch']) ## get solved AC power flow case from MAT-file ## defines bus_soln, gen_soln, branch_soln soln9_dcpf = loadmat(join(tdir, 'soln9_dcpf.mat'), struct_as_record=False) bus_soln = soln9_dcpf['bus_soln'] gen_soln = soln9_dcpf['gen_soln'] branch_soln = soln9_dcpf['branch_soln'] ## run DC PF t = 'DC PF : ' results, success = rundcpf(casefile, ppopt) bus, gen, branch = results['bus'], results['gen'], results['branch'] t_ok(success, [t, 'success']) t_is(bus, bus_soln, 6, [t, 'bus']) t_is(gen, gen_soln, 6, [t, 'gen']) t_is(branch, branch_soln, 6, [t, 'branch']) ## check Qg distribution, when Qmin = Qmax t = 'check Qg : ' ppopt = ppoption(ppopt, PF_ALG=1, VERBOSE=0) ppc = loadcase(casefile) ppc['gen'][0, [QMIN, QMAX]] = [20, 20] results, success = runpf(ppc, ppopt) bus, gen, branch = results['bus'], results['gen'], results['branch'] t_is(gen[0, QG], 24.07, 2, [t, 'single gen, Qmin = Qmax']) ppc['gen'] = r_[array([ppc['gen'][0, :]]), ppc['gen']] ppc['gen'][0, [QMIN, QMAX]] = [10, 10] ppc['gen'][1, [QMIN, QMAX]] = [0, 50] results, success = runpf(ppc, ppopt) bus, gen, branch = results['bus'], results['gen'], results['branch'] t_is(gen[0:2, QG], [10, 14.07], 2, [t, '2 gens, Qmin = Qmax for one']) ppc['gen'][0, [QMIN, QMAX]] = [10, 10] ppc['gen'][1, [QMIN, QMAX]] = [-50, -50] results, success = runpf(ppc, ppopt) bus, gen, branch = results['bus'], results['gen'], results['branch'] t_is(gen[0:2, QG], [12.03, 12.03], 2, [t, '2 gens, Qmin = Qmax for both']) ppc['gen'][0, [QMIN, QMAX]] = [0, 50] ppc['gen'][1, [QMIN, QMAX]] = [0, 100] results, success = runpf(ppc, ppopt) bus, gen, branch = results['bus'], results['gen'], results['branch'] t_is(gen[0:2, QG], [8.02, 16.05], 2, [t, '2 gens, proportional']) ppc['gen'][0, [QMIN, QMAX]] = [-50, 0] ppc['gen'][1, [QMIN, QMAX]] = [50, 150] results, success = runpf(ppc, ppopt) bus, gen, branch = results['bus'], results['gen'], results['branch'] t_is(gen[0:2, QG], [-50 + 8.02, 50 + 16.05], 2, [t, '2 gens, proportional']) ## network with islands t = 'network w/islands : DC PF : ' ppc0 = loadcase(casefile) ppc0['gen'][0, PG] = 60 ppc0['gen'][0, [PMIN, PMAX, QMIN, QMAX, PG, QG]] = \ ppc0['gen'][0, [PMIN, PMAX, QMIN, QMAX, PG, QG]] / 2 ppc0['gen'] = r_[array([ppc0['gen'][0, :]]), ppc0['gen']] ppc1 = ppc0.copy() ppc = ppc0.copy() nb = ppc['bus'].shape[0] ppc1['bus'][:, BUS_I] = ppc1['bus'][:, BUS_I] + nb ppc1['branch'][:, F_BUS] = ppc1['branch'][:, F_BUS] + nb ppc1['branch'][:, T_BUS] = ppc1['branch'][:, T_BUS] + nb ppc1['gen'][:, GEN_BUS] = ppc1['gen'][:, GEN_BUS] + nb ppc['bus'] = r_[ppc['bus'], ppc1['bus']] ppc['branch'] = r_[ppc['branch'], ppc1['branch']] ppc['gen'] = r_[ppc['gen'], ppc1['gen']] #ppopt = ppoption(ppopt, OUT_BUS=1, OUT_GEN=1, OUT_ALL=-1, VERBOSE=2) ppopt = ppoption(ppopt, VERBOSE=verbose) r = rundcpf(ppc, ppopt) t_is(r['bus'][:9, VA], bus_soln[:, VA], 8, [t, 'voltage angles 1']) t_is(r['bus'][10:18, VA], bus_soln[:, VA], 8, [t, 'voltage angles 2']) Pg = r_[gen_soln[0, PG] - 30, 30, gen_soln[1:3, PG]] t_is(r['gen'][:4, PG], Pg, 8, [t, 'active power generation 1']) t_is(r['gen'][4:8, PG], Pg, 8, [t, 'active power generation 1']) t = 'network w/islands : AC PF : ' ## get solved AC power flow case from MAT-file soln9_pf = loadmat(join(tdir, 'soln9_pf.mat'), struct_as_record=False) bus_soln = soln9_pf['bus_soln'] gen_soln = soln9_pf['gen_soln'] branch_soln = soln9_pf['branch_soln'] r = runpf(ppc, ppopt) t_is(r['bus'][:9, VA], bus_soln[:, VA], 8, [t, 'voltage angles 1']) t_is(r['bus'][9:18, VA], bus_soln[:, VA], 8, [t, 'voltage angles 2']) Pg = r_[gen_soln[0, PG] - 30, 30, gen_soln[1:3, PG]] t_is(r['gen'][:4, PG], Pg, 8, [t, 'active power generation 1']) t_is(r['gen'][4:8, PG], Pg, 8, [t, 'active power generation 1']) t_end()
def t_opf_userfcns(quiet=False): """Tests for userfcn callbacks (reserves/iflims) w/OPF. Includes high-level tests of reserves and iflims implementations. @author: Ray Zimmerman (PSERC Cornell) @author: Richard Lincoln """ t_begin(38, quiet) tdir = dirname(__file__) casefile = join(tdir, 't_case30_userfcns') verbose = 0#not quiet ppopt = ppoption(OPF_VIOLATION=1e-6, PDIPM_GRADTOL=1e-8, PDIPM_COMPTOL=1e-8, PDIPM_COSTTOL=1e-9) ppopt = ppoption(ppopt, OUT_ALL=0, VERBOSE=verbose, OPF_ALG=560, OPF_ALG_DC=200) #ppopt = ppoption(ppopt, OUT_ALL=-1, VERBOSE=2, OUT_GEN=1) ## run the OPF with fixed reserves t = 'fixed reserves : ' ppc = loadcase(casefile) ppc = toggle_reserves(ppc, 'on') r = runopf(ppc, ppopt) t_ok(r['success'], [t, 'success']) t_is(r['reserves']['R'], [25, 15, 0, 0, 19.3906, 0.6094], 4, [t, 'reserves.R']) t_is(r['reserves']['prc'], [2, 2, 2, 2, 5.5, 5.5], 4, [t, 'reserves.prc']) t_is(r['reserves']['mu']['Pmax'], [0, 0, 0, 0, 0.5, 0], 4, [t, 'reserves.mu.Pmax']) t_is(r['reserves']['mu']['l'], [0, 0, 1, 2, 0, 0], 4, [t, 'reserves.mu.l']) t_is(r['reserves']['mu']['u'], [0.1, 0, 0, 0, 0, 0], 4, [t, 'reserves.mu.u']) t_ok('P' not in r['if'], [t, 'no iflims']) t_is(r['reserves']['totalcost'], 177.8047, 4, [t, 'totalcost']) t = 'toggle_reserves(ppc, \'off\') : '; ppc = toggle_reserves(ppc, 'off') r = runopf(ppc, ppopt) t_ok(r['success'], [t, 'success']) t_ok('R' not in r['reserves'], [t, 'no reserves']) t_ok('P' not in r['if'], [t, 'no iflims']) t = 'interface flow lims (DC) : ' ppc = loadcase(casefile) ppc = toggle_iflims(ppc, 'on') r = rundcopf(ppc, ppopt) t_ok(r['success'], [t, 'success']) t_is(r['if']['P'], [-15, 20], 4, [t, 'if.P']) t_is(r['if']['mu']['l'], [4.8427, 0], 4, [t, 'if.mu.l']) t_is(r['if']['mu']['u'], [0, 13.2573], 4, [t, 'if.mu.u']) t_is(r['branch'][13, PF], 8.244, 3, [t, 'flow in branch 14']) t_ok('R' not in r['reserves'], [t, 'no reserves']) t = 'reserves + interface flow lims (DC) : ' ppc = loadcase(casefile) ppc = toggle_reserves(ppc, 'on') ppc = toggle_iflims(ppc, 'on') r = rundcopf(ppc, ppopt) t_ok(r['success'], [t, 'success']) t_is(r['if']['P'], [-15, 20], 4, [t, 'if.P']) t_is(r['if']['mu']['l'], [4.8427, 0], 4, [t, 'if.mu.l']) t_is(r['if']['mu']['u'], [0, 38.2573], 4, [t, 'if.mu.u']) t_is(r['reserves']['R'], [25, 15, 0, 0, 16.9, 3.1], 4, [t, 'reserves.R']) t_is(r['reserves']['prc'], [2, 2, 2, 2, 5.5, 5.5], 4, [t, 'reserves.prc']) t_is(r['reserves']['mu']['Pmax'], [0, 0, 0, 0, 0.5, 0], 4, [t, 'reserves.mu.Pmax']) t_is(r['reserves']['mu']['l'], [0, 0, 1, 2, 0, 0], 4, [t, 'reserves.mu.l']) t_is(r['reserves']['mu']['u'], [0.1, 0, 0, 0, 0, 0], 4, [t, 'reserves.mu.u']) t_is(r['reserves']['totalcost'], 179.05, 4, [t, 'totalcost']) t = 'interface flow lims (AC) : ' ppc = toggle_reserves(ppc, 'off') r = runopf(ppc, ppopt) t_ok(r['success'], [t, 'success']) t_is(r['if']['P'], [-9.101, 21.432], 3, [t, 'if.P']) t_is(r['if']['mu']['l'], [0, 0], 4, [t, 'if.mu.l']) t_is(r['if']['mu']['u'], [0, 10.198], 3, [t, 'if.mu.u']) t_ok('R' not in r['reserves'], [t, 'no reserves']) t = 'interface flow lims (line out) : ' ppc = loadcase(casefile) ppc = toggle_iflims(ppc, 'on') ppc['branch'][11, BR_STATUS] = 0 ## take out line 6-10 r = rundcopf(ppc, ppopt) t_ok(r['success'], [t, 'success']) t_is(r['if']['P'], [-15, 20], 4, [t, 'if.P']) t_is(r['if']['mu']['l'], [4.8427, 0], 4, [t, 'if.mu.l']) t_is(r['if']['mu']['u'], [0, 13.2573], 4, [t, 'if.mu.u']) t_is(r['branch'][13, PF], 10.814, 3, [t, 'flow in branch 14']) t_ok('R' not in r['reserves'], [t, 'no reserves']) # r['reserves']['R'] # r['reserves']['prc'] # r['reserves']['mu.Pmax'] # r['reserves']['mu']['l'] # r['reserves']['mu']['u'] # r['reserves']['totalcost'] # # r['if']['P'] # r['if']['mu']['l'] # r['if']['mu']['u'] t_end()
def t_dcline(quiet=False): """Tests for DC line extension in L{{toggle_dcline}. @author: Ray Zimmerman (PSERC Cornell) """ num_tests = 50 t_begin(num_tests, quiet) tdir = dirname(__file__) casefile = join(tdir, 't_case9_dcline') if quiet: verbose = False else: verbose = False t0 = '' ppopt = ppoption(OPF_VIOLATION=1e-6, PDIPM_GRADTOL=1e-8, PDIPM_COMPTOL=1e-8, PDIPM_COSTTOL=1e-9) ppopt = ppoption(ppopt, OPF_ALG=560, OPF_ALG_DC=200) ppopt = ppoption(ppopt, OUT_ALL=0, VERBOSE=verbose) ## set up indices ib_data = r_[arange(BUS_AREA + 1), arange(BASE_KV, VMIN + 1)] ib_voltage = arange(VM, VA + 1) ib_lam = arange(LAM_P, LAM_Q + 1) ib_mu = arange(MU_VMAX, MU_VMIN + 1) ig_data = r_[[GEN_BUS, QMAX, QMIN], arange(MBASE, APF + 1)] ig_disp = array([PG, QG, VG]) ig_mu = arange(MU_PMAX, MU_QMIN + 1) ibr_data = arange(ANGMAX + 1) ibr_flow = arange(PF, QT + 1) ibr_mu = array([MU_SF, MU_ST]) ibr_angmu = array([MU_ANGMIN, MU_ANGMAX]) ## load case ppc0 = loadcase(casefile) del ppc0['dclinecost'] ppc = ppc0 ppc = toggle_dcline(ppc, 'on') ppc = toggle_dcline(ppc, 'off') ndc = ppc['dcline'].shape[0] ## run AC OPF w/o DC lines t = ''.join([t0, 'AC OPF (no DC lines) : ']) r0 = runopf(ppc0, ppopt) success = r0['success'] t_ok(success, [t, 'success']) r = runopf(ppc, ppopt) success = r['success'] t_ok(success, [t, 'success']) t_is(r['f'], r0['f'], 8, [t, 'f']) t_is(r['bus'][:, ib_data], r0['bus'][:, ib_data], 10, [t, 'bus data']) t_is(r['bus'][:, ib_voltage], r0['bus'][:, ib_voltage], 3, [t, 'bus voltage']) t_is(r['bus'][:, ib_lam], r0['bus'][:, ib_lam], 3, [t, 'bus lambda']) t_is(r['bus'][:, ib_mu], r0['bus'][:, ib_mu], 2, [t, 'bus mu']) t_is(r['gen'][:, ig_data], r0['gen'][:, ig_data], 10, [t, 'gen data']) t_is(r['gen'][:, ig_disp], r0['gen'][:, ig_disp], 3, [t, 'gen dispatch']) t_is(r['gen'][:, ig_mu], r0['gen'][:, ig_mu], 3, [t, 'gen mu']) t_is(r['branch'][:, ibr_data], r0['branch'][:, ibr_data], 10, [t, 'branch data']) t_is(r['branch'][:, ibr_flow], r0['branch'][:, ibr_flow], 3, [t, 'branch flow']) t_is(r['branch'][:, ibr_mu], r0['branch'][:, ibr_mu], 2, [t, 'branch mu']) t = ''.join([t0, 'AC PF (no DC lines) : ']) ppc1 = { 'baseMVA': r['baseMVA'], 'bus': r['bus'][:, :VMIN + 1].copy(), 'gen': r['gen'][:, :APF + 1].copy(), 'branch': r['branch'][:, :ANGMAX + 1].copy(), 'gencost': r['gencost'].copy(), 'dcline': r['dcline'][:, :c.LOSS1 + 1].copy() } ppc1['bus'][:, VM] = 1 ppc1['bus'][:, VA] = 0 rp = runpf(ppc1, ppopt) success = rp['success'] t_ok(success, [t, 'success']) t_is(rp['bus'][:, ib_voltage], r['bus'][:, ib_voltage], 3, [t, 'bus voltage']) t_is(rp['gen'][:, ig_disp], r['gen'][:, ig_disp], 3, [t, 'gen dispatch']) t_is(rp['branch'][:, ibr_flow], r['branch'][:, ibr_flow], 3, [t, 'branch flow']) ## run with DC lines t = ''.join([t0, 'AC OPF (with DC lines) : ']) ppc = toggle_dcline(ppc, 'on') r = runopf(ppc, ppopt) success = r['success'] t_ok(success, [t, 'success']) expected = array([[10, 8.9, -10, 10, 1.0674, 1.0935], [2.2776, 2.2776, 0, 0, 1.0818, 1.0665], [0, 0, 0, 0, 1.0000, 1.0000], [10, 9.5, 0.0563, -10, 1.0778, 1.0665]]) t_is(r['dcline'][:, c.PF:c.VT + 1], expected, 4, [t, 'P Q V']) expected = array([[0, 0.8490, 0.6165, 0, 0, 0.2938], [0, 0, 0, 0.4290, 0.0739, 0], [0, 0, 0, 0, 0, 0], [0, 7.2209, 0, 0, 0.0739, 0]]) t_is(r['dcline'][:, c.MU_PMIN:c.MU_QMAXT + 1], expected, 3, [t, 'mu']) t = ''.join([t0, 'AC PF (with DC lines) : ']) ppc1 = { 'baseMVA': r['baseMVA'], 'bus': r['bus'][:, :VMIN + 1].copy(), 'gen': r['gen'][:, :APF + 1].copy(), 'branch': r['branch'][:, :ANGMAX + 1].copy(), 'gencost': r['gencost'].copy(), 'dcline': r['dcline'][:, :c.LOSS1 + 1].copy() } ppc1 = toggle_dcline(ppc1, 'on') ppc1['bus'][:, VM] = 1 ppc1['bus'][:, VA] = 0 rp = runpf(ppc1, ppopt) success = rp['success'] t_ok(success, [t, 'success']) t_is(rp['bus'][:, ib_voltage], r['bus'][:, ib_voltage], 3, [t, 'bus voltage']) #t_is( rp['gen'][:,ig_disp ], r['gen'][:,ig_disp ], 3, [t, 'gen dispatch']) t_is(rp['gen'][:2, ig_disp], r['gen'][:2, ig_disp], 3, [t, 'gen dispatch']) t_is(rp['gen'][2, PG], r['gen'][2, PG], 3, [t, 'gen dispatch']) t_is(rp['gen'][2, QG] + rp['dcline'][0, c.QF], r['gen'][2, QG] + r['dcline'][0, c.QF], 3, [t, 'gen dispatch']) t_is(rp['branch'][:, ibr_flow], r['branch'][:, ibr_flow], 3, [t, 'branch flow']) ## add appropriate P and Q injections and check angles and generation when running PF t = ''.join([t0, 'AC PF (with equivalent injections) : ']) ppc1 = { 'baseMVA': r['baseMVA'], 'bus': r['bus'][:, :VMIN + 1].copy(), 'gen': r['gen'][:, :APF + 1].copy(), 'branch': r['branch'][:, :ANGMAX + 1].copy(), 'gencost': r['gencost'].copy(), 'dcline': r['dcline'][:, :c.LOSS1 + 1].copy() } ppc1['bus'][:, VM] = 1 ppc1['bus'][:, VA] = 0 for k in range(ndc): if ppc1['dcline'][k, c.BR_STATUS]: ff = find(ppc1['bus'][:, BUS_I] == ppc1['dcline'][k, c.F_BUS]) tt = find(ppc1['bus'][:, BUS_I] == ppc1['dcline'][k, c.T_BUS]) ppc1['bus'][ff, PD] = ppc1['bus'][ff, PD] + r['dcline'][k, c.PF] ppc1['bus'][ff, QD] = ppc1['bus'][ff, QD] - r['dcline'][k, c.QF] ppc1['bus'][tt, PD] = ppc1['bus'][tt, PD] - r['dcline'][k, c.PT] ppc1['bus'][tt, QD] = ppc1['bus'][tt, QD] - r['dcline'][k, c.QT] ppc1['bus'][ff, VM] = r['dcline'][k, c.VF] ppc1['bus'][tt, VM] = r['dcline'][k, c.VT] ppc1['bus'][ff, BUS_TYPE] = PV ppc1['bus'][tt, BUS_TYPE] = PV rp = runpf(ppc1, ppopt) success = rp['success'] t_ok(success, [t, 'success']) t_is(rp['bus'][:, ib_voltage], r['bus'][:, ib_voltage], 3, [t, 'bus voltage']) t_is(rp['gen'][:, ig_disp], r['gen'][:, ig_disp], 3, [t, 'gen dispatch']) t_is(rp['branch'][:, ibr_flow], r['branch'][:, ibr_flow], 3, [t, 'branch flow']) ## test DC OPF t = ''.join([t0, 'DC OPF (with DC lines) : ']) ppc = ppc0.copy() ppc['gen'][0, PMIN] = 10 ppc['branch'][4, RATE_A] = 100 ppc = toggle_dcline(ppc, 'on') r = rundcopf(ppc, ppopt) success = r['success'] t_ok(success, [t, 'success']) expected = array([[10, 8.9, 0, 0, 1.01, 1], [2, 2, 0, 0, 1, 1], [0, 0, 0, 0, 1, 1], [10, 9.5, 0, 0, 1, 0.98]]) t_is(r['dcline'][:, c.PF:c.VT + 1], expected, 4, [t, 'P Q V']) expected = array([[0, 1.8602, 0, 0, 0, 0], [1.8507, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0.2681, 0, 0, 0, 0]]) t_is(r['dcline'][:, c.MU_PMIN:c.MU_QMAXT + 1], expected, 3, [t, 'mu']) t = ''.join([t0, 'DC PF (with DC lines) : ']) ppc1 = { 'baseMVA': r['baseMVA'], 'bus': r['bus'][:, :VMIN + 1].copy(), 'gen': r['gen'][:, :APF + 1].copy(), 'branch': r['branch'][:, :ANGMAX + 1].copy(), 'gencost': r['gencost'].copy(), 'dcline': r['dcline'][:, :c.LOSS1 + 1].copy() } ppc1 = toggle_dcline(ppc1, 'on') ppc1['bus'][:, VA] = 0 rp = rundcpf(ppc1, ppopt) success = rp['success'] t_ok(success, [t, 'success']) t_is(rp['bus'][:, ib_voltage], r['bus'][:, ib_voltage], 3, [t, 'bus voltage']) t_is(rp['gen'][:, ig_disp], r['gen'][:, ig_disp], 3, [t, 'gen dispatch']) t_is(rp['branch'][:, ibr_flow], r['branch'][:, ibr_flow], 3, [t, 'branch flow']) ## add appropriate P injections and check angles and generation when running PF t = ''.join([t0, 'DC PF (with equivalent injections) : ']) ppc1 = { 'baseMVA': r['baseMVA'], 'bus': r['bus'][:, :VMIN + 1].copy(), 'gen': r['gen'][:, :APF + 1].copy(), 'branch': r['branch'][:, :ANGMAX + 1].copy(), 'gencost': r['gencost'].copy(), 'dcline': r['dcline'][:, :c.LOSS1 + 1].copy() } ppc1['bus'][:, VA] = 0 for k in range(ndc): if ppc1['dcline'][k, c.BR_STATUS]: ff = find(ppc1['bus'][:, BUS_I] == ppc1['dcline'][k, c.F_BUS]) tt = find(ppc1['bus'][:, BUS_I] == ppc1['dcline'][k, c.T_BUS]) ppc1['bus'][ff, PD] = ppc1['bus'][ff, PD] + r['dcline'][k, c.PF] ppc1['bus'][tt, PD] = ppc1['bus'][tt, PD] - r['dcline'][k, c.PT] ppc1['bus'][ff, BUS_TYPE] = PV ppc1['bus'][tt, BUS_TYPE] = PV rp = rundcpf(ppc1, ppopt) success = rp['success'] t_ok(success, [t, 'success']) t_is(rp['bus'][:, ib_voltage], r['bus'][:, ib_voltage], 3, [t, 'bus voltage']) t_is(rp['gen'][:, ig_disp], r['gen'][:, ig_disp], 3, [t, 'gen dispatch']) t_is(rp['branch'][:, ibr_flow], r['branch'][:, ibr_flow], 3, [t, 'branch flow']) ## run with DC lines t = ''.join([t0, 'AC OPF (with DC lines + poly cost) : ']) ppc = loadcase(casefile) ppc = toggle_dcline(ppc, 'on') r = runopf(ppc, ppopt) success = r['success'] t_ok(success, [t, 'success']) expected1 = array([[10, 8.9, -10, 10, 1.0663, 1.0936], [7.8429, 7.8429, 0, 0, 1.0809, 1.0667], [0, 0, 0, 0, 1.0000, 1.0000], [6.0549, 5.7522, -0.5897, -10, 1.0778, 1.0667]]) t_is(r['dcline'][:, c.PF:c.VT + 1], expected1, 4, [t, 'P Q V']) expected2 = array([[0, 0.7605, 0.6226, 0, 0, 0.2980], [0, 0, 0, 0.4275, 0.0792, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0.0792, 0]]) t_is(r['dcline'][:, c.MU_PMIN:c.MU_QMAXT + 1], expected2, 3, [t, 'mu']) ppc['dclinecost'][3, :8] = array([2, 0, 0, 4, 0, 0, 7.3, 0]) r = runopf(ppc, ppopt) success = r['success'] t_ok(success, [t, 'success']) t_is(r['dcline'][:, c.PF:c.VT + 1], expected1, 4, [t, 'P Q V']) t_is(r['dcline'][:, c.MU_PMIN:c.MU_QMAXT + 1], expected2, 3, [t, 'mu']) t = ''.join([t0, 'AC OPF (with DC lines + pwl cost) : ']) ppc['dclinecost'][3, :8] = array([1, 0, 0, 2, 0, 0, 10, 73]) r = runopf(ppc, ppopt) success = r['success'] t_ok(success, [t, 'success']) t_is(r['dcline'][:, c.PF:c.VT + 1], expected1, 4, [t, 'P Q V']) t_is(r['dcline'][:, c.MU_PMIN:c.MU_QMAXT + 1], expected2, 3, [t, 'mu']) t_end()
def t_qps_pypower(quiet=False): """Tests of C{qps_pypower} QP solvers. @author: Ray Zimmerman (PSERC Cornell) """ algs = [200, 250, 400, 500, 600, 700] names = ['PIPS', 'sc-PIPS', 'IPOPT', 'CPLEX', 'MOSEK', 'Gurobi'] check = [None, None, 'ipopt', 'cplex', 'mosek', 'gurobipy'] n = 36 t_begin(n * len(algs), quiet) for k in range(len(algs)): if check[k] is not None and not have_fcn(check[k]): t_skip(n, '%s not installed' % names[k]) else: opt = {'verbose': 0, 'alg': algs[k]} if names[k] == 'PIPS' or names[k] == 'sc-PIPS': opt['pips_opt'] = {} opt['pips_opt']['comptol'] = 1e-8 if names[k] == 'CPLEX': # alg = 0 ## default uses barrier method with NaN bug in lower lim multipliers alg = 2 ## use dual simplex ppopt = ppoption(CPLEX_LPMETHOD = alg, CPLEX_QPMETHOD = min([4, alg])) opt['cplex_opt'] = cplex_options([], ppopt) if names[k] == 'MOSEK': # alg = 5 ## use dual simplex ppopt = ppoption() # ppopt = ppoption(ppopt, MOSEK_LP_ALG = alg) ppopt = ppoption(ppopt, MOSEK_GAP_TOL=1e-9) opt['mosek_opt'] = mosek_options([], ppopt) t = '%s - 3-d LP : ' % names[k] ## example from 'doc linprog' c = array([-5, -4, -6], float) A = sparse([[1, -1, 1], [3, 2, 4], [3, 2, 0]], dtype=float) l = None u = array([20, 42, 30], float) xmin = array([0, 0, 0], float) x0 = None x, f, s, _, lam = qps_pypower(None, c, A, l, u, xmin, None, None, opt) t_is(s, 1, 12, [t, 'success']) t_is(x, [0, 15, 3], 6, [t, 'x']) t_is(f, -78, 6, [t, 'f']) t_is(lam['mu_l'], [0, 0, 0], 13, [t, 'lam.mu_l']) t_is(lam['mu_u'], [0, 1.5, 0.5], 9, [t, 'lam.mu_u']) t_is(lam['lower'], [1, 0, 0], 9, [t, 'lam.lower']) t_is(lam['upper'], zeros(shape(x)), 13, [t, 'lam.upper']) t = '%s - unconstrained 3-d quadratic : ' % names[k] ## from http://www.akiti.ca/QuadProgEx0Constr.html H = sparse([ [ 5, -2, -1], [-2, 4, 3], [-1, 3, 5] ], dtype=float) c = array([2, -35, -47], float) x0 = array([0, 0, 0], float) x, f, s, _, lam = qps_pypower(H, c, opt=opt) t_is(s, 1, 12, [t, 'success']) t_is(x, [3, 5, 7], 8, [t, 'x']) t_is(f, -249, 13, [t, 'f']) t_ok(len(lam['mu_l']) == 0, [t, 'lam.mu_l']) t_ok(len(lam['mu_u']) == 0, [t, 'lam.mu_u']) t_is(lam['lower'], zeros(shape(x)), 13, [t, 'lam.lower']) t_is(lam['upper'], zeros(shape(x)), 13, [t, 'lam.upper']) t = '%s - constrained 2-d QP : ' % names[k] ## example from 'doc quadprog' H = sparse([[ 1, -1], [-1, 2]], dtype=float) c = array([-2, -6], float) A = sparse([[ 1, 1], [-1, 2], [ 2, 1]], dtype=float) l = None u = array([2, 2, 3], float) xmin = array([0, 0]) x0 = None x, f, s, _, lam = qps_pypower(H, c, A, l, u, xmin, None, x0, opt) t_is(s, 1, 12, [t, 'success']) t_is(x, array([2., 4.]) / 3, 7, [t, 'x']) t_is(f, -74. / 9, 6, [t, 'f']) t_is(lam['mu_l'], [0., 0., 0.], 13, [t, 'lam.mu_l']) t_is(lam['mu_u'], array([28., 4., 0.]) / 9, 7, [t, 'lam.mu_u']) t_is(lam['lower'], zeros(shape(x)), 8, [t, 'lam.lower']) t_is(lam['upper'], zeros(shape(x)), 13, [t, 'lam.upper']) t = '%s - constrained 4-d QP : ' % names[k] ## from http://www.jmu.edu/docs/sasdoc/sashtml/iml/chap8/sect12.htm H = sparse([[1003.1, 4.3, 6.3, 5.9], [4.3, 2.2, 2.1, 3.9], [6.3, 2.1, 3.5, 4.8], [5.9, 3.9, 4.8, 10.0]]) c = zeros(4) A = sparse([[ 1, 1, 1, 1], [0.17, 0.11, 0.10, 0.18]]) l = array([1, 0.10]) u = array([1, Inf]) xmin = zeros(4) x0 = array([1, 0, 0, 1], float) x, f, s, _, lam = qps_pypower(H, c, A, l, u, xmin, None, x0, opt) t_is(s, 1, 12, [t, 'success']) t_is(x, array([0, 2.8, 0.2, 0]) / 3, 5, [t, 'x']) t_is(f, 3.29 / 3, 6, [t, 'f']) t_is(lam['mu_l'], array([6.58, 0]) / 3, 6, [t, 'lam.mu_l']) t_is(lam['mu_u'], [0, 0], 13, [t, 'lam.mu_u']) t_is(lam['lower'], [2.24, 0, 0, 1.7667], 4, [t, 'lam.lower']) t_is(lam['upper'], zeros(shape(x)), 13, [t, 'lam.upper']) t = '%s - (dict) constrained 4-d QP : ' % names[k] p = {'H': H, 'A': A, 'l': l, 'u': u, 'xmin': xmin, 'x0': x0, 'opt': opt} x, f, s, _, lam = qps_pypower(p) t_is(s, 1, 12, [t, 'success']) t_is(x, array([0, 2.8, 0.2, 0]) / 3, 5, [t, 'x']) t_is(f, 3.29 / 3, 6, [t, 'f']) t_is(lam['mu_l'], array([6.58, 0]) / 3, 6, [t, 'lam.mu_l']) t_is(lam['mu_u'], [0, 0], 13, [t, 'lam.mu_u']) t_is(lam['lower'], [2.24, 0, 0, 1.7667], 4, [t, 'lam.lower']) t_is(lam['upper'], zeros(shape(x)), 13, [t, 'lam.upper']) t = '%s - infeasible LP : ' % names[k] p = {'A': sparse([1, 1]), 'c': array([1, 1]), 'u': array([-1]), 'xmin': array([0, 0]), 'opt': opt} x, f, s, _, lam = qps_pypower(p) t_ok(s <= 0, [t, 'no success']) t_end()
def t_scale_load(quiet=False): """Tests for code in C{scale_load}. @author: Ray Zimmerman (PSERC Cornell) @author: Richard Lincoln """ n_tests = 275 t_begin(n_tests, quiet) ppc = loadcase(join(dirname(__file__), 't_auction_case')) ppc['gen'][7, GEN_BUS] = 2 ## multiple d. loads per area, same bus as gen ppc['gen'][7, [QG, QMIN, QMAX]] = array([3, 0, 3]) ## put it load before gen in matrix ppc['gen'] = vstack([ppc['gen'][7, :], ppc['gen'][:7, :], ppc['gen'][8, :]]) ld = find(isload(ppc['gen'])) a = [None] * 3 lda = [None] * 3 for k in range(3): a[k] = find(ppc['bus'][:, BUS_AREA] == k + 1) ## buses in area k tmp = find( in1d(ppc['gen'][ld, GEN_BUS] - 1, a[k]) ) lda[k] = ld[tmp] ## disp loads in area k area = [None] * 3 for k in range(3): area[k] = {'fixed': {}, 'disp': {}, 'both': {}} area[k]['fixed']['p'] = sum(ppc['bus'][a[k], PD]) area[k]['fixed']['q'] = sum(ppc['bus'][a[k], QD]) area[k]['disp']['p'] = -sum(ppc['gen'][lda[k], PMIN]) area[k]['disp']['qmin'] = -sum(ppc['gen'][lda[k], QMIN]) area[k]['disp']['qmax'] = -sum(ppc['gen'][lda[k], QMAX]) area[k]['disp']['q'] = area[k]['disp']['qmin'] + area[k]['disp']['qmax'] area[k]['both']['p'] = area[k]['fixed']['p'] + area[k]['disp']['p'] area[k]['both']['q'] = area[k]['fixed']['q'] + area[k]['disp']['q'] total = {'fixed': {}, 'disp': {}, 'both': {}} total['fixed']['p'] = sum(ppc['bus'][:, PD]) total['fixed']['q'] = sum(ppc['bus'][:, QD]) total['disp']['p'] = -sum(ppc['gen'][ld, PMIN]) total['disp']['qmin'] = -sum(ppc['gen'][ld, QMIN]) total['disp']['qmax'] = -sum(ppc['gen'][ld, QMAX]) total['disp']['q'] = total['disp']['qmin'] + total['disp']['qmax'] total['both']['p'] = total['fixed']['p'] + total['disp']['p'] total['both']['q'] = total['fixed']['q'] + total['disp']['q'] ##----- single load zone, one scale factor ----- load = array([2]) t = 'all fixed loads (PQ) * 2 : ' bus, _ = scale_load(load, ppc['bus']) t_is(sum(bus[:, PD]), load * total['fixed']['p'], 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), load * total['fixed']['q'], 8, [t, 'total fixed Q']) opt = {'which': 'FIXED'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) t_is(sum(bus[:, PD]), load * total['fixed']['p'], 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), load * total['fixed']['q'], 8, [t, 'total fixed Q']) t_is(-sum(gen[ld, PMIN]), total['disp']['p'], 8, [t, 'total disp P']) t_is(-sum(gen[ld, QMIN]), total['disp']['qmin'], 8, [t, 'total disp Qmin']) t_is(-sum(gen[ld, QMAX]), total['disp']['qmax'], 8, [t, 'total disp Qmax']) t = 'all fixed loads (P) * 2 : ' opt = {'pq': 'P'} bus, _ = scale_load(load, ppc['bus'], None, None, opt) t_is(sum(bus[:, PD]), load * total['fixed']['p'], 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), total['fixed']['q'], 8, [t, 'total fixed Q']) opt = {'pq': 'P', 'which': 'FIXED'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) t_is(sum(bus[:, PD]), load * total['fixed']['p'], 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), total['fixed']['q'], 8, [t, 'total fixed Q']) t_is(-sum(gen[ld, PMIN]), total['disp']['p'], 8, [t, 'total disp P']) t_is(-sum(gen[ld, QMIN]), total['disp']['qmin'], 8, [t, 'total disp Qmin']) t_is(-sum(gen[ld, QMAX]), total['disp']['qmax'], 8, [t, 'total disp Qmax']) t = 'all loads (PQ) * 2 : ' bus, gen = scale_load(load, ppc['bus'], ppc['gen']) t_is(sum(bus[:, PD]), load * total['fixed']['p'], 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), load * total['fixed']['q'], 8, [t, 'total fixed Q']) t_is(-sum(gen[ld, PMIN]), load * total['disp']['p'], 8, [t, 'total disp P']) t_is(-sum(gen[ld, QMIN]), load * total['disp']['qmin'], 8, [t, 'total disp Qmin']) t_is(-sum(gen[ld, QMAX]), load * total['disp']['qmax'], 8, [t, 'total disp Qmax']) t = 'all loads (P) * 2 : ' opt = {'pq': 'P'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) t_is(sum(bus[:, PD]), load * total['fixed']['p'], 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), total['fixed']['q'], 8, [t, 'total fixed Q']) t_is(-sum(gen[ld, PMIN]), load * total['disp']['p'], 8, [t, 'total disp P']) t_is(-sum(gen[ld, QMIN]), total['disp']['qmin'], 8, [t, 'total disp Qmin']) t_is(-sum(gen[ld, QMAX]), total['disp']['qmax'], 8, [t, 'total disp Qmax']) t = 'all disp loads (PQ) * 2 : ' opt = {'which': 'DISPATCHABLE'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) t_is(sum(bus[:, PD]), total['fixed']['p'], 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), total['fixed']['q'], 8, [t, 'total fixed Q']) t_is(-sum(gen[ld, PMIN]), load * total['disp']['p'], 8, [t, 'total disp P']) t_is(-sum(gen[ld, QMIN]), load * total['disp']['qmin'], 8, [t, 'total disp Qmin']) t_is(-sum(gen[ld, QMAX]), load * total['disp']['qmax'], 8, [t, 'total disp Qmax']) t = 'all disp loads (P) * 2 : ' opt = {'pq': 'P', 'which': 'DISPATCHABLE'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) t_is(sum(bus[:, PD]), total['fixed']['p'], 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), total['fixed']['q'], 8, [t, 'total fixed Q']) t_is(-sum(gen[ld, PMIN]), load * total['disp']['p'], 8, [t, 'total disp P']) t_is(-sum(gen[ld, QMIN]), total['disp']['qmin'], 8, [t, 'total disp Qmin']) t_is(-sum(gen[ld, QMAX]), total['disp']['qmax'], 8, [t, 'total disp Qmax']) ##----- single load zone, one scale quantity ----- load = array([200.0]) t = 'all fixed loads (PQ) => total = 200 : ' opt = {'scale': 'QUANTITY'} bus, _ = scale_load(load, ppc['bus'], None, None, opt) t_is(sum(bus[:, PD]), load, 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), load / total['fixed']['p'] * total['fixed']['q'], 8, [t, 'total fixed Q']) opt = {'scale': 'QUANTITY', 'which': 'FIXED'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) t_is(sum(bus[:, PD]), load - total['disp']['p'], 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), (load - total['disp']['p'])/total['fixed']['p']*total['fixed']['q'], 8, [t, 'total fixed Q']) t_is(-sum(gen[ld, PMIN]), total['disp']['p'], 8, [t, 'total disp P']) t_is(-sum(gen[ld, QMIN]), total['disp']['qmin'], 8, [t, 'total disp Qmin']) t_is(-sum(gen[ld, QMAX]), total['disp']['qmax'], 8, [t, 'total disp Qmax']) t = 'all fixed loads (P) => total = 200 : ' opt = {'scale': 'QUANTITY', 'pq': 'P'} bus, _ = scale_load(load, ppc['bus'], None, None, opt) t_is(sum(bus[:, PD]), load, 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), total['fixed']['q'], 8, [t, 'total fixed Q']) opt = {'scale': 'QUANTITY', 'pq': 'P', 'which': 'FIXED'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) t_is(sum(bus[:, PD]), load - total['disp']['p'], 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), total['fixed']['q'], 8, [t, 'total fixed Q']) t_is(-sum(gen[ld, PMIN]), total['disp']['p'], 8, [t, 'total disp P']) t_is(-sum(gen[ld, QMIN]), total['disp']['qmin'], 8, [t, 'total disp Qmin']) t_is(-sum(gen[ld, QMAX]), total['disp']['qmax'], 8, [t, 'total disp Qmax']) t = 'all loads (PQ) => total = 200 : ' opt = {'scale': 'QUANTITY'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) t_is(sum(bus[:, PD]), load / total['both']['p']*total['fixed']['p'], 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), load / total['both']['p']*total['fixed']['q'], 8, [t, 'total fixed Q']) t_is(-sum(gen[ld, PMIN]), load / total['both']['p']*total['disp']['p'], 8, [t, 'total disp P']) t_is(-sum(gen[ld, QMIN]), load / total['both']['p']*total['disp']['qmin'], 8, [t, 'total disp Qmin']) t_is(-sum(gen[ld, QMAX]), load / total['both']['p']*total['disp']['qmax'], 8, [t, 'total disp Qmax']) t = 'all loads (P) => total = 200 : ' opt = {'scale': 'QUANTITY', 'pq': 'P'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) t_is(sum(bus[:, PD]), load / total['both']['p']*total['fixed']['p'], 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), total['fixed']['q'], 8, [t, 'total fixed Q']) t_is(-sum(gen[ld, PMIN]), load / total['both']['p']*total['disp']['p'], 8, [t, 'total disp P']) t_is(-sum(gen[ld, QMIN]), total['disp']['qmin'], 8, [t, 'total disp Qmin']) t_is(-sum(gen[ld, QMAX]), total['disp']['qmax'], 8, [t, 'total disp Qmax']) t = 'all disp loads (PQ) => total = 200 : ' opt = {'scale': 'QUANTITY', 'which': 'DISPATCHABLE'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) t_is(sum(bus[:, PD]), total['fixed']['p'], 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), total['fixed']['q'], 8, [t, 'total fixed Q']) t_is(-sum(gen[ld, PMIN]), load - total['fixed']['p'], 8, [t, 'total disp P']) t_is(-sum(gen[ld, QMIN]), (load - total['fixed']['p'])/total['disp']['p']*total['disp']['qmin'], 8, [t, 'total disp Qmin']) t_is(-sum(gen[ld, QMAX]), (load - total['fixed']['p'])/total['disp']['p']*total['disp']['qmax'], 8, [t, 'total disp Qmax']) t = 'all disp loads (P) => total = 200 : ' opt = {'scale': 'QUANTITY', 'pq': 'P', 'which': 'DISPATCHABLE'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) t_is(sum(bus[:, PD]), total['fixed']['p'], 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), total['fixed']['q'], 8, [t, 'total fixed Q']) t_is(-sum(gen[ld, PMIN]), load - total['fixed']['p'], 8, [t, 'total disp P']) t_is(-sum(gen[ld, QMIN]), total['disp']['qmin'], 8, [t, 'total disp Qmin']) t_is(-sum(gen[ld, QMAX]), total['disp']['qmax'], 8, [t, 'total disp Qmax']) ##----- 3 zones, area scale factors ----- t = 'area fixed loads (PQ) * [3 2 1] : ' load = array([3, 2, 1]) bus, _ = scale_load(load, ppc['bus']) for k in range(len(load)): t_is(sum(bus[a[k], PD]), load[k] * area[k]['fixed']['p'], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), load[k] * area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) opt = {'which': 'FIXED'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) for k in range(len(load)): t_is(sum(bus[a[k], PD]), load[k] * area[k]['fixed']['p'], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), load[k] * area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) t_is(-sum(gen[lda[k], PMIN]), area[k]['disp']['p'], 8, '%s area %d disp P' % (t, k)) t_is(-sum(gen[lda[k], QMIN]), area[k]['disp']['qmin'], 8, '%s area %d disp Qmin' % (t, k)) t_is(-sum(gen[lda[k], QMAX]), area[k]['disp']['qmax'], 8, '%s area %d disp Qmax' % (t, k)) t = 'area fixed loads (P) * [3 2 1] : ' load = array([3, 2, 1]) opt = {'pq': 'P'} bus, _ = scale_load(load, ppc['bus'], None, None, opt) for k in range(len(load)): t_is(sum(bus[a[k], PD]), load[k] * area[k]['fixed']['p'], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) opt = {'pq': 'P', 'which': 'FIXED'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) for k in range(len(load)): t_is(sum(bus[a[k], PD]), load[k] * area[k]['fixed']['p'], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) t_is(-sum(gen[lda[k], PMIN]), area[k]['disp']['p'], 8, '%s area %d disp P' % (t, k)) t_is(-sum(gen[lda[k], QMIN]), area[k]['disp']['qmin'], 8, '%s area %d disp Qmin' % (t, k)) t_is(-sum(gen[lda[k], QMAX]), area[k]['disp']['qmax'], 8, '%s area %d disp Qmax' % (t, k)) t = 'all area loads (PQ) * [3 2 1] : ' bus, gen = scale_load(load, ppc['bus'], ppc['gen']) for k in range(len(load)): t_is(sum(bus[a[k], PD]), load[k] * area[k]['fixed']['p'], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), load[k] * area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) t_is(-sum(gen[lda[k], PMIN]), load[k] * area[k]['disp']['p'], 8, '%s area %d disp P' % (t, k)) t_is(-sum(gen[lda[k], QMIN]), load[k] * area[k]['disp']['qmin'], 8, '%s area %d disp Qmin' % (t, k)) t_is(-sum(gen[lda[k], QMAX]), load[k] * area[k]['disp']['qmax'], 8, '%s area %d disp Qmax' % (t, k)) t = 'all area loads (P) * [3 2 1] : ' opt = {'pq': 'P'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) for k in range(len(load)): t_is(sum(bus[a[k], PD]), load[k] * area[k]['fixed']['p'], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) t_is(-sum(gen[lda[k], PMIN]), load[k] * area[k]['disp']['p'], 8, '%s area %d disp P' % (t, k)) t_is(-sum(gen[lda[k], QMIN]), area[k]['disp']['qmin'], 8, '%s area %d disp Qmin' % (t, k)) t_is(-sum(gen[lda[k], QMAX]), area[k]['disp']['qmax'], 8, '%s area %d disp Qmax' % (t, k)) t = 'area disp loads (PQ) * [3 2 1] : ' opt = {'which': 'DISPATCHABLE'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) for k in range(len(load)): t_is(sum(bus[a[k], PD]), area[k]['fixed']['p'], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) t_is(-sum(gen[lda[k], PMIN]), load[k] * area[k]['disp']['p'], 8, '%s area %d disp P' % (t, k)) t_is(-sum(gen[lda[k], QMIN]), load[k] * area[k]['disp']['qmin'], 8, '%s area %d disp Qmin' % (t, k)) t_is(-sum(gen[lda[k], QMAX]), load[k] * area[k]['disp']['qmax'], 8, '%s area %d disp Qmax' % (t, k)) t = 'area disp loads (P) * [3 2 1] : ' opt = {'pq': 'P', 'which': 'DISPATCHABLE'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) for k in range(len(load)): t_is(sum(bus[a[k], PD]), area[k]['fixed']['p'], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) t_is(-sum(gen[lda[k], PMIN]), load[k] * area[k]['disp']['p'], 8, '%s area %d disp P' % (t, k)) t_is(-sum(gen[lda[k], QMIN]), area[k]['disp']['qmin'], 8, '%s area %d disp Qmin' % (t, k)) t_is(-sum(gen[lda[k], QMAX]), area[k]['disp']['qmax'], 8, '%s area %d disp Qmax' % (t, k)) ##----- 3 zones, area scale quantities ----- t = 'area fixed loads (PQ) => total = [100 80 60] : ' load = array([100, 80, 60], float) opt = {'scale': 'QUANTITY'} bus, _ = scale_load(load, ppc['bus'], None, None, opt) for k in range(len(load)): t_is(sum(bus[a[k], PD]), load[k], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), load[k] / area[k]['fixed']['p'] * area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) opt = {'scale': 'QUANTITY', 'which': 'FIXED'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) for k in range(len(load)): t_is(sum(bus[a[k], PD]), load[k] - area[k]['disp']['p'], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), (load[k] - area[k]['disp']['p']) / area[k]['fixed']['p'] * area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) t_is(-sum(gen[lda[k], PMIN]), area[k]['disp']['p'], 8, '%s area %d disp P' % (t, k)) t_is(-sum(gen[lda[k], QMIN]), area[k]['disp']['qmin'], 8, '%s area %d disp Qmin' % (t, k)) t_is(-sum(gen[lda[k], QMAX]), area[k]['disp']['qmax'], 8, '%s area %d disp Qmax' % (t, k)) t = 'area fixed loads (P) => total = [100 80 60] : ' load = array([100, 80, 60], float) opt = {'scale': 'QUANTITY', 'pq': 'P'} bus, _ = scale_load(load, ppc['bus'], None, None, opt) for k in range(len(load)): t_is(sum(bus[a[k], PD]), load[k], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) opt = {'scale': 'QUANTITY', 'pq': 'P', 'which': 'FIXED'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) for k in range(len(load)): t_is(sum(bus[a[k], PD]), load[k]-area[k]['disp']['p'], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) t_is(-sum(gen[lda[k], PMIN]), area[k]['disp']['p'], 8, '%s area %d disp P' % (t, k)) t_is(-sum(gen[lda[k], QMIN]), area[k]['disp']['qmin'], 8, '%s area %d disp Qmin' % (t, k)) t_is(-sum(gen[lda[k], QMAX]), area[k]['disp']['qmax'], 8, '%s area %d disp Qmax' % (t, k)) t = 'all area loads (PQ) => total = [100 80 60] : ' opt = {'scale': 'QUANTITY'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) for k in range(len(load)): t_is(sum(bus[a[k], PD]), load[k] / area[k]['both']['p'] * area[k]['fixed']['p'], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), load[k] / area[k]['both']['p'] * area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) t_is(-sum(gen[lda[k], PMIN]), load[k] / area[k]['both']['p'] * area[k]['disp']['p'], 8, '%s area %d disp P' % (t, k)) t_is(-sum(gen[lda[k], QMIN]), load[k] / area[k]['both']['p'] * area[k]['disp']['qmin'], 8, '%s area %d disp Qmin' % (t, k)) t_is(-sum(gen[lda[k], QMAX]), load[k] / area[k]['both']['p'] * area[k]['disp']['qmax'], 8, '%s area %d disp Qmax' % (t, k)) t = 'all area loads (P) => total = [100 80 60] : ' opt = {'scale': 'QUANTITY', 'pq': 'P'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) for k in range(len(load)): t_is(sum(bus[a[k], PD]), load[k] / area[k]['both']['p'] * area[k]['fixed']['p'], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) t_is(-sum(gen[lda[k], PMIN]), load[k] / area[k]['both']['p'] * area[k]['disp']['p'], 8, '%s area %d disp P' % (t, k)) t_is(-sum(gen[lda[k], QMIN]), area[k]['disp']['qmin'], 8, '%s area %d disp Qmin' % (t, k)) t_is(-sum(gen[lda[k], QMAX]), area[k]['disp']['qmax'], 8, '%s area %d disp Qmax' % (t, k)) t = 'area disp loads (PQ) => total = [100 80 60] : throws expected exception' load = array([100, 80, 60], float) opt = {'scale': 'QUANTITY', 'which': 'DISPATCHABLE'} err = 0 try: bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) except ScalingError as e: expected = 'scale_load: impossible to make zone 2 load equal 80 by scaling non-existent dispatchable load' err = expected not in str(e) t_ok(err, t) t = 'area disp loads (PQ) => total = [100 74.3941 60] : ' load = array([100, area[1]['fixed']['p'], 60], float) opt = {'scale': 'QUANTITY', 'which': 'DISPATCHABLE'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) for k in range(len(load)): t_is(sum(bus[a[k], PD]), area[k]['fixed']['p'], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) t_is(-sum(gen[lda[k], PMIN]), load[k]-area[k]['fixed']['p'], 8, '%s area %d disp P' % (t, k)) if k == 1: t_is(-sum(gen[lda[k], QMIN]), area[k]['disp']['qmin'], 8, '%s area %d disp Qmin' % (t, k)) t_is(-sum(gen[lda[k], QMAX]), area[k]['disp']['qmax'], 8, '%s area %d disp Qmax' % (t, k)) else: t_is(-sum(gen[lda[k], QMIN]), (load[k] - area[k]['fixed']['p']) / area[k]['disp']['p'] * area[k]['disp']['qmin'], 8, '%s area %d disp Qmin' % (t, k)) t_is(-sum(gen[lda[k], QMAX]), (load[k] - area[k]['fixed']['p']) / area[k]['disp']['p'] * area[k]['disp']['qmax'], 8, '%s area %d disp Qmax' % (t, k)) t = 'area disp loads (P) => total = [100 74.3941 60] : ' opt = {'scale': 'QUANTITY', 'pq': 'P', 'which': 'DISPATCHABLE'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) for k in range(len(load)): t_is(sum(bus[a[k], PD]), area[k]['fixed']['p'], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) t_is(-sum(gen[lda[k], PMIN]), load[k]-area[k]['fixed']['p'], 8, '%s area %d disp P' % (t, k)) t_is(-sum(gen[lda[k], QMIN]), area[k]['disp']['qmin'], 8, '%s area %d disp Qmin' % (t, k)) t_is(-sum(gen[lda[k], QMAX]), area[k]['disp']['qmax'], 8, '%s area %d disp Qmax' % (t, k)) ##----- explict single load zone ----- t = 'explicit single load zone' load_zone = zeros(ppc['bus'].shape[0]) load_zone[[2, 3]] = 1 load = array([2.0]) bus, gen = scale_load(load, ppc['bus'], ppc['gen'], load_zone) Pd = ppc['bus'][:, PD] Pd[[2, 3]] = load * Pd[[2, 3]] t_is( bus[:, PD], Pd, 8, t) ##----- explict multiple load zone ----- t = 'explicit multiple load zone' load_zone = zeros(ppc['bus'].shape[0]) load_zone[[2, 3]] = 1 load_zone[[6, 7]] = 2 load = array([2, 0.5]) bus, gen = scale_load(load, ppc['bus'], ppc['gen'], load_zone) Pd = ppc['bus'][:, PD] Pd[[2, 3]] = load[0] * Pd[[2, 3]] Pd[[6, 7]] = load[1] * Pd[[6, 7]] t_is( bus[:, PD], Pd, 8, t) t_end()
def t_dcline(quiet=False): """Tests for DC line extension in L{{toggle_dcline}. @author: Ray Zimmerman (PSERC Cornell) @author: Richard Lincoln """ num_tests = 50 t_begin(num_tests, quiet) tdir = dirname(__file__) casefile = join(tdir, 't_case9_dcline') if quiet: verbose = False else: verbose = False t0 = '' ppopt = ppoption(OPF_VIOLATION=1e-6, PDIPM_GRADTOL=1e-8, PDIPM_COMPTOL=1e-8, PDIPM_COSTTOL=1e-9) ppopt = ppoption(ppopt, OPF_ALG=560, OPF_ALG_DC=200) ppopt = ppoption(ppopt, OUT_ALL=0, VERBOSE=verbose) ## set up indices ib_data = r_[arange(BUS_AREA + 1), arange(BASE_KV, VMIN + 1)] ib_voltage = arange(VM, VA + 1) ib_lam = arange(LAM_P, LAM_Q + 1) ib_mu = arange(MU_VMAX, MU_VMIN + 1) ig_data = r_[[GEN_BUS, QMAX, QMIN], arange(MBASE, APF + 1)] ig_disp = array([PG, QG, VG]) ig_mu = arange(MU_PMAX, MU_QMIN + 1) ibr_data = arange(ANGMAX + 1) ibr_flow = arange(PF, QT + 1) ibr_mu = array([MU_SF, MU_ST]) ibr_angmu = array([MU_ANGMIN, MU_ANGMAX]) ## load case ppc0 = loadcase(casefile) del ppc0['dclinecost'] ppc = ppc0 ppc = toggle_dcline(ppc, 'on') ppc = toggle_dcline(ppc, 'off') ndc = ppc['dcline'].shape[0] ## run AC OPF w/o DC lines t = ''.join([t0, 'AC OPF (no DC lines) : ']) r0 = runopf(ppc0, ppopt) success = r0['success'] t_ok(success, [t, 'success']) r = runopf(ppc, ppopt) success = r['success'] t_ok(success, [t, 'success']) t_is(r['f'], r0['f'], 8, [t, 'f']) t_is( r['bus'][:,ib_data ], r0['bus'][:,ib_data ], 10, [t, 'bus data']) t_is( r['bus'][:,ib_voltage], r0['bus'][:,ib_voltage], 3, [t, 'bus voltage']) t_is( r['bus'][:,ib_lam ], r0['bus'][:,ib_lam ], 3, [t, 'bus lambda']) t_is( r['bus'][:,ib_mu ], r0['bus'][:,ib_mu ], 2, [t, 'bus mu']) t_is( r['gen'][:,ig_data ], r0['gen'][:,ig_data ], 10, [t, 'gen data']) t_is( r['gen'][:,ig_disp ], r0['gen'][:,ig_disp ], 3, [t, 'gen dispatch']) t_is( r['gen'][:,ig_mu ], r0['gen'][:,ig_mu ], 3, [t, 'gen mu']) t_is(r['branch'][:,ibr_data ], r0['branch'][:,ibr_data ], 10, [t, 'branch data']) t_is(r['branch'][:,ibr_flow ], r0['branch'][:,ibr_flow ], 3, [t, 'branch flow']) t_is(r['branch'][:,ibr_mu ], r0['branch'][:,ibr_mu ], 2, [t, 'branch mu']) t = ''.join([t0, 'AC PF (no DC lines) : ']) ppc1 = {'baseMVA': r['baseMVA'], 'bus': r['bus'][:, :VMIN + 1].copy(), 'gen': r['gen'][:, :APF + 1].copy(), 'branch': r['branch'][:, :ANGMAX + 1].copy(), 'gencost': r['gencost'].copy(), 'dcline': r['dcline'][:, :c.LOSS1 + 1].copy()} ppc1['bus'][:, VM] = 1 ppc1['bus'][:, VA] = 0 rp = runpf(ppc1, ppopt) success = rp['success'] t_ok(success, [t, 'success']) t_is( rp['bus'][:,ib_voltage], r['bus'][:,ib_voltage], 3, [t, 'bus voltage']) t_is( rp['gen'][:,ig_disp ], r['gen'][:,ig_disp ], 3, [t, 'gen dispatch']) t_is(rp['branch'][:,ibr_flow ], r['branch'][:,ibr_flow ], 3, [t, 'branch flow']) ## run with DC lines t = ''.join([t0, 'AC OPF (with DC lines) : ']) ppc = toggle_dcline(ppc, 'on') r = runopf(ppc, ppopt) success = r['success'] t_ok(success, [t, 'success']) expected = array([ [10, 8.9, -10, 10, 1.0674, 1.0935], [2.2776, 2.2776, 0, 0, 1.0818, 1.0665], [0, 0, 0, 0, 1.0000, 1.0000], [10, 9.5, 0.0563, -10, 1.0778, 1.0665] ]) t_is(r['dcline'][:, c.PF:c.VT + 1], expected, 4, [t, 'P Q V']) expected = array([ [0, 0.8490, 0.6165, 0, 0, 0.2938], [0, 0, 0, 0.4290, 0.0739, 0], [0, 0, 0, 0, 0, 0], [0, 7.2209, 0, 0, 0.0739, 0] ]) t_is(r['dcline'][:, c.MU_PMIN:c.MU_QMAXT + 1], expected, 3, [t, 'mu']) t = ''.join([t0, 'AC PF (with DC lines) : ']) ppc1 = {'baseMVA': r['baseMVA'], 'bus': r['bus'][:, :VMIN + 1].copy(), 'gen': r['gen'][:, :APF + 1].copy(), 'branch': r['branch'][:, :ANGMAX + 1].copy(), 'gencost': r['gencost'].copy(), 'dcline': r['dcline'][:, :c.LOSS1 + 1].copy()} ppc1 = toggle_dcline(ppc1, 'on') ppc1['bus'][:, VM] = 1 ppc1['bus'][:, VA] = 0 rp = runpf(ppc1, ppopt) success = rp['success'] t_ok(success, [t, 'success']) t_is( rp['bus'][:,ib_voltage], r['bus'][:,ib_voltage], 3, [t, 'bus voltage']) #t_is( rp['gen'][:,ig_disp ], r['gen'][:,ig_disp ], 3, [t, 'gen dispatch']) t_is( rp['gen'][:2,ig_disp ], r['gen'][:2,ig_disp ], 3, [t, 'gen dispatch']) t_is( rp['gen'][2,PG ], r['gen'][2,PG ], 3, [t, 'gen dispatch']) t_is( rp['gen'][2,QG]+rp['dcline'][0,c.QF], r['gen'][2,QG]+r['dcline'][0,c.QF], 3, [t, 'gen dispatch']) t_is(rp['branch'][:,ibr_flow ], r['branch'][:,ibr_flow ], 3, [t, 'branch flow']) ## add appropriate P and Q injections and check angles and generation when running PF t = ''.join([t0, 'AC PF (with equivalent injections) : ']) ppc1 = {'baseMVA': r['baseMVA'], 'bus': r['bus'][:, :VMIN + 1].copy(), 'gen': r['gen'][:, :APF + 1].copy(), 'branch': r['branch'][:, :ANGMAX + 1].copy(), 'gencost': r['gencost'].copy(), 'dcline': r['dcline'][:, :c.LOSS1 + 1].copy()} ppc1['bus'][:, VM] = 1 ppc1['bus'][:, VA] = 0 for k in range(ndc): if ppc1['dcline'][k, c.BR_STATUS]: ff = find(ppc1['bus'][:, BUS_I] == ppc1['dcline'][k, c.F_BUS]) tt = find(ppc1['bus'][:, BUS_I] == ppc1['dcline'][k, c.T_BUS]) ppc1['bus'][ff, PD] = ppc1['bus'][ff, PD] + r['dcline'][k, c.PF] ppc1['bus'][ff, QD] = ppc1['bus'][ff, QD] - r['dcline'][k, c.QF] ppc1['bus'][tt, PD] = ppc1['bus'][tt, PD] - r['dcline'][k, c.PT] ppc1['bus'][tt, QD] = ppc1['bus'][tt, QD] - r['dcline'][k, c.QT] ppc1['bus'][ff, VM] = r['dcline'][k, c.VF] ppc1['bus'][tt, VM] = r['dcline'][k, c.VT] ppc1['bus'][ff, BUS_TYPE] = PV ppc1['bus'][tt, BUS_TYPE] = PV rp = runpf(ppc1, ppopt) success = rp['success'] t_ok(success, [t, 'success']) t_is( rp['bus'][:,ib_voltage], r['bus'][:,ib_voltage], 3, [t, 'bus voltage']) t_is( rp['gen'][:,ig_disp ], r['gen'][:,ig_disp ], 3, [t, 'gen dispatch']) t_is(rp['branch'][:,ibr_flow ], r['branch'][:,ibr_flow ], 3, [t, 'branch flow']) ## test DC OPF t = ''.join([t0, 'DC OPF (with DC lines) : ']) ppc = ppc0.copy() ppc['gen'][0, PMIN] = 10 ppc['branch'][4, RATE_A] = 100 ppc = toggle_dcline(ppc, 'on') r = rundcopf(ppc, ppopt) success = r['success'] t_ok(success, [t, 'success']) expected = array([ [10, 8.9, 0, 0, 1.01, 1], [2, 2, 0, 0, 1, 1], [0, 0, 0, 0, 1, 1], [10, 9.5, 0, 0, 1, 0.98] ]) t_is(r['dcline'][:, c.PF:c.VT + 1], expected, 4, [t, 'P Q V']) expected = array([ [0, 1.8602, 0, 0, 0, 0], [1.8507, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0.2681, 0, 0, 0, 0] ]) t_is(r['dcline'][:, c.MU_PMIN:c.MU_QMAXT + 1], expected, 3, [t, 'mu']) t = ''.join([t0, 'DC PF (with DC lines) : ']) ppc1 = {'baseMVA': r['baseMVA'], 'bus': r['bus'][:, :VMIN + 1].copy(), 'gen': r['gen'][:, :APF + 1].copy(), 'branch': r['branch'][:, :ANGMAX + 1].copy(), 'gencost': r['gencost'].copy(), 'dcline': r['dcline'][:, :c.LOSS1 + 1].copy()} ppc1 = toggle_dcline(ppc1, 'on') ppc1['bus'][:, VA] = 0 rp = rundcpf(ppc1, ppopt) success = rp['success'] t_ok(success, [t, 'success']) t_is( rp['bus'][:,ib_voltage], r['bus'][:,ib_voltage], 3, [t, 'bus voltage']) t_is( rp['gen'][:,ig_disp ], r['gen'][:,ig_disp ], 3, [t, 'gen dispatch']) t_is(rp['branch'][:,ibr_flow ], r['branch'][:,ibr_flow ], 3, [t, 'branch flow']) ## add appropriate P injections and check angles and generation when running PF t = ''.join([t0, 'DC PF (with equivalent injections) : ']) ppc1 = {'baseMVA': r['baseMVA'], 'bus': r['bus'][:, :VMIN + 1].copy(), 'gen': r['gen'][:, :APF + 1].copy(), 'branch': r['branch'][:, :ANGMAX + 1].copy(), 'gencost': r['gencost'].copy(), 'dcline': r['dcline'][:, :c.LOSS1 + 1].copy()} ppc1['bus'][:, VA] = 0 for k in range(ndc): if ppc1['dcline'][k, c.BR_STATUS]: ff = find(ppc1['bus'][:, BUS_I] == ppc1['dcline'][k, c.F_BUS]) tt = find(ppc1['bus'][:, BUS_I] == ppc1['dcline'][k, c.T_BUS]) ppc1['bus'][ff, PD] = ppc1['bus'][ff, PD] + r['dcline'][k, c.PF] ppc1['bus'][tt, PD] = ppc1['bus'][tt, PD] - r['dcline'][k, c.PT] ppc1['bus'][ff, BUS_TYPE] = PV ppc1['bus'][tt, BUS_TYPE] = PV rp = rundcpf(ppc1, ppopt) success = rp['success'] t_ok(success, [t, 'success']) t_is( rp['bus'][:,ib_voltage], r['bus'][:,ib_voltage], 3, [t, 'bus voltage']) t_is( rp['gen'][:,ig_disp ], r['gen'][:,ig_disp ], 3, [t, 'gen dispatch']) t_is(rp['branch'][:,ibr_flow ], r['branch'][:,ibr_flow ], 3, [t, 'branch flow']) ## run with DC lines t = ''.join([t0, 'AC OPF (with DC lines + poly cost) : ']) ppc = loadcase(casefile) ppc = toggle_dcline(ppc, 'on') r = runopf(ppc, ppopt) success = r['success'] t_ok(success, [t, 'success']) expected1 = array([ [10, 8.9, -10, 10, 1.0663, 1.0936], [7.8429, 7.8429, 0, 0, 1.0809, 1.0667], [0, 0, 0, 0, 1.0000, 1.0000], [6.0549, 5.7522, -0.5897, -10, 1.0778, 1.0667] ]) t_is(r['dcline'][:, c.PF:c.VT + 1], expected1, 4, [t, 'P Q V']) expected2 = array([ [0, 0.7605, 0.6226, 0, 0, 0.2980], [0, 0, 0, 0.4275, 0.0792, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0.0792, 0] ]) t_is(r['dcline'][:, c.MU_PMIN:c.MU_QMAXT + 1], expected2, 3, [t, 'mu']) ppc['dclinecost'][3, :8] = array([2, 0, 0, 4, 0, 0, 7.3, 0]) r = runopf(ppc, ppopt) success = r['success'] t_ok(success, [t, 'success']) t_is(r['dcline'][:, c.PF:c.VT + 1], expected1, 4, [t, 'P Q V']) t_is(r['dcline'][:, c.MU_PMIN:c.MU_QMAXT + 1], expected2, 3, [t, 'mu']) t = ''.join([t0, 'AC OPF (with DC lines + pwl cost) : ']) ppc['dclinecost'][3, :8] = array([1, 0, 0, 2, 0, 0, 10, 73]) r = runopf(ppc, ppopt) success = r['success'] t_ok(success, [t, 'success']) t_is(r['dcline'][:, c.PF:c.VT + 1], expected1, 4, [t, 'P Q V']) t_is(r['dcline'][:, c.MU_PMIN:c.MU_QMAXT + 1], expected2, 3, [t, 'mu']) t_end()
def t_qps_pypower(quiet=False): """Tests of C{qps_pypower} QP solvers. @author: Ray Zimmerman (PSERC Cornell) @author: Richard Lincoln """ algs = [200, 250, 400, 500, 600, 700] names = ['PIPS', 'sc-PIPS', 'IPOPT', 'CPLEX', 'MOSEK', 'Gurobi'] check = [None, None, 'ipopt', 'cplex', 'mosek', 'gurobipy'] n = 36 t_begin(n * len(algs), quiet) for k in range(len(algs)): if check[k] is not None and not have_fcn(check[k]): t_skip(n, '%s not installed' % names[k]) else: opt = {'verbose': 0, 'alg': algs[k]} if names[k] == 'PIPS' or names[k] == 'sc-PIPS': opt['pips_opt'] = {} opt['pips_opt']['comptol'] = 1e-8 if names[k] == 'CPLEX': # alg = 0 ## default uses barrier method with NaN bug in lower lim multipliers alg = 2 ## use dual simplex ppopt = ppoption(CPLEX_LPMETHOD=alg, CPLEX_QPMETHOD=min([4, alg])) opt['cplex_opt'] = cplex_options([], ppopt) if names[k] == 'MOSEK': # alg = 5 ## use dual simplex ppopt = ppoption() # ppopt = ppoption(ppopt, MOSEK_LP_ALG = alg) ppopt = ppoption(ppopt, MOSEK_GAP_TOL=1e-9) opt['mosek_opt'] = mosek_options([], ppopt) t = '%s - 3-d LP : ' % names[k] ## example from 'doc linprog' c = array([-5, -4, -6], float) A = sparse([[1, -1, 1], [3, 2, 4], [3, 2, 0]], dtype=float) l = None u = array([20, 42, 30], float) xmin = array([0, 0, 0], float) x0 = None x, f, s, _, lam = qps_pypower(None, c, A, l, u, xmin, None, None, opt) t_is(s, 1, 12, [t, 'success']) t_is(x, [0, 15, 3], 6, [t, 'x']) t_is(f, -78, 6, [t, 'f']) t_is(lam['mu_l'], [0, 0, 0], 13, [t, 'lam.mu_l']) t_is(lam['mu_u'], [0, 1.5, 0.5], 9, [t, 'lam.mu_u']) t_is(lam['lower'], [1, 0, 0], 9, [t, 'lam.lower']) t_is(lam['upper'], zeros(shape(x)), 13, [t, 'lam.upper']) t = '%s - unconstrained 3-d quadratic : ' % names[k] ## from http://www.akiti.ca/QuadProgEx0Constr.html H = sparse([[5, -2, -1], [-2, 4, 3], [-1, 3, 5]], dtype=float) c = array([2, -35, -47], float) x0 = array([0, 0, 0], float) x, f, s, _, lam = qps_pypower(H, c, opt=opt) t_is(s, 1, 12, [t, 'success']) t_is(x, [3, 5, 7], 8, [t, 'x']) t_is(f, -249, 13, [t, 'f']) t_ok(len(lam['mu_l']) == 0, [t, 'lam.mu_l']) t_ok(len(lam['mu_u']) == 0, [t, 'lam.mu_u']) t_is(lam['lower'], zeros(shape(x)), 13, [t, 'lam.lower']) t_is(lam['upper'], zeros(shape(x)), 13, [t, 'lam.upper']) t = '%s - constrained 2-d QP : ' % names[k] ## example from 'doc quadprog' H = sparse([[1, -1], [-1, 2]], dtype=float) c = array([-2, -6], float) A = sparse([[1, 1], [-1, 2], [2, 1]], dtype=float) l = None u = array([2, 2, 3], float) xmin = array([0, 0]) x0 = None x, f, s, _, lam = qps_pypower(H, c, A, l, u, xmin, None, x0, opt) t_is(s, 1, 12, [t, 'success']) t_is(x, array([2., 4.]) / 3, 7, [t, 'x']) t_is(f, -74. / 9, 6, [t, 'f']) t_is(lam['mu_l'], [0., 0., 0.], 13, [t, 'lam.mu_l']) t_is(lam['mu_u'], array([28., 4., 0.]) / 9, 7, [t, 'lam.mu_u']) t_is(lam['lower'], zeros(shape(x)), 8, [t, 'lam.lower']) t_is(lam['upper'], zeros(shape(x)), 13, [t, 'lam.upper']) t = '%s - constrained 4-d QP : ' % names[k] ## from http://www.jmu.edu/docs/sasdoc/sashtml/iml/chap8/sect12.htm H = sparse([[1003.1, 4.3, 6.3, 5.9], [4.3, 2.2, 2.1, 3.9], [6.3, 2.1, 3.5, 4.8], [5.9, 3.9, 4.8, 10.0]]) c = zeros(4) A = sparse([[1, 1, 1, 1], [0.17, 0.11, 0.10, 0.18]]) l = array([1, 0.10]) u = array([1, Inf]) xmin = zeros(4) x0 = array([1, 0, 0, 1], float) x, f, s, _, lam = qps_pypower(H, c, A, l, u, xmin, None, x0, opt) t_is(s, 1, 12, [t, 'success']) t_is(x, array([0, 2.8, 0.2, 0]) / 3, 5, [t, 'x']) t_is(f, 3.29 / 3, 6, [t, 'f']) t_is(lam['mu_l'], array([6.58, 0]) / 3, 6, [t, 'lam.mu_l']) t_is(lam['mu_u'], [0, 0], 13, [t, 'lam.mu_u']) t_is(lam['lower'], [2.24, 0, 0, 1.7667], 4, [t, 'lam.lower']) t_is(lam['upper'], zeros(shape(x)), 13, [t, 'lam.upper']) t = '%s - (dict) constrained 4-d QP : ' % names[k] p = { 'H': H, 'A': A, 'l': l, 'u': u, 'xmin': xmin, 'x0': x0, 'opt': opt } x, f, s, _, lam = qps_pypower(p) t_is(s, 1, 12, [t, 'success']) t_is(x, array([0, 2.8, 0.2, 0]) / 3, 5, [t, 'x']) t_is(f, 3.29 / 3, 6, [t, 'f']) t_is(lam['mu_l'], array([6.58, 0]) / 3, 6, [t, 'lam.mu_l']) t_is(lam['mu_u'], [0, 0], 13, [t, 'lam.mu_u']) t_is(lam['lower'], [2.24, 0, 0, 1.7667], 4, [t, 'lam.lower']) t_is(lam['upper'], zeros(shape(x)), 13, [t, 'lam.upper']) t = '%s - infeasible LP : ' % names[k] p = { 'A': sparse([1, 1]), 'c': array([1, 1]), 'u': array([-1]), 'xmin': array([0, 0]), 'opt': opt } x, f, s, _, lam = qps_pypower(p) t_ok(s <= 0, [t, 'no success']) t_end()
def t_opf_dc_pips_sc(quiet=False): """Tests for DC optimal power flow using PIPS-sc solver. @author: Ray Zimmerman (PSERC Cornell) @author: Richard Lincoln """ num_tests = 23 t_begin(num_tests, quiet) tdir = dirname(__file__) casefile = join(tdir, 't_case9_opf') verbose = 0 #not quiet t0 = 'DC OPF (PIPS-sc): ' ppopt = ppoption(VERBOSE=verbose, OUT_ALL=0, OPF_ALG_DC=250) ## run DC OPF ## set up indices ib_data = r_[arange(BUS_AREA + 1), arange(BASE_KV, VMIN + 1)] ib_voltage = arange(VM, VA + 1) ib_lam = arange(LAM_P, LAM_Q + 1) ib_mu = arange(MU_VMAX, MU_VMIN + 1) ig_data = r_[[GEN_BUS, QMAX, QMIN], arange(MBASE, APF + 1)] ig_disp = array([PG, QG, VG]) ig_mu = arange(MU_PMAX, MU_QMIN + 1) ibr_data = arange(ANGMAX + 1) ibr_flow = arange(PF, QT + 1) ibr_mu = array([MU_SF, MU_ST]) #ibr_angmu = array([MU_ANGMIN, MU_ANGMAX]) ## get solved DC power flow case from MAT-file soln9_dcopf = loadmat(join(tdir, 'soln9_dcopf.mat'), struct_as_record=True) ## defines bus_soln, gen_soln, branch_soln, f_soln bus_soln = soln9_dcopf['bus_soln'] gen_soln = soln9_dcopf['gen_soln'] branch_soln = soln9_dcopf['branch_soln'] f_soln = soln9_dcopf['f_soln'][0] ## run OPF t = t0 r = rundcopf(casefile, ppopt) bus, gen, branch, f, success = \ r['bus'], r['gen'], r['branch'], r['f'], r['success'] t_ok(success, [t, 'success']) t_is(f, f_soln, 3, [t, 'f']) t_is(bus[:, ib_data], bus_soln[:, ib_data], 10, [t, 'bus data']) t_is(bus[:, ib_voltage], bus_soln[:, ib_voltage], 3, [t, 'bus voltage']) t_is(bus[:, ib_lam], bus_soln[:, ib_lam], 3, [t, 'bus lambda']) t_is(bus[:, ib_mu], bus_soln[:, ib_mu], 2, [t, 'bus mu']) t_is(gen[:, ig_data], gen_soln[:, ig_data], 10, [t, 'gen data']) t_is(gen[:, ig_disp], gen_soln[:, ig_disp], 3, [t, 'gen dispatch']) t_is(gen[:, ig_mu], gen_soln[:, ig_mu], 3, [t, 'gen mu']) t_is(branch[:, ibr_data], branch_soln[:, ibr_data], 10, [t, 'branch data']) t_is(branch[:, ibr_flow], branch_soln[:, ibr_flow], 3, [t, 'branch flow']) t_is(branch[:, ibr_mu], branch_soln[:, ibr_mu], 2, [t, 'branch mu']) ##----- run OPF with extra linear user constraints & costs ----- ## two new z variables ## 0 <= z1, P2 - P1 <= z1 ## 0 <= z2, P2 - P3 <= z2 ## with A and N sized for DC opf ppc = loadcase(casefile) row = [0, 0, 0, 1, 1, 1] col = [9, 10, 12, 10, 11, 13] ppc['A'] = sparse(([-1, 1, -1, 1, -1, -1], (row, col)), (2, 14)) ppc['u'] = array([0, 0]) ppc['l'] = array([-Inf, -Inf]) ppc['zl'] = array([0, 0]) ppc['N'] = sparse(([1, 1], ([0, 1], [12, 13])), (2, 14)) ## new z variables only ppc['fparm'] = ones((2, 1)) * array([[1, 0, 0, 1]]) ## w = r = z ppc['H'] = sparse((2, 2)) ## no quadratic term ppc['Cw'] = array([1000, 1]) t = ''.join([t0, 'w/extra constraints & costs 1 : ']) r = rundcopf(ppc, ppopt) t_ok(r['success'], [t, 'success']) t_is(r['gen'][0, PG], 116.15974, 4, [t, 'Pg1 = 116.15974']) t_is(r['gen'][1, PG], 116.15974, 4, [t, 'Pg2 = 116.15974']) t_is(r['var']['val']['z'], [0, 0.3348], 4, [t, 'user vars']) t_is(r['cost']['usr'], 0.3348, 3, [t, 'user costs']) ## with A and N sized for AC opf ppc = loadcase(casefile) row = [0, 0, 0, 1, 1, 1] col = [18, 19, 24, 19, 20, 25] ppc['A'] = sparse(([-1, 1, -1, 1, -1, -1], (row, col)), (2, 26)) ppc['u'] = array([0, 0]) ppc['l'] = array([-Inf, -Inf]) ppc['zl'] = array([0, 0]) ppc['N'] = sparse(([1, 1], ([0, 1], [24, 25])), (2, 26)) ## new z variables only ppc['fparm'] = ones((2, 1)) * array([[1, 0, 0, 1]]) ## w = r = z ppc['H'] = sparse((2, 2)) ## no quadratic term ppc['Cw'] = array([1000, 1]) t = ''.join([t0, 'w/extra constraints & costs 2 : ']) r = rundcopf(ppc, ppopt) t_ok(r['success'], [t, 'success']) t_is(r['gen'][0, PG], 116.15974, 4, [t, 'Pg1 = 116.15974']) t_is(r['gen'][1, PG], 116.15974, 4, [t, 'Pg2 = 116.15974']) t_is(r['var']['val']['z'], [0, 0.3348], 4, [t, 'user vars']) t_is(r['cost']['usr'], 0.3348, 3, [t, 'user costs']) t = ''.join([t0, 'infeasible : ']) ## with A and N sized for DC opf ppc = loadcase(casefile) ppc['A'] = sparse(([1, 1], ([0, 0], [9, 10])), (1, 14)) ## Pg1 + Pg2 ppc['u'] = array([Inf]) ppc['l'] = array([600]) r = rundcopf(ppc, ppopt) t_ok(not r['success'], [t, 'no success']) t_end()
def t_opf_pips(quiet=False): """Tests for PIPS-based AC optimal power flow. @author: Ray Zimmerman (PSERC Cornell) """ num_tests = 101 t_begin(num_tests, quiet) tdir = dirname(__file__) casefile = join(tdir, 't_case9_opf') verbose = 0#not quiet t0 = 'PIPS : ' ppopt = ppoption(OPF_VIOLATION=1e-6, PDIPM_GRADTOL=1e-8, PDIPM_COMPTOL=1e-8, PDIPM_COSTTOL=1e-9) ppopt = ppoption(ppopt, OUT_ALL=0, VERBOSE=verbose, OPF_ALG=560) ## set up indices ib_data = r_[arange(BUS_AREA + 1), arange(BASE_KV, VMIN + 1)] ib_voltage = arange(VM, VA + 1) ib_lam = arange(LAM_P, LAM_Q + 1) ib_mu = arange(MU_VMAX, MU_VMIN + 1) ig_data = r_[[GEN_BUS, QMAX, QMIN], arange(MBASE, APF + 1)] ig_disp = array([PG, QG, VG]) ig_mu = arange(MU_PMAX, MU_QMIN + 1) ibr_data = arange(ANGMAX + 1) ibr_flow = arange(PF, QT + 1) ibr_mu = array([MU_SF, MU_ST]) ibr_angmu = array([MU_ANGMIN, MU_ANGMAX]) ## get solved AC power flow case from MAT-file soln9_opf = loadmat(join(tdir, 'soln9_opf.mat'), struct_as_record=True) ## defines bus_soln, gen_soln, branch_soln, f_soln bus_soln = soln9_opf['bus_soln'] gen_soln = soln9_opf['gen_soln'] branch_soln = soln9_opf['branch_soln'] f_soln = soln9_opf['f_soln'][0] ## run OPF t = t0 r = runopf(casefile, ppopt) bus, gen, branch, f, success = \ r['bus'], r['gen'], r['branch'], r['f'], r['success'] t_ok(success, [t, 'success']) t_is(f, f_soln, 3, [t, 'f']) t_is( bus[:, ib_data ], bus_soln[:, ib_data ], 10, [t, 'bus data']) t_is( bus[:, ib_voltage], bus_soln[:, ib_voltage], 3, [t, 'bus voltage']) t_is( bus[:, ib_lam ], bus_soln[:, ib_lam ], 3, [t, 'bus lambda']) t_is( bus[:, ib_mu ], bus_soln[:, ib_mu ], 2, [t, 'bus mu']) t_is( gen[:, ig_data ], gen_soln[:, ig_data ], 10, [t, 'gen data']) t_is( gen[:, ig_disp ], gen_soln[:, ig_disp ], 3, [t, 'gen dispatch']) t_is( gen[:, ig_mu ], gen_soln[:, ig_mu ], 3, [t, 'gen mu']) t_is(branch[:, ibr_data ], branch_soln[:, ibr_data ], 10, [t, 'branch data']) t_is(branch[:, ibr_flow ], branch_soln[:, ibr_flow ], 3, [t, 'branch flow']) t_is(branch[:, ibr_mu ], branch_soln[:, ibr_mu ], 2, [t, 'branch mu']) ## run with automatic conversion of single-block pwl to linear costs t = ''.join([t0, '(single-block PWL) : ']) ppc = loadcase(casefile) ppc['gencost'][2, NCOST] = 2 r = runopf(ppc, ppopt) bus, gen, branch, f, success = \ r['bus'], r['gen'], r['branch'], r['f'], r['success'] t_ok(success, [t, 'success']) t_is(f, f_soln, 3, [t, 'f']) t_is( bus[:, ib_data ], bus_soln[:, ib_data ], 10, [t, 'bus data']) t_is( bus[:, ib_voltage], bus_soln[:, ib_voltage], 3, [t, 'bus voltage']) t_is( bus[:, ib_lam ], bus_soln[:, ib_lam ], 3, [t, 'bus lambda']) t_is( bus[:, ib_mu ], bus_soln[:, ib_mu ], 2, [t, 'bus mu']) t_is( gen[:, ig_data ], gen_soln[:, ig_data ], 10, [t, 'gen data']) t_is( gen[:, ig_disp ], gen_soln[:, ig_disp ], 3, [t, 'gen dispatch']) t_is( gen[:, ig_mu ], gen_soln[:, ig_mu ], 3, [t, 'gen mu']) t_is(branch[:, ibr_data ], branch_soln[:, ibr_data ], 10, [t, 'branch data']) t_is(branch[:, ibr_flow ], branch_soln[:, ibr_flow ], 3, [t, 'branch flow']) t_is(branch[:, ibr_mu ], branch_soln[:, ibr_mu ], 2, [t, 'branch mu']) xr = r_[r['var']['val']['Va'], r['var']['val']['Vm'], r['var']['val']['Pg'], r['var']['val']['Qg'], 0, r['var']['val']['y']] t_is(r['x'], xr, 8, [t, 'check on raw x returned from OPF']) ## get solved AC power flow case from MAT-file soln9_opf_Plim = loadmat(join(tdir, 'soln9_opf_Plim.mat'), struct_as_record=True) ## defines bus_soln, gen_soln, branch_soln, f_soln bus_soln = soln9_opf_Plim['bus_soln'] gen_soln = soln9_opf_Plim['gen_soln'] branch_soln = soln9_opf_Plim['branch_soln'] f_soln = soln9_opf_Plim['f_soln'][0] ## run OPF with active power line limits t = ''.join([t0, '(P line lim) : ']) ppopt1 = ppoption(ppopt, OPF_FLOW_LIM=1) r = runopf(casefile, ppopt1) bus, gen, branch, f, success = \ r['bus'], r['gen'], r['branch'], r['f'], r['success'] t_ok(success, [t, 'success']) t_is(f, f_soln, 3, [t, 'f']) t_is( bus[:, ib_data ], bus_soln[:, ib_data ], 10, [t, 'bus data']) t_is( bus[:, ib_voltage], bus_soln[:, ib_voltage], 3, [t, 'bus voltage']) t_is( bus[:, ib_lam ], bus_soln[:, ib_lam ], 3, [t, 'bus lambda']) t_is( bus[:, ib_mu ], bus_soln[:, ib_mu ], 2, [t, 'bus mu']) t_is( gen[:, ig_data ], gen_soln[:, ig_data ], 10, [t, 'gen data']) t_is( gen[:, ig_disp ], gen_soln[:, ig_disp ], 3, [t, 'gen dispatch']) t_is( gen[:, ig_mu ], gen_soln[:, ig_mu ], 3, [t, 'gen mu']) t_is(branch[:, ibr_data ], branch_soln[:, ibr_data ], 10, [t, 'branch data']) t_is(branch[:, ibr_flow ], branch_soln[:, ibr_flow ], 3, [t, 'branch flow']) t_is(branch[:, ibr_mu ], branch_soln[:, ibr_mu ], 2, [t, 'branch mu']) ##----- test OPF with quadratic gen costs moved to generalized costs ----- ppc = loadcase(casefile) ppc['gencost'] = array([ [2, 1500, 0, 3, 0.11, 5, 0], [2, 2000, 0, 3, 0.085, 1.2, 0], [2, 3000, 0, 3, 0.1225, 1, 0] ]) r = runopf(ppc, ppopt) bus_soln, gen_soln, branch_soln, f_soln, success = \ r['bus'], r['gen'], r['branch'], r['f'], r['success'] branch_soln = branch_soln[:, :MU_ST + 1] A = None l = array([]) u = array([]) nb = ppc['bus'].shape[0] # number of buses ng = ppc['gen'].shape[0] # number of gens thbas = 0; thend = thbas + nb vbas = thend; vend = vbas + nb pgbas = vend; pgend = pgbas + ng # qgbas = pgend; qgend = qgbas + ng nxyz = 2 * nb + 2 * ng N = sparse((ppc['baseMVA'] * ones(ng), (arange(ng), arange(pgbas, pgend))), (ng, nxyz)) fparm = ones((ng, 1)) * array([[1, 0, 0, 1]]) ix = argsort(ppc['gen'][:, 0]) H = 2 * spdiags(ppc['gencost'][ix, 4], 0, ng, ng, 'csr') Cw = ppc['gencost'][ix, 5] ppc['gencost'][:, 4:7] = 0 ## run OPF with quadratic gen costs moved to generalized costs t = ''.join([t0, 'w/quadratic generalized gen cost : ']) r = opf(ppc, A, l, u, ppopt, N, fparm, H, Cw) f, bus, gen, branch, success = \ r['f'], r['bus'], r['gen'], r['branch'], r['success'] t_ok(success, [t, 'success']) t_is(f, f_soln, 3, [t, 'f']) t_is( bus[:, ib_data ], bus_soln[:, ib_data ], 10, [t, 'bus data']) t_is( bus[:, ib_voltage], bus_soln[:, ib_voltage], 3, [t, 'bus voltage']) t_is( bus[:, ib_lam ], bus_soln[:, ib_lam ], 3, [t, 'bus lambda']) t_is( bus[:, ib_mu ], bus_soln[:, ib_mu ], 2, [t, 'bus mu']) t_is( gen[:, ig_data ], gen_soln[:, ig_data ], 10, [t, 'gen data']) t_is( gen[:, ig_disp ], gen_soln[:, ig_disp ], 3, [t, 'gen dispatch']) t_is( gen[:, ig_mu ], gen_soln[:, ig_mu ], 3, [t, 'gen mu']) t_is(branch[:, ibr_data ], branch_soln[:, ibr_data ], 10, [t, 'branch data']) t_is(branch[:, ibr_flow ], branch_soln[:, ibr_flow ], 3, [t, 'branch flow']) t_is(branch[:, ibr_mu ], branch_soln[:, ibr_mu ], 2, [t, 'branch mu']) t_is(r['cost']['usr'], f, 12, [t, 'user cost']) ##----- run OPF with extra linear user constraints & costs ----- ## single new z variable constrained to be greater than or equal to ## deviation from 1 pu voltage at bus 1, linear cost on this z ## get solved AC power flow case from MAT-file soln9_opf_extras1 = loadmat(join(tdir, 'soln9_opf_extras1.mat'), struct_as_record=True) ## defines bus_soln, gen_soln, branch_soln, f_soln bus_soln = soln9_opf_extras1['bus_soln'] gen_soln = soln9_opf_extras1['gen_soln'] branch_soln = soln9_opf_extras1['branch_soln'] f_soln = soln9_opf_extras1['f_soln'][0] row = [0, 0, 1, 1] col = [9, 24, 9, 24] A = sparse(([-1, 1, 1, 1], (row, col)), (2, 25)) u = array([Inf, Inf]) l = array([-1, 1]) N = sparse(([1], ([0], [24])), (1, 25)) ## new z variable only fparm = array([[1, 0, 0, 1]]) ## w = r = z H = sparse((1, 1)) ## no quadratic term Cw = array([100.0]) t = ''.join([t0, 'w/extra constraints & costs 1 : ']) r = opf(casefile, A, l, u, ppopt, N, fparm, H, Cw) f, bus, gen, branch, success = \ r['f'], r['bus'], r['gen'], r['branch'], r['success'] t_ok(success, [t, 'success']) t_is(f, f_soln, 3, [t, 'f']) t_is( bus[:, ib_data ], bus_soln[:, ib_data ], 10, [t, 'bus data']) t_is( bus[:, ib_voltage], bus_soln[:, ib_voltage], 3, [t, 'bus voltage']) t_is( bus[:, ib_lam ], bus_soln[:, ib_lam ], 3, [t, 'bus lambda']) t_is( bus[:, ib_mu ], bus_soln[:, ib_mu ], 2, [t, 'bus mu']) t_is( gen[:, ig_data ], gen_soln[:, ig_data ], 10, [t, 'gen data']) t_is( gen[:, ig_disp ], gen_soln[:, ig_disp ], 3, [t, 'gen dispatch']) t_is( gen[:, ig_mu ], gen_soln[:, ig_mu ], 3, [t, 'gen mu']) t_is(branch[:, ibr_data ], branch_soln[:, ibr_data ], 10, [t, 'branch data']) t_is(branch[:, ibr_flow ], branch_soln[:, ibr_flow ], 3, [t, 'branch flow']) t_is(branch[:, ibr_mu ], branch_soln[:, ibr_mu ], 2, [t, 'branch mu']) t_is(r['var']['val']['z'], 0.025419, 6, [t, 'user variable']) t_is(r['cost']['usr'], 2.5419, 4, [t, 'user cost']) ##----- test OPF with capability curves ----- ppc = loadcase(join(tdir, 't_case9_opfv2')) ## remove angle diff limits ppc['branch'][0, ANGMAX] = 360 ppc['branch'][8, ANGMIN] = -360 ## get solved AC power flow case from MAT-file soln9_opf_PQcap = loadmat(join(tdir, 'soln9_opf_PQcap.mat'), struct_as_record=True) ## defines bus_soln, gen_soln, branch_soln, f_soln bus_soln = soln9_opf_PQcap['bus_soln'] gen_soln = soln9_opf_PQcap['gen_soln'] branch_soln = soln9_opf_PQcap['branch_soln'] f_soln = soln9_opf_PQcap['f_soln'][0] ## run OPF with capability curves t = ''.join([t0, 'w/capability curves : ']) r = runopf(ppc, ppopt) bus, gen, branch, f, success = \ r['bus'], r['gen'], r['branch'], r['f'], r['success'] t_ok(success, [t, 'success']) t_is(f, f_soln, 3, [t, 'f']) t_is( bus[:, ib_data ], bus_soln[:, ib_data ], 10, [t, 'bus data']) t_is( bus[:, ib_voltage], bus_soln[:, ib_voltage], 3, [t, 'bus voltage']) t_is( bus[:, ib_lam ], bus_soln[:, ib_lam ], 3, [t, 'bus lambda']) t_is( bus[:, ib_mu ], bus_soln[:, ib_mu ], 2, [t, 'bus mu']) t_is( gen[:, ig_data ], gen_soln[:, ig_data ], 10, [t, 'gen data']) t_is( gen[:, ig_disp ], gen_soln[:, ig_disp ], 3, [t, 'gen dispatch']) t_is( gen[:, ig_mu ], gen_soln[:, ig_mu ], 3, [t, 'gen mu']) t_is(branch[:, ibr_data ], branch_soln[:, ibr_data ], 10, [t, 'branch data']) t_is(branch[:, ibr_flow ], branch_soln[:, ibr_flow ], 3, [t, 'branch flow']) t_is(branch[:, ibr_mu ], branch_soln[:, ibr_mu ], 2, [t, 'branch mu']) ##----- test OPF with angle difference limits ----- ppc = loadcase(join(tdir, 't_case9_opfv2')) ## remove capability curves ppc['gen'][ix_(arange(1, 3), [PC1, PC2, QC1MIN, QC1MAX, QC2MIN, QC2MAX])] = zeros((2, 6)) ## get solved AC power flow case from MAT-file soln9_opf_ang = loadmat(join(tdir, 'soln9_opf_ang.mat'), struct_as_record=True) ## defines bus_soln, gen_soln, branch_soln, f_soln bus_soln = soln9_opf_ang['bus_soln'] gen_soln = soln9_opf_ang['gen_soln'] branch_soln = soln9_opf_ang['branch_soln'] f_soln = soln9_opf_ang['f_soln'][0] ## run OPF with angle difference limits t = ''.join([t0, 'w/angle difference limits : ']) r = runopf(ppc, ppopt) bus, gen, branch, f, success = \ r['bus'], r['gen'], r['branch'], r['f'], r['success'] t_ok(success, [t, 'success']) t_is(f, f_soln, 3, [t, 'f']) t_is( bus[:, ib_data ], bus_soln[:, ib_data ], 10, [t, 'bus data']) t_is( bus[:, ib_voltage], bus_soln[:, ib_voltage], 3, [t, 'bus voltage']) t_is( bus[:, ib_lam ], bus_soln[:, ib_lam ], 3, [t, 'bus lambda']) t_is( bus[:, ib_mu ], bus_soln[:, ib_mu ], 1, [t, 'bus mu']) t_is( gen[:, ig_data ], gen_soln[:, ig_data ], 10, [t, 'gen data']) t_is( gen[:, ig_disp ], gen_soln[:, ig_disp ], 3, [t, 'gen dispatch']) t_is( gen[:, ig_mu ], gen_soln[:, ig_mu ], 3, [t, 'gen mu']) t_is(branch[:, ibr_data ], branch_soln[:, ibr_data ], 10, [t, 'branch data']) t_is(branch[:, ibr_flow ], branch_soln[:, ibr_flow ], 3, [t, 'branch flow']) t_is(branch[:, ibr_mu ], branch_soln[:, ibr_mu ], 2, [t, 'branch mu']) t_is(branch[:, ibr_angmu ], branch_soln[:, ibr_angmu ], 2, [t, 'branch angle mu']) ##----- test OPF with ignored angle difference limits ----- ## get solved AC power flow case from MAT-file soln9_opf = loadmat(join(tdir, 'soln9_opf.mat'), struct_as_record=True) ## defines bus_soln, gen_soln, branch_soln, f_soln bus_soln = soln9_opf['bus_soln'] gen_soln = soln9_opf['gen_soln'] branch_soln = soln9_opf['branch_soln'] f_soln = soln9_opf['f_soln'][0] ## run OPF with ignored angle difference limits t = ''.join([t0, 'w/ignored angle difference limits : ']) ppopt1 = ppoption(ppopt, OPF_IGNORE_ANG_LIM=1) r = runopf(ppc, ppopt1) bus, gen, branch, f, success = \ r['bus'], r['gen'], r['branch'], r['f'], r['success'] ## ang limits are not in this solution data, so let's remove them branch[0, ANGMAX] = 360 branch[8, ANGMIN] = -360 t_ok(success, [t, 'success']) t_is(f, f_soln, 3, [t, 'f']) t_is( bus[:, ib_data ], bus_soln[:, ib_data ], 10, [t, 'bus data']) t_is( bus[:, ib_voltage], bus_soln[:, ib_voltage], 3, [t, 'bus voltage']) t_is( bus[:, ib_lam ], bus_soln[:, ib_lam ], 3, [t, 'bus lambda']) t_is( bus[:, ib_mu ], bus_soln[:, ib_mu ], 2, [t, 'bus mu']) t_is( gen[:, ig_data ], gen_soln[:, ig_data ], 10, [t, 'gen data']) t_is( gen[:, ig_disp ], gen_soln[:, ig_disp ], 3, [t, 'gen dispatch']) t_is( gen[:, ig_mu ], gen_soln[:, ig_mu ], 3, [t, 'gen mu']) t_is(branch[:, ibr_data ], branch_soln[:, ibr_data ], 10, [t, 'branch data']) t_is(branch[:, ibr_flow ], branch_soln[:, ibr_flow ], 3, [t, 'branch flow']) t_is(branch[:, ibr_mu ], branch_soln[:, ibr_mu ], 2, [t, 'branch mu']) t_end()
def t_scale_load(quiet=False): """Tests for code in C{scale_load}. @author: Ray Zimmerman (PSERC Cornell) """ n_tests = 275 t_begin(n_tests, quiet) ppc = loadcase(join(dirname(__file__), 't_auction_case')) ppc['gen'][7, GEN_BUS] = 2 ## multiple d. loads per area, same bus as gen ppc['gen'][7, [QG, QMIN, QMAX]] = array([3, 0, 3]) ## put it load before gen in matrix ppc['gen'] = vstack( [ppc['gen'][7, :], ppc['gen'][:7, :], ppc['gen'][8, :]]) ld = find(isload(ppc['gen'])) a = [None] * 3 lda = [None] * 3 for k in range(3): a[k] = find(ppc['bus'][:, BUS_AREA] == k + 1) ## buses in area k tmp = find(in1d(ppc['gen'][ld, GEN_BUS] - 1, a[k])) lda[k] = ld[tmp] ## disp loads in area k area = [None] * 3 for k in range(3): area[k] = {'fixed': {}, 'disp': {}, 'both': {}} area[k]['fixed']['p'] = sum(ppc['bus'][a[k], PD]) area[k]['fixed']['q'] = sum(ppc['bus'][a[k], QD]) area[k]['disp']['p'] = -sum(ppc['gen'][lda[k], PMIN]) area[k]['disp']['qmin'] = -sum(ppc['gen'][lda[k], QMIN]) area[k]['disp']['qmax'] = -sum(ppc['gen'][lda[k], QMAX]) area[k]['disp'][ 'q'] = area[k]['disp']['qmin'] + area[k]['disp']['qmax'] area[k]['both']['p'] = area[k]['fixed']['p'] + area[k]['disp']['p'] area[k]['both']['q'] = area[k]['fixed']['q'] + area[k]['disp']['q'] total = {'fixed': {}, 'disp': {}, 'both': {}} total['fixed']['p'] = sum(ppc['bus'][:, PD]) total['fixed']['q'] = sum(ppc['bus'][:, QD]) total['disp']['p'] = -sum(ppc['gen'][ld, PMIN]) total['disp']['qmin'] = -sum(ppc['gen'][ld, QMIN]) total['disp']['qmax'] = -sum(ppc['gen'][ld, QMAX]) total['disp']['q'] = total['disp']['qmin'] + total['disp']['qmax'] total['both']['p'] = total['fixed']['p'] + total['disp']['p'] total['both']['q'] = total['fixed']['q'] + total['disp']['q'] ##----- single load zone, one scale factor ----- load = array([2]) t = 'all fixed loads (PQ) * 2 : ' bus, _ = scale_load(load, ppc['bus']) t_is(sum(bus[:, PD]), load * total['fixed']['p'], 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), load * total['fixed']['q'], 8, [t, 'total fixed Q']) opt = {'which': 'FIXED'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) t_is(sum(bus[:, PD]), load * total['fixed']['p'], 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), load * total['fixed']['q'], 8, [t, 'total fixed Q']) t_is(-sum(gen[ld, PMIN]), total['disp']['p'], 8, [t, 'total disp P']) t_is(-sum(gen[ld, QMIN]), total['disp']['qmin'], 8, [t, 'total disp Qmin']) t_is(-sum(gen[ld, QMAX]), total['disp']['qmax'], 8, [t, 'total disp Qmax']) t = 'all fixed loads (P) * 2 : ' opt = {'pq': 'P'} bus, _ = scale_load(load, ppc['bus'], None, None, opt) t_is(sum(bus[:, PD]), load * total['fixed']['p'], 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), total['fixed']['q'], 8, [t, 'total fixed Q']) opt = {'pq': 'P', 'which': 'FIXED'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) t_is(sum(bus[:, PD]), load * total['fixed']['p'], 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), total['fixed']['q'], 8, [t, 'total fixed Q']) t_is(-sum(gen[ld, PMIN]), total['disp']['p'], 8, [t, 'total disp P']) t_is(-sum(gen[ld, QMIN]), total['disp']['qmin'], 8, [t, 'total disp Qmin']) t_is(-sum(gen[ld, QMAX]), total['disp']['qmax'], 8, [t, 'total disp Qmax']) t = 'all loads (PQ) * 2 : ' bus, gen = scale_load(load, ppc['bus'], ppc['gen']) t_is(sum(bus[:, PD]), load * total['fixed']['p'], 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), load * total['fixed']['q'], 8, [t, 'total fixed Q']) t_is(-sum(gen[ld, PMIN]), load * total['disp']['p'], 8, [t, 'total disp P']) t_is(-sum(gen[ld, QMIN]), load * total['disp']['qmin'], 8, [t, 'total disp Qmin']) t_is(-sum(gen[ld, QMAX]), load * total['disp']['qmax'], 8, [t, 'total disp Qmax']) t = 'all loads (P) * 2 : ' opt = {'pq': 'P'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) t_is(sum(bus[:, PD]), load * total['fixed']['p'], 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), total['fixed']['q'], 8, [t, 'total fixed Q']) t_is(-sum(gen[ld, PMIN]), load * total['disp']['p'], 8, [t, 'total disp P']) t_is(-sum(gen[ld, QMIN]), total['disp']['qmin'], 8, [t, 'total disp Qmin']) t_is(-sum(gen[ld, QMAX]), total['disp']['qmax'], 8, [t, 'total disp Qmax']) t = 'all disp loads (PQ) * 2 : ' opt = {'which': 'DISPATCHABLE'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) t_is(sum(bus[:, PD]), total['fixed']['p'], 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), total['fixed']['q'], 8, [t, 'total fixed Q']) t_is(-sum(gen[ld, PMIN]), load * total['disp']['p'], 8, [t, 'total disp P']) t_is(-sum(gen[ld, QMIN]), load * total['disp']['qmin'], 8, [t, 'total disp Qmin']) t_is(-sum(gen[ld, QMAX]), load * total['disp']['qmax'], 8, [t, 'total disp Qmax']) t = 'all disp loads (P) * 2 : ' opt = {'pq': 'P', 'which': 'DISPATCHABLE'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) t_is(sum(bus[:, PD]), total['fixed']['p'], 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), total['fixed']['q'], 8, [t, 'total fixed Q']) t_is(-sum(gen[ld, PMIN]), load * total['disp']['p'], 8, [t, 'total disp P']) t_is(-sum(gen[ld, QMIN]), total['disp']['qmin'], 8, [t, 'total disp Qmin']) t_is(-sum(gen[ld, QMAX]), total['disp']['qmax'], 8, [t, 'total disp Qmax']) ##----- single load zone, one scale quantity ----- load = array([200.0]) t = 'all fixed loads (PQ) => total = 200 : ' opt = {'scale': 'QUANTITY'} bus, _ = scale_load(load, ppc['bus'], None, None, opt) t_is(sum(bus[:, PD]), load, 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), load / total['fixed']['p'] * total['fixed']['q'], 8, [t, 'total fixed Q']) opt = {'scale': 'QUANTITY', 'which': 'FIXED'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) t_is(sum(bus[:, PD]), load - total['disp']['p'], 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), (load - total['disp']['p']) / total['fixed']['p'] * total['fixed']['q'], 8, [t, 'total fixed Q']) t_is(-sum(gen[ld, PMIN]), total['disp']['p'], 8, [t, 'total disp P']) t_is(-sum(gen[ld, QMIN]), total['disp']['qmin'], 8, [t, 'total disp Qmin']) t_is(-sum(gen[ld, QMAX]), total['disp']['qmax'], 8, [t, 'total disp Qmax']) t = 'all fixed loads (P) => total = 200 : ' opt = {'scale': 'QUANTITY', 'pq': 'P'} bus, _ = scale_load(load, ppc['bus'], None, None, opt) t_is(sum(bus[:, PD]), load, 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), total['fixed']['q'], 8, [t, 'total fixed Q']) opt = {'scale': 'QUANTITY', 'pq': 'P', 'which': 'FIXED'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) t_is(sum(bus[:, PD]), load - total['disp']['p'], 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), total['fixed']['q'], 8, [t, 'total fixed Q']) t_is(-sum(gen[ld, PMIN]), total['disp']['p'], 8, [t, 'total disp P']) t_is(-sum(gen[ld, QMIN]), total['disp']['qmin'], 8, [t, 'total disp Qmin']) t_is(-sum(gen[ld, QMAX]), total['disp']['qmax'], 8, [t, 'total disp Qmax']) t = 'all loads (PQ) => total = 200 : ' opt = {'scale': 'QUANTITY'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) t_is(sum(bus[:, PD]), load / total['both']['p'] * total['fixed']['p'], 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), load / total['both']['p'] * total['fixed']['q'], 8, [t, 'total fixed Q']) t_is(-sum(gen[ld, PMIN]), load / total['both']['p'] * total['disp']['p'], 8, [t, 'total disp P']) t_is(-sum(gen[ld, QMIN]), load / total['both']['p'] * total['disp']['qmin'], 8, [t, 'total disp Qmin']) t_is(-sum(gen[ld, QMAX]), load / total['both']['p'] * total['disp']['qmax'], 8, [t, 'total disp Qmax']) t = 'all loads (P) => total = 200 : ' opt = {'scale': 'QUANTITY', 'pq': 'P'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) t_is(sum(bus[:, PD]), load / total['both']['p'] * total['fixed']['p'], 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), total['fixed']['q'], 8, [t, 'total fixed Q']) t_is(-sum(gen[ld, PMIN]), load / total['both']['p'] * total['disp']['p'], 8, [t, 'total disp P']) t_is(-sum(gen[ld, QMIN]), total['disp']['qmin'], 8, [t, 'total disp Qmin']) t_is(-sum(gen[ld, QMAX]), total['disp']['qmax'], 8, [t, 'total disp Qmax']) t = 'all disp loads (PQ) => total = 200 : ' opt = {'scale': 'QUANTITY', 'which': 'DISPATCHABLE'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) t_is(sum(bus[:, PD]), total['fixed']['p'], 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), total['fixed']['q'], 8, [t, 'total fixed Q']) t_is(-sum(gen[ld, PMIN]), load - total['fixed']['p'], 8, [t, 'total disp P']) t_is(-sum(gen[ld, QMIN]), (load - total['fixed']['p']) / total['disp']['p'] * total['disp']['qmin'], 8, [t, 'total disp Qmin']) t_is(-sum(gen[ld, QMAX]), (load - total['fixed']['p']) / total['disp']['p'] * total['disp']['qmax'], 8, [t, 'total disp Qmax']) t = 'all disp loads (P) => total = 200 : ' opt = {'scale': 'QUANTITY', 'pq': 'P', 'which': 'DISPATCHABLE'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) t_is(sum(bus[:, PD]), total['fixed']['p'], 8, [t, 'total fixed P']) t_is(sum(bus[:, QD]), total['fixed']['q'], 8, [t, 'total fixed Q']) t_is(-sum(gen[ld, PMIN]), load - total['fixed']['p'], 8, [t, 'total disp P']) t_is(-sum(gen[ld, QMIN]), total['disp']['qmin'], 8, [t, 'total disp Qmin']) t_is(-sum(gen[ld, QMAX]), total['disp']['qmax'], 8, [t, 'total disp Qmax']) ##----- 3 zones, area scale factors ----- t = 'area fixed loads (PQ) * [3 2 1] : ' load = array([3, 2, 1]) bus, _ = scale_load(load, ppc['bus']) for k in range(len(load)): t_is(sum(bus[a[k], PD]), load[k] * area[k]['fixed']['p'], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), load[k] * area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) opt = {'which': 'FIXED'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) for k in range(len(load)): t_is(sum(bus[a[k], PD]), load[k] * area[k]['fixed']['p'], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), load[k] * area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) t_is(-sum(gen[lda[k], PMIN]), area[k]['disp']['p'], 8, '%s area %d disp P' % (t, k)) t_is(-sum(gen[lda[k], QMIN]), area[k]['disp']['qmin'], 8, '%s area %d disp Qmin' % (t, k)) t_is(-sum(gen[lda[k], QMAX]), area[k]['disp']['qmax'], 8, '%s area %d disp Qmax' % (t, k)) t = 'area fixed loads (P) * [3 2 1] : ' load = array([3, 2, 1]) opt = {'pq': 'P'} bus, _ = scale_load(load, ppc['bus'], None, None, opt) for k in range(len(load)): t_is(sum(bus[a[k], PD]), load[k] * area[k]['fixed']['p'], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) opt = {'pq': 'P', 'which': 'FIXED'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) for k in range(len(load)): t_is(sum(bus[a[k], PD]), load[k] * area[k]['fixed']['p'], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) t_is(-sum(gen[lda[k], PMIN]), area[k]['disp']['p'], 8, '%s area %d disp P' % (t, k)) t_is(-sum(gen[lda[k], QMIN]), area[k]['disp']['qmin'], 8, '%s area %d disp Qmin' % (t, k)) t_is(-sum(gen[lda[k], QMAX]), area[k]['disp']['qmax'], 8, '%s area %d disp Qmax' % (t, k)) t = 'all area loads (PQ) * [3 2 1] : ' bus, gen = scale_load(load, ppc['bus'], ppc['gen']) for k in range(len(load)): t_is(sum(bus[a[k], PD]), load[k] * area[k]['fixed']['p'], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), load[k] * area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) t_is(-sum(gen[lda[k], PMIN]), load[k] * area[k]['disp']['p'], 8, '%s area %d disp P' % (t, k)) t_is(-sum(gen[lda[k], QMIN]), load[k] * area[k]['disp']['qmin'], 8, '%s area %d disp Qmin' % (t, k)) t_is(-sum(gen[lda[k], QMAX]), load[k] * area[k]['disp']['qmax'], 8, '%s area %d disp Qmax' % (t, k)) t = 'all area loads (P) * [3 2 1] : ' opt = {'pq': 'P'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) for k in range(len(load)): t_is(sum(bus[a[k], PD]), load[k] * area[k]['fixed']['p'], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) t_is(-sum(gen[lda[k], PMIN]), load[k] * area[k]['disp']['p'], 8, '%s area %d disp P' % (t, k)) t_is(-sum(gen[lda[k], QMIN]), area[k]['disp']['qmin'], 8, '%s area %d disp Qmin' % (t, k)) t_is(-sum(gen[lda[k], QMAX]), area[k]['disp']['qmax'], 8, '%s area %d disp Qmax' % (t, k)) t = 'area disp loads (PQ) * [3 2 1] : ' opt = {'which': 'DISPATCHABLE'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) for k in range(len(load)): t_is(sum(bus[a[k], PD]), area[k]['fixed']['p'], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) t_is(-sum(gen[lda[k], PMIN]), load[k] * area[k]['disp']['p'], 8, '%s area %d disp P' % (t, k)) t_is(-sum(gen[lda[k], QMIN]), load[k] * area[k]['disp']['qmin'], 8, '%s area %d disp Qmin' % (t, k)) t_is(-sum(gen[lda[k], QMAX]), load[k] * area[k]['disp']['qmax'], 8, '%s area %d disp Qmax' % (t, k)) t = 'area disp loads (P) * [3 2 1] : ' opt = {'pq': 'P', 'which': 'DISPATCHABLE'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) for k in range(len(load)): t_is(sum(bus[a[k], PD]), area[k]['fixed']['p'], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) t_is(-sum(gen[lda[k], PMIN]), load[k] * area[k]['disp']['p'], 8, '%s area %d disp P' % (t, k)) t_is(-sum(gen[lda[k], QMIN]), area[k]['disp']['qmin'], 8, '%s area %d disp Qmin' % (t, k)) t_is(-sum(gen[lda[k], QMAX]), area[k]['disp']['qmax'], 8, '%s area %d disp Qmax' % (t, k)) ##----- 3 zones, area scale quantities ----- t = 'area fixed loads (PQ) => total = [100 80 60] : ' load = array([100, 80, 60], float) opt = {'scale': 'QUANTITY'} bus, _ = scale_load(load, ppc['bus'], None, None, opt) for k in range(len(load)): t_is(sum(bus[a[k], PD]), load[k], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), load[k] / area[k]['fixed']['p'] * area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) opt = {'scale': 'QUANTITY', 'which': 'FIXED'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) for k in range(len(load)): t_is(sum(bus[a[k], PD]), load[k] - area[k]['disp']['p'], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), (load[k] - area[k]['disp']['p']) / area[k]['fixed']['p'] * area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) t_is(-sum(gen[lda[k], PMIN]), area[k]['disp']['p'], 8, '%s area %d disp P' % (t, k)) t_is(-sum(gen[lda[k], QMIN]), area[k]['disp']['qmin'], 8, '%s area %d disp Qmin' % (t, k)) t_is(-sum(gen[lda[k], QMAX]), area[k]['disp']['qmax'], 8, '%s area %d disp Qmax' % (t, k)) t = 'area fixed loads (P) => total = [100 80 60] : ' load = array([100, 80, 60], float) opt = {'scale': 'QUANTITY', 'pq': 'P'} bus, _ = scale_load(load, ppc['bus'], None, None, opt) for k in range(len(load)): t_is(sum(bus[a[k], PD]), load[k], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) opt = {'scale': 'QUANTITY', 'pq': 'P', 'which': 'FIXED'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) for k in range(len(load)): t_is(sum(bus[a[k], PD]), load[k] - area[k]['disp']['p'], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) t_is(-sum(gen[lda[k], PMIN]), area[k]['disp']['p'], 8, '%s area %d disp P' % (t, k)) t_is(-sum(gen[lda[k], QMIN]), area[k]['disp']['qmin'], 8, '%s area %d disp Qmin' % (t, k)) t_is(-sum(gen[lda[k], QMAX]), area[k]['disp']['qmax'], 8, '%s area %d disp Qmax' % (t, k)) t = 'all area loads (PQ) => total = [100 80 60] : ' opt = {'scale': 'QUANTITY'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) for k in range(len(load)): t_is(sum(bus[a[k], PD]), load[k] / area[k]['both']['p'] * area[k]['fixed']['p'], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), load[k] / area[k]['both']['p'] * area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) t_is(-sum(gen[lda[k], PMIN]), load[k] / area[k]['both']['p'] * area[k]['disp']['p'], 8, '%s area %d disp P' % (t, k)) t_is(-sum(gen[lda[k], QMIN]), load[k] / area[k]['both']['p'] * area[k]['disp']['qmin'], 8, '%s area %d disp Qmin' % (t, k)) t_is(-sum(gen[lda[k], QMAX]), load[k] / area[k]['both']['p'] * area[k]['disp']['qmax'], 8, '%s area %d disp Qmax' % (t, k)) t = 'all area loads (P) => total = [100 80 60] : ' opt = {'scale': 'QUANTITY', 'pq': 'P'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) for k in range(len(load)): t_is(sum(bus[a[k], PD]), load[k] / area[k]['both']['p'] * area[k]['fixed']['p'], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) t_is(-sum(gen[lda[k], PMIN]), load[k] / area[k]['both']['p'] * area[k]['disp']['p'], 8, '%s area %d disp P' % (t, k)) t_is(-sum(gen[lda[k], QMIN]), area[k]['disp']['qmin'], 8, '%s area %d disp Qmin' % (t, k)) t_is(-sum(gen[lda[k], QMAX]), area[k]['disp']['qmax'], 8, '%s area %d disp Qmax' % (t, k)) t = 'area disp loads (PQ) => total = [100 80 60] : throws expected exception' load = array([100, 80, 60], float) opt = {'scale': 'QUANTITY', 'which': 'DISPATCHABLE'} err = 0 try: bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) except ScalingError as e: expected = 'scale_load: impossible to make zone 2 load equal 80 by scaling non-existent dispatchable load' err = expected not in str(e) t_ok(err, t) t = 'area disp loads (PQ) => total = [100 74.3941 60] : ' load = array([100, area[1]['fixed']['p'], 60], float) opt = {'scale': 'QUANTITY', 'which': 'DISPATCHABLE'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) for k in range(len(load)): t_is(sum(bus[a[k], PD]), area[k]['fixed']['p'], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) t_is(-sum(gen[lda[k], PMIN]), load[k] - area[k]['fixed']['p'], 8, '%s area %d disp P' % (t, k)) if k == 1: t_is(-sum(gen[lda[k], QMIN]), area[k]['disp']['qmin'], 8, '%s area %d disp Qmin' % (t, k)) t_is(-sum(gen[lda[k], QMAX]), area[k]['disp']['qmax'], 8, '%s area %d disp Qmax' % (t, k)) else: t_is(-sum(gen[lda[k], QMIN]), (load[k] - area[k]['fixed']['p']) / area[k]['disp']['p'] * area[k]['disp']['qmin'], 8, '%s area %d disp Qmin' % (t, k)) t_is(-sum(gen[lda[k], QMAX]), (load[k] - area[k]['fixed']['p']) / area[k]['disp']['p'] * area[k]['disp']['qmax'], 8, '%s area %d disp Qmax' % (t, k)) t = 'area disp loads (P) => total = [100 74.3941 60] : ' opt = {'scale': 'QUANTITY', 'pq': 'P', 'which': 'DISPATCHABLE'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) for k in range(len(load)): t_is(sum(bus[a[k], PD]), area[k]['fixed']['p'], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) t_is(-sum(gen[lda[k], PMIN]), load[k] - area[k]['fixed']['p'], 8, '%s area %d disp P' % (t, k)) t_is(-sum(gen[lda[k], QMIN]), area[k]['disp']['qmin'], 8, '%s area %d disp Qmin' % (t, k)) t_is(-sum(gen[lda[k], QMAX]), area[k]['disp']['qmax'], 8, '%s area %d disp Qmax' % (t, k)) ##----- explict single load zone ----- t = 'explicit single load zone' load_zone = zeros(ppc['bus'].shape[0]) load_zone[[2, 3]] = 1 load = array([2.0]) bus, gen = scale_load(load, ppc['bus'], ppc['gen'], load_zone) Pd = ppc['bus'][:, PD] Pd[[2, 3]] = load * Pd[[2, 3]] t_is(bus[:, PD], Pd, 8, t) ##----- explict multiple load zone ----- t = 'explicit multiple load zone' load_zone = zeros(ppc['bus'].shape[0]) load_zone[[2, 3]] = 1 load_zone[[6, 7]] = 2 load = array([2, 0.5]) bus, gen = scale_load(load, ppc['bus'], ppc['gen'], load_zone) Pd = ppc['bus'][:, PD] Pd[[2, 3]] = load[0] * Pd[[2, 3]] Pd[[6, 7]] = load[1] * Pd[[6, 7]] t_is(bus[:, PD], Pd, 8, t) t_end()
def t_savecase(quiet=False): """Tests that C{savecase} saves case files in MAT and PY file formats.""" t_begin(12, quiet) MATCASE = 'test_savedcase.mat' PYCASE = 'test_savedcase.py' file_formats = [MATCASE, PYCASE] pf_case = {'case': case24_ieee_rts(), 'run_func': runpf, 'run_label': 'PF run'} opf_case = {'case': case24_ieee_rts(), 'run_func': runopf, 'run_label': 'OPF run'} case_unsolved = {'case': case24_ieee_rts(), 'run_func': None, 'run_label': 'pre-run'} cases = [pf_case, opf_case, case_unsolved] tmpdir = tempfile.mkdtemp() for case in cases: for i, filename in enumerate([f for f in file_formats]): file_format = save_format(filename) # 'mat' or 'py' saved_umask = os.umask(0o22) path = join(tmpdir, filename) ppc = case['case'] pf_func = case['run_func'] run_type = case['run_label'] # Test saving of results if case has been solved if pf_func: ppopt = ppoption(VERBOSE=0, OUT_ALL=0) # Run power flow type specified, assign solution to case ppc = pf_func(ppc, ppopt) # runpf.py returns a tuple containing the result if isinstance(ppc, tuple): ppc = ppc[0] try: savedcase = savecase(path, ppc, comment=None, version='2') except IOError: t_ok(False, ['Savecase: ', 'IOError.']) else: # Do tests msg_prefix = message_prefix(file_format, run_type) loaded_case = loadcase(savedcase) msg_desc = ' file name matches argument' t_ok(savedcase == path, msg_prefix + msg_desc) msg_desc = ' file content matches case' # Boolean: saved key-value pairs do/do not correspond to case saved_case_matches_ppc = verify_saved_case(loaded_case, ppc) t_ok(saved_case_matches_ppc, msg_prefix + msg_desc) os.remove(path) finally: os.umask(saved_umask) os.rmdir(tmpdir)
def t_opf_dc_pips(quiet=False): """Tests for DC optimal power flow using PIPS solver. @author: Ray Zimmerman (PSERC Cornell) @author: Richard Lincoln """ num_tests = 23 t_begin(num_tests, quiet) tdir = dirname(__file__) casefile = join(tdir, 't_case9_opf') verbose = 0#not quiet t0 = 'DC OPF (PIPS): ' ppopt = ppoption(VERBOSE=verbose, OUT_ALL=0, OPF_ALG_DC=200) ## run DC OPF ## set up indices ib_data = r_[arange(BUS_AREA + 1), arange(BASE_KV, VMIN + 1)] ib_voltage = arange(VM, VA + 1) ib_lam = arange(LAM_P, LAM_Q + 1) ib_mu = arange(MU_VMAX, MU_VMIN + 1) ig_data = r_[[GEN_BUS, QMAX, QMIN], arange(MBASE, APF + 1)] ig_disp = array([PG, QG, VG]) ig_mu = arange(MU_PMAX, MU_QMIN + 1) ibr_data = arange(ANGMAX + 1) ibr_flow = arange(PF, QT + 1) ibr_mu = array([MU_SF, MU_ST]) #ibr_angmu = array([MU_ANGMIN, MU_ANGMAX]) ## get solved DC power flow case from MAT-file soln9_dcopf = loadmat(join(tdir, 'soln9_dcopf.mat'), struct_as_record=True) ## defines bus_soln, gen_soln, branch_soln, f_soln bus_soln = soln9_dcopf['bus_soln'] gen_soln = soln9_dcopf['gen_soln'] branch_soln = soln9_dcopf['branch_soln'] f_soln = soln9_dcopf['f_soln'][0] ## run OPF t = t0 r = rundcopf(casefile, ppopt) bus, gen, branch, f, success = \ r['bus'], r['gen'], r['branch'], r['f'], r['success'] t_ok(success, [t, 'success']) t_is(f, f_soln, 3, [t, 'f']) t_is( bus[:, ib_data ], bus_soln[:, ib_data ], 10, [t, 'bus data']) t_is( bus[:, ib_voltage], bus_soln[:, ib_voltage], 3, [t, 'bus voltage']) t_is( bus[:, ib_lam ], bus_soln[:, ib_lam ], 3, [t, 'bus lambda']) t_is( bus[:, ib_mu ], bus_soln[:, ib_mu ], 2, [t, 'bus mu']) t_is( gen[:, ig_data ], gen_soln[:, ig_data ], 10, [t, 'gen data']) t_is( gen[:, ig_disp ], gen_soln[:, ig_disp ], 3, [t, 'gen dispatch']) t_is( gen[:, ig_mu ], gen_soln[:, ig_mu ], 3, [t, 'gen mu']) t_is(branch[:, ibr_data ], branch_soln[:, ibr_data ], 10, [t, 'branch data']) t_is(branch[:, ibr_flow ], branch_soln[:, ibr_flow ], 3, [t, 'branch flow']) t_is(branch[:, ibr_mu ], branch_soln[:, ibr_mu ], 2, [t, 'branch mu']) ##----- run OPF with extra linear user constraints & costs ----- ## two new z variables ## 0 <= z1, P2 - P1 <= z1 ## 0 <= z2, P2 - P3 <= z2 ## with A and N sized for DC opf ppc = loadcase(casefile) row = [0, 0, 0, 1, 1, 1] col = [9, 10, 12, 10, 11, 13] ppc['A'] = sparse(([-1, 1, -1, 1, -1, -1], (row, col)), (2, 14)) ppc['u'] = array([0, 0]) ppc['l'] = array([-Inf, -Inf]) ppc['zl'] = array([0, 0]) ppc['N'] = sparse(([1, 1], ([0, 1], [12, 13])), (2, 14)) ## new z variables only ppc['fparm'] = ones((2, 1)) * array([[1, 0, 0, 1]]) ## w = r = z ppc['H'] = sparse((2, 2)) ## no quadratic term ppc['Cw'] = array([1000, 1]) t = ''.join([t0, 'w/extra constraints & costs 1 : ']) r = rundcopf(ppc, ppopt) t_ok(r['success'], [t, 'success']) t_is(r['gen'][0, PG], 116.15974, 4, [t, 'Pg1 = 116.15974']) t_is(r['gen'][1, PG], 116.15974, 4, [t, 'Pg2 = 116.15974']) t_is(r['var']['val']['z'], [0, 0.3348], 4, [t, 'user vars']) t_is(r['cost']['usr'], 0.3348, 3, [t, 'user costs']) ## with A and N sized for AC opf ppc = loadcase(casefile) row = [0, 0, 0, 1, 1, 1] col = [18, 19, 24, 19, 20, 25] ppc['A'] = sparse(([-1, 1, -1, 1, -1, -1], (row, col)), (2, 26)) ppc['u'] = array([0, 0]) ppc['l'] = array([-Inf, -Inf]) ppc['zl'] = array([0, 0]) ppc['N'] = sparse(([1, 1], ([0, 1], [24, 25])), (2, 26)) ## new z variables only ppc['fparm'] = ones((2, 1)) * array([[1, 0, 0, 1]]) ## w = r = z ppc['H'] = sparse((2, 2)) ## no quadratic term ppc['Cw'] = array([1000, 1]) t = ''.join([t0, 'w/extra constraints & costs 2 : ']) r = rundcopf(ppc, ppopt) t_ok(r['success'], [t, 'success']) t_is(r['gen'][0, PG], 116.15974, 4, [t, 'Pg1 = 116.15974']) t_is(r['gen'][1, PG], 116.15974, 4, [t, 'Pg2 = 116.15974']) t_is(r['var']['val']['z'], [0, 0.3348], 4, [t, 'user vars']) t_is(r['cost']['usr'], 0.3348, 3, [t, 'user costs']) t = ''.join([t0, 'infeasible : ']) ## with A and N sized for DC opf ppc = loadcase(casefile) ppc['A'] = sparse(([1, 1], ([0, 0], [9, 10])), (1, 14)) ## Pg1 + Pg2 ppc['u'] = array([Inf]) ppc['l'] = array([600]) r = rundcopf(ppc, ppopt) t_ok(not r['success'], [t, 'no success']) t_end()
def t_is(got, expected, prec=5, msg=''): """Tests if two matrices are identical to some tolerance. Increments the global test count and if the maximum difference between corresponding elements of C{got} and C{expected} is less than 10**(-C{prec}) then it increments the passed tests count, otherwise increments the failed tests count. Prints 'ok' or 'not ok' followed by the MSG, unless the global variable t_quiet is true. Intended to be called between calls to C{t_begin} and C{t_end}. @author: Ray Zimmerman (PSERC Cornell) """ if isinstance(got, int) or isinstance(got, float): got = array([got], float) elif isinstance(got, list) or isinstance(got, tuple): got = array(got, float) if isinstance(expected, int) or isinstance(expected, float): expected = array([expected], float) elif isinstance(expected, list) or isinstance(expected, tuple): expected = array(expected, float) if (got.shape == expected.shape) or (expected.shape == (0, )): got_minus_expected = got - expected max_diff = max(max(abs(got_minus_expected))) condition = (max_diff < 10**(-prec)) else: condition = False max_diff = 0 t_ok(condition, msg) if (not condition and not TestGlobals.t_quiet): s = '' if max_diff != 0: idx = nonzero(not abs(got_minus_expected) < 10**(-prec)) if len(idx) == 1: # 1D array idx = (idx[0], zeros(len(got_minus_expected))) i, j = idx k = i + (j - 1) * expected.shape[0] got = got.flatten() expected = expected.flatten() got_minus_expected = got_minus_expected.flatten() kk = argmax(abs(got_minus_expected[k.astype(int)])) s += ' row col got expected got - exp\n' s += '------- ------ ---------------- ---------------- ----------------' for u in range(len(i)): s += '\n%6d %6d %16g %16g %16g' % \ (i[u], j[u], got[k[u]], expected[k[u]], got_minus_expected[k[u]]) if u == kk: s += ' *' s += '\nmax diff @ (%d,%d) = %g > allowed tol of %g\n\n' % \ (i[kk], j[kk], max_diff, 10**(-prec)) else: s += ' dimension mismatch:\n' if len(got.shape) == 1: # 1D array s += ' got: %d\n' % got.shape else: s += ' got: %d x %d\n' % got.shape if len(expected.shape) == 1: # 1D array s += ' expected: %d\n' % expected.shape else: s += ' expected: %d x %d\n' % expected.shape print(s)
def t_opf_ipopt(quiet=False): """Tests for IPOPT-based AC optimal power flow. @author: Ray Zimmerman (PSERC Cornell) @author: Richard Lincoln """ num_tests = 101 t_begin(num_tests, quiet) tdir = dirname(__file__) casefile = join(tdir, 't_case9_opf') verbose = 0#not quiet t0 = 'IPOPT : ' ppopt = ppoption(OPF_VIOLATION=1e-6, PDIPM_GRADTOL=1e-8, PDIPM_COMPTOL=1e-8, PDIPM_COSTTOL=1e-9) ppopt = ppoption(ppopt, OUT_ALL=0, VERBOSE=verbose, OPF_ALG=580) ## set up indices ib_data = r_[arange(BUS_AREA + 1), arange(BASE_KV, VMIN + 1)] ib_voltage = arange(VM, VA + 1) ib_lam = arange(LAM_P, LAM_Q + 1) ib_mu = arange(MU_VMAX, MU_VMIN + 1) ig_data = r_[[GEN_BUS, QMAX, QMIN], arange(MBASE, APF + 1)] ig_disp = array([PG, QG, VG]) ig_mu = arange(MU_PMAX, MU_QMIN + 1) ibr_data = arange(ANGMAX + 1) ibr_flow = arange(PF, QT + 1) ibr_mu = array([MU_SF, MU_ST]) ibr_angmu = array([MU_ANGMIN, MU_ANGMAX]) ## get solved AC power flow case from MAT-file soln9_opf = loadmat(join(tdir, 'soln9_opf.mat'), struct_as_record=True) ## defines bus_soln, gen_soln, branch_soln, f_soln bus_soln = soln9_opf['bus_soln'] gen_soln = soln9_opf['gen_soln'] branch_soln = soln9_opf['branch_soln'] f_soln = soln9_opf['f_soln'][0] ## run OPF t = t0 r = runopf(casefile, ppopt) bus, gen, branch, f, success = \ r['bus'], r['gen'], r['branch'], r['f'], r['success'] t_ok(success, [t, 'success']) t_is(f, f_soln, 3, [t, 'f']) t_is( bus[:, ib_data ], bus_soln[:, ib_data ], 10, [t, 'bus data']) t_is( bus[:, ib_voltage], bus_soln[:, ib_voltage], 3, [t, 'bus voltage']) t_is( bus[:, ib_lam ], bus_soln[:, ib_lam ], 3, [t, 'bus lambda']) t_is( bus[:, ib_mu ], bus_soln[:, ib_mu ], 2, [t, 'bus mu']) t_is( gen[:, ig_data ], gen_soln[:, ig_data ], 10, [t, 'gen data']) t_is( gen[:, ig_disp ], gen_soln[:, ig_disp ], 3, [t, 'gen dispatch']) t_is( gen[:, ig_mu ], gen_soln[:, ig_mu ], 3, [t, 'gen mu']) t_is(branch[:, ibr_data ], branch_soln[:, ibr_data ], 10, [t, 'branch data']) t_is(branch[:, ibr_flow ], branch_soln[:, ibr_flow ], 3, [t, 'branch flow']) t_is(branch[:, ibr_mu ], branch_soln[:, ibr_mu ], 2, [t, 'branch mu']) ## run with automatic conversion of single-block pwl to linear costs t = ''.join([t0, '(single-block PWL) : ']) ppc = loadcase(casefile) ppc['gencost'][2, NCOST] = 2 r = runopf(ppc, ppopt) bus, gen, branch, f, success = \ r['bus'], r['gen'], r['branch'], r['f'], r['success'] t_ok(success, [t, 'success']) t_is(f, f_soln, 3, [t, 'f']) t_is( bus[:, ib_data ], bus_soln[:, ib_data ], 10, [t, 'bus data']) t_is( bus[:, ib_voltage], bus_soln[:, ib_voltage], 3, [t, 'bus voltage']) t_is( bus[:, ib_lam ], bus_soln[:, ib_lam ], 3, [t, 'bus lambda']) t_is( bus[:, ib_mu ], bus_soln[:, ib_mu ], 2, [t, 'bus mu']) t_is( gen[:, ig_data ], gen_soln[:, ig_data ], 10, [t, 'gen data']) t_is( gen[:, ig_disp ], gen_soln[:, ig_disp ], 3, [t, 'gen dispatch']) t_is( gen[:, ig_mu ], gen_soln[:, ig_mu ], 3, [t, 'gen mu']) t_is(branch[:, ibr_data ], branch_soln[:, ibr_data ], 10, [t, 'branch data']) t_is(branch[:, ibr_flow ], branch_soln[:, ibr_flow ], 3, [t, 'branch flow']) t_is(branch[:, ibr_mu ], branch_soln[:, ibr_mu ], 2, [t, 'branch mu']) xr = r_[r['var']['val']['Va'], r['var']['val']['Vm'], r['var']['val']['Pg'], r['var']['val']['Qg'], 0, r['var']['val']['y']] t_is(r['x'], xr, 8, [t, 'check on raw x returned from OPF']) ## get solved AC power flow case from MAT-file soln9_opf_Plim = loadmat(join(tdir, 'soln9_opf_Plim.mat'), struct_as_record=True) ## defines bus_soln, gen_soln, branch_soln, f_soln bus_soln = soln9_opf_Plim['bus_soln'] gen_soln = soln9_opf_Plim['gen_soln'] branch_soln = soln9_opf_Plim['branch_soln'] f_soln = soln9_opf_Plim['f_soln'][0] ## run OPF with active power line limits t = ''.join([t0, '(P line lim) : ']) ppopt1 = ppoption(ppopt, OPF_FLOW_LIM=1) r = runopf(casefile, ppopt1) bus, gen, branch, f, success = \ r['bus'], r['gen'], r['branch'], r['f'], r['success'] t_ok(success, [t, 'success']) t_is(f, f_soln, 3, [t, 'f']) t_is( bus[:, ib_data ], bus_soln[:, ib_data ], 10, [t, 'bus data']) t_is( bus[:, ib_voltage], bus_soln[:, ib_voltage], 3, [t, 'bus voltage']) t_is( bus[:, ib_lam ], bus_soln[:, ib_lam ], 3, [t, 'bus lambda']) t_is( bus[:, ib_mu ], bus_soln[:, ib_mu ], 2, [t, 'bus mu']) t_is( gen[:, ig_data ], gen_soln[:, ig_data ], 10, [t, 'gen data']) t_is( gen[:, ig_disp ], gen_soln[:, ig_disp ], 3, [t, 'gen dispatch']) t_is( gen[:, ig_mu ], gen_soln[:, ig_mu ], 3, [t, 'gen mu']) t_is(branch[:, ibr_data ], branch_soln[:, ibr_data ], 10, [t, 'branch data']) t_is(branch[:, ibr_flow ], branch_soln[:, ibr_flow ], 3, [t, 'branch flow']) t_is(branch[:, ibr_mu ], branch_soln[:, ibr_mu ], 2, [t, 'branch mu']) ##----- test OPF with quadratic gen costs moved to generalized costs ----- ppc = loadcase(casefile) ppc['gencost'] = array([ [2, 1500, 0, 3, 0.11, 5, 0], [2, 2000, 0, 3, 0.085, 1.2, 0], [2, 3000, 0, 3, 0.1225, 1, 0] ]) r = runopf(ppc, ppopt) bus_soln, gen_soln, branch_soln, f_soln, success = \ r['bus'], r['gen'], r['branch'], r['f'], r['success'] branch_soln = branch_soln[:, :MU_ST + 1] A = None l = array([]) u = array([]) nb = ppc['bus'].shape[0] # number of buses ng = ppc['gen'].shape[0] # number of gens thbas = 0; thend = thbas + nb vbas = thend; vend = vbas + nb pgbas = vend; pgend = pgbas + ng # qgbas = pgend; qgend = qgbas + ng nxyz = 2 * nb + 2 * ng N = sparse((ppc['baseMVA'] * ones(ng), (arange(ng), arange(pgbas, pgend))), (ng, nxyz)) fparm = ones((ng, 1)) * array([[1, 0, 0, 1]]) ix = argsort(ppc['gen'][:, 0]) H = 2 * spdiags(ppc['gencost'][ix, 4], 0, ng, ng, 'csr') Cw = ppc['gencost'][ix, 5] ppc['gencost'][:, 4:7] = 0 ## run OPF with quadratic gen costs moved to generalized costs t = ''.join([t0, 'w/quadratic generalized gen cost : ']) r = opf(ppc, A, l, u, ppopt, N, fparm, H, Cw) f, bus, gen, branch, success = \ r['f'], r['bus'], r['gen'], r['branch'], r['success'] t_ok(success, [t, 'success']) t_is(f, f_soln, 3, [t, 'f']) t_is( bus[:, ib_data ], bus_soln[:, ib_data ], 10, [t, 'bus data']) t_is( bus[:, ib_voltage], bus_soln[:, ib_voltage], 3, [t, 'bus voltage']) t_is( bus[:, ib_lam ], bus_soln[:, ib_lam ], 3, [t, 'bus lambda']) t_is( bus[:, ib_mu ], bus_soln[:, ib_mu ], 2, [t, 'bus mu']) t_is( gen[:, ig_data ], gen_soln[:, ig_data ], 10, [t, 'gen data']) t_is( gen[:, ig_disp ], gen_soln[:, ig_disp ], 3, [t, 'gen dispatch']) t_is( gen[:, ig_mu ], gen_soln[:, ig_mu ], 3, [t, 'gen mu']) t_is(branch[:, ibr_data ], branch_soln[:, ibr_data ], 10, [t, 'branch data']) t_is(branch[:, ibr_flow ], branch_soln[:, ibr_flow ], 3, [t, 'branch flow']) t_is(branch[:, ibr_mu ], branch_soln[:, ibr_mu ], 2, [t, 'branch mu']) t_is(r['cost']['usr'], f, 12, [t, 'user cost']) ##----- run OPF with extra linear user constraints & costs ----- ## single new z variable constrained to be greater than or equal to ## deviation from 1 pu voltage at bus 1, linear cost on this z ## get solved AC power flow case from MAT-file soln9_opf_extras1 = loadmat(join(tdir, 'soln9_opf_extras1.mat'), struct_as_record=True) ## defines bus_soln, gen_soln, branch_soln, f_soln bus_soln = soln9_opf_extras1['bus_soln'] gen_soln = soln9_opf_extras1['gen_soln'] branch_soln = soln9_opf_extras1['branch_soln'] f_soln = soln9_opf_extras1['f_soln'][0] row = [0, 0, 1, 1] col = [9, 24, 9, 24] A = sparse(([-1, 1, 1, 1], (row, col)), (2, 25)) u = array([Inf, Inf]) l = array([-1, 1]) N = sparse(([1], ([0], [24])), (1, 25)) ## new z variable only fparm = array([[1, 0, 0, 1]]) ## w = r = z H = sparse((1, 1)) ## no quadratic term Cw = array([100.0]) t = ''.join([t0, 'w/extra constraints & costs 1 : ']) r = opf(casefile, A, l, u, ppopt, N, fparm, H, Cw) f, bus, gen, branch, success = \ r['f'], r['bus'], r['gen'], r['branch'], r['success'] t_ok(success, [t, 'success']) t_is(f, f_soln, 3, [t, 'f']) t_is( bus[:, ib_data ], bus_soln[:, ib_data ], 10, [t, 'bus data']) t_is( bus[:, ib_voltage], bus_soln[:, ib_voltage], 3, [t, 'bus voltage']) t_is( bus[:, ib_lam ], bus_soln[:, ib_lam ], 3, [t, 'bus lambda']) t_is( bus[:, ib_mu ], bus_soln[:, ib_mu ], 2, [t, 'bus mu']) t_is( gen[:, ig_data ], gen_soln[:, ig_data ], 10, [t, 'gen data']) t_is( gen[:, ig_disp ], gen_soln[:, ig_disp ], 3, [t, 'gen dispatch']) t_is( gen[:, ig_mu ], gen_soln[:, ig_mu ], 3, [t, 'gen mu']) t_is(branch[:, ibr_data ], branch_soln[:, ibr_data ], 10, [t, 'branch data']) t_is(branch[:, ibr_flow ], branch_soln[:, ibr_flow ], 3, [t, 'branch flow']) t_is(branch[:, ibr_mu ], branch_soln[:, ibr_mu ], 2, [t, 'branch mu']) t_is(r['var']['val']['z'], 0.025419, 6, [t, 'user variable']) t_is(r['cost']['usr'], 2.5419, 4, [t, 'user cost']) ##----- test OPF with capability curves ----- ppc = loadcase(join(tdir, 't_case9_opfv2')) ## remove angle diff limits ppc['branch'][0, ANGMAX] = 360 ppc['branch'][8, ANGMIN] = -360 ## get solved AC power flow case from MAT-file soln9_opf_PQcap = loadmat(join(tdir, 'soln9_opf_PQcap.mat'), struct_as_record=True) ## defines bus_soln, gen_soln, branch_soln, f_soln bus_soln = soln9_opf_PQcap['bus_soln'] gen_soln = soln9_opf_PQcap['gen_soln'] branch_soln = soln9_opf_PQcap['branch_soln'] f_soln = soln9_opf_PQcap['f_soln'][0] ## run OPF with capability curves t = ''.join([t0, 'w/capability curves : ']) r = runopf(ppc, ppopt) bus, gen, branch, f, success = \ r['bus'], r['gen'], r['branch'], r['f'], r['success'] t_ok(success, [t, 'success']) t_is(f, f_soln, 3, [t, 'f']) t_is( bus[:, ib_data ], bus_soln[:, ib_data ], 10, [t, 'bus data']) t_is( bus[:, ib_voltage], bus_soln[:, ib_voltage], 3, [t, 'bus voltage']) t_is( bus[:, ib_lam ], bus_soln[:, ib_lam ], 3, [t, 'bus lambda']) t_is( bus[:, ib_mu ], bus_soln[:, ib_mu ], 2, [t, 'bus mu']) t_is( gen[:, ig_data ], gen_soln[:, ig_data ], 10, [t, 'gen data']) t_is( gen[:, ig_disp ], gen_soln[:, ig_disp ], 3, [t, 'gen dispatch']) t_is( gen[:, ig_mu ], gen_soln[:, ig_mu ], 3, [t, 'gen mu']) t_is(branch[:, ibr_data ], branch_soln[:, ibr_data ], 10, [t, 'branch data']) t_is(branch[:, ibr_flow ], branch_soln[:, ibr_flow ], 3, [t, 'branch flow']) t_is(branch[:, ibr_mu ], branch_soln[:, ibr_mu ], 2, [t, 'branch mu']) ##----- test OPF with angle difference limits ----- ppc = loadcase(join(tdir, 't_case9_opfv2')) ## remove capability curves ppc['gen'][ix_(arange(1, 3), [PC1, PC2, QC1MIN, QC1MAX, QC2MIN, QC2MAX])] = zeros((2, 6)) ## get solved AC power flow case from MAT-file soln9_opf_ang = loadmat(join(tdir, 'soln9_opf_ang.mat'), struct_as_record=True) ## defines bus_soln, gen_soln, branch_soln, f_soln bus_soln = soln9_opf_ang['bus_soln'] gen_soln = soln9_opf_ang['gen_soln'] branch_soln = soln9_opf_ang['branch_soln'] f_soln = soln9_opf_ang['f_soln'][0] ## run OPF with angle difference limits t = ''.join([t0, 'w/angle difference limits : ']) r = runopf(ppc, ppopt) bus, gen, branch, f, success = \ r['bus'], r['gen'], r['branch'], r['f'], r['success'] t_ok(success, [t, 'success']) t_is(f, f_soln, 3, [t, 'f']) t_is( bus[:, ib_data ], bus_soln[:, ib_data ], 10, [t, 'bus data']) t_is( bus[:, ib_voltage], bus_soln[:, ib_voltage], 3, [t, 'bus voltage']) t_is( bus[:, ib_lam ], bus_soln[:, ib_lam ], 3, [t, 'bus lambda']) t_is( bus[:, ib_mu ], bus_soln[:, ib_mu ], 1, [t, 'bus mu']) t_is( gen[:, ig_data ], gen_soln[:, ig_data ], 10, [t, 'gen data']) t_is( gen[:, ig_disp ], gen_soln[:, ig_disp ], 3, [t, 'gen dispatch']) t_is( gen[:, ig_mu ], gen_soln[:, ig_mu ], 3, [t, 'gen mu']) t_is(branch[:, ibr_data ], branch_soln[:, ibr_data ], 10, [t, 'branch data']) t_is(branch[:, ibr_flow ], branch_soln[:, ibr_flow ], 3, [t, 'branch flow']) t_is(branch[:, ibr_mu ], branch_soln[:, ibr_mu ], 2, [t, 'branch mu']) t_is(branch[:, ibr_angmu ], branch_soln[:, ibr_angmu ], 2, [t, 'branch angle mu']) ##----- test OPF with ignored angle difference limits ----- ## get solved AC power flow case from MAT-file soln9_opf = loadmat(join(tdir, 'soln9_opf.mat'), struct_as_record=True) ## defines bus_soln, gen_soln, branch_soln, f_soln bus_soln = soln9_opf['bus_soln'] gen_soln = soln9_opf['gen_soln'] branch_soln = soln9_opf['branch_soln'] f_soln = soln9_opf['f_soln'][0] ## run OPF with ignored angle difference limits t = ''.join([t0, 'w/ignored angle difference limits : ']) ppopt1 = ppoption(ppopt, OPF_IGNORE_ANG_LIM=1) r = runopf(ppc, ppopt1) bus, gen, branch, f, success = \ r['bus'], r['gen'], r['branch'], r['f'], r['success'] ## ang limits are not in this solution data, so let's remove them branch[0, ANGMAX] = 360 branch[8, ANGMIN] = -360 t_ok(success, [t, 'success']) t_is(f, f_soln, 3, [t, 'f']) t_is( bus[:, ib_data ], bus_soln[:, ib_data ], 10, [t, 'bus data']) t_is( bus[:, ib_voltage], bus_soln[:, ib_voltage], 3, [t, 'bus voltage']) t_is( bus[:, ib_lam ], bus_soln[:, ib_lam ], 3, [t, 'bus lambda']) t_is( bus[:, ib_mu ], bus_soln[:, ib_mu ], 2, [t, 'bus mu']) t_is( gen[:, ig_data ], gen_soln[:, ig_data ], 10, [t, 'gen data']) t_is( gen[:, ig_disp ], gen_soln[:, ig_disp ], 3, [t, 'gen dispatch']) t_is( gen[:, ig_mu ], gen_soln[:, ig_mu ], 3, [t, 'gen mu']) t_is(branch[:, ibr_data ], branch_soln[:, ibr_data ], 10, [t, 'branch data']) t_is(branch[:, ibr_flow ], branch_soln[:, ibr_flow ], 3, [t, 'branch flow']) t_is(branch[:, ibr_mu ], branch_soln[:, ibr_mu ], 2, [t, 'branch mu']) t_end()
def t_opf_dc_gurobi(quiet=False): """Tests for DC optimal power flow using Gurobi solver. """ algs = [0, 1, 2, 3, 4] num_tests = 23 * len(algs) t_begin(num_tests, quiet) tdir = dirname(__file__) casefile = join(tdir, 't_case9_opf') if quiet: verbose = False else: verbose = False ppopt = ppoption('OUT_ALL', 0, 'VERBOSE', verbose); ppopt = ppoption(ppopt, 'OPF_ALG_DC', 700); ## run DC OPF if have_fcn('gurobipy'): for k in range(len(algs)): ppopt = ppoption(ppopt, 'GRB_METHOD', algs[k]) methods = [ 'automatic', 'primal simplex', 'dual simplex', 'barrier', 'concurrent', 'deterministic concurrent', ] t0 = 'DC OPF (Gurobi %s): ' % methods[k] ## set up indices ib_data = r_[arange(BUS_AREA + 1), arange(BASE_KV, VMIN + 1)] ib_voltage = arange(VM, VA + 1) ib_lam = arange(LAM_P, LAM_Q + 1) ib_mu = arange(MU_VMAX, MU_VMIN + 1) ig_data = r_[[GEN_BUS, QMAX, QMIN], arange(MBASE, APF + 1)] ig_disp = array([PG, QG, VG]) ig_mu = arange(MU_PMAX, MU_QMIN + 1) ibr_data = arange(ANGMAX + 1) ibr_flow = arange(PF, QT + 1) ibr_mu = array([MU_SF, MU_ST]) #ibr_angmu = array([MU_ANGMIN, MU_ANGMAX]) ## get solved DC power flow case from MAT-file ## defines bus_soln, gen_soln, branch_soln, f_soln soln9_dcopf = loadmat(join(tdir, 'soln9_dcopf.mat'), struct_as_record=True) bus_soln, gen_soln, branch_soln, f_soln = \ soln9_dcopf['bus_soln'], soln9_dcopf['gen_soln'], \ soln9_dcopf['branch_soln'], soln9_dcopf['f_soln'] ## run OPF t = t0 r = rundcopf(casefile, ppopt) bus, gen, branch, f, success = \ r['bus'], r['gen'], r['branch'], r['f'], r['success'] t_ok(success, [t, 'success']) t_is(f, f_soln, 3, [t, 'f']) t_is( bus[:, ib_data ], bus_soln[:, ib_data ], 10, [t, 'bus data']) t_is( bus[:, ib_voltage], bus_soln[:, ib_voltage], 3, [t, 'bus voltage']) t_is( bus[:, ib_lam ], bus_soln[:, ib_lam ], 3, [t, 'bus lambda']) t_is( bus[:, ib_mu ], bus_soln[:, ib_mu ], 2, [t, 'bus mu']) t_is( gen[:, ig_data ], gen_soln[:, ig_data ], 10, [t, 'gen data']) t_is( gen[:, ig_disp ], gen_soln[:, ig_disp ], 3, [t, 'gen dispatch']) t_is( gen[:, ig_mu ], gen_soln[:, ig_mu ], 3, [t, 'gen mu']) t_is(branch[:, ibr_data ], branch_soln[:, ibr_data ], 10, [t, 'branch data']) t_is(branch[:, ibr_flow ], branch_soln[:, ibr_flow ], 3, [t, 'branch flow']) t_is(branch[:, ibr_mu ], branch_soln[:, ibr_mu ], 2, [t, 'branch mu']) ##----- run OPF with extra linear user constraints & costs ----- ## two new z variables ## 0 <= z1, P2 - P1 <= z1 ## 0 <= z2, P2 - P3 <= z2 ## with A and N sized for DC opf ppc = loadcase(casefile) row = [0, 0, 0, 1, 1, 1] col = [9, 10, 12, 10, 11, 13] ppc['A'] = sparse(([-1, 1, -1, 1, -1, -1], (row, col)), (2, 14)) ppc['u'] = array([0, 0]) ppc['l'] = array([-Inf, -Inf]) ppc['zl'] = array([0, 0]) ppc['N'] = sparse(([1, 1], ([0, 1], [12, 13])), (2, 14)) ## new z variables only ppc['fparm'] = ones((2, 1)) * array([[1, 0, 0, 1]]) ## w = r = z ppc['H'] = sparse((2, 2)) ## no quadratic term ppc['Cw'] = array([1000, 1]) t = ''.join([t0, 'w/extra constraints & costs 1 : ']) r = rundcopf(ppc, ppopt) t_ok(r['success'], [t, 'success']) t_is(r['gen'][0, PG], 116.15974, 4, [t, 'Pg1 = 116.15974']) t_is(r['gen'][1, PG], 116.15974, 4, [t, 'Pg2 = 116.15974']) t_is(r['var']['val']['z'], [0, 0.3348], 4, [t, 'user vars']) t_is(r['cost']['usr'], 0.3348, 3, [t, 'user costs']) ## with A and N sized for AC opf ppc = loadcase(casefile) row = [0, 0, 0, 1, 1, 1] col = [18, 19, 24, 19, 20, 25] ppc['A'] = sparse(([-1, 1, -1, 1, -1, -1], (row, col)), (2, 26)) ppc['u'] = array([0, 0]) ppc['l'] = array([-Inf, -Inf]) ppc['zl'] = array([0, 0]) ppc['N'] = sparse(([1, 1], ([0, 1], [24, 25])), (2, 26)) ## new z variables only ppc['fparm'] = ones((2, 1)) * array([[1, 0, 0, 1]]) ## w = r = z ppc['H'] = sparse((2, 2)) ## no quadratic term ppc['Cw'] = array([1000, 1]) t = ''.join([t0, 'w/extra constraints & costs 2 : ']) r = rundcopf(ppc, ppopt) t_ok(r['success'], [t, 'success']) t_is(r['gen'][0, PG], 116.15974, 4, [t, 'Pg1 = 116.15974']) t_is(r['gen'][1, PG], 116.15974, 4, [t, 'Pg2 = 116.15974']) t_is(r['var']['val']['z'], [0, 0.3348], 4, [t, 'user vars']) t_is(r['cost']['usr'], 0.3348, 3, [t, 'user costs']) t = ''.join([t0, 'infeasible : ']) ## with A and N sized for DC opf ppc = loadcase(casefile) ppc['A'] = sparse(([1, 1], ([0, 0], [9, 10])), (1, 14)) ## Pg1 + Pg2 ppc['u'] = array([Inf]) ppc['l'] = array([600]) r = rundcopf(ppc, ppopt) t_ok(not r['success'], [t, 'no success']) else: t_skip(num_tests, 'Gurobi not available') t_end()
def t_loadcase(quiet=False): """Test that C{loadcase} works with an object as well as case file. @author: Ray Zimmerman (PSERC Cornell) @author: Richard Lincoln """ t_begin(240, quiet) ## compare result of loading from M-file file to result of using data matrices tdir = dirname(__file__) casefile = join(tdir, 't_case9_opf') matfile = join(tdir, 't_mat9_opf') pfcasefile = join(tdir, 't_case9_pf') pfmatfile = join(tdir, 't_mat9_pf') casefilev2 = join(tdir, 't_case9_opfv2') matfilev2 = join(tdir, 't_mat9_opfv2') pfcasefilev2 = join(tdir, 't_case9_pfv2') pfmatfilev2 = join(tdir, 't_mat9_pfv2') ## read version 1 OPF data matrices baseMVA, bus, gen, branch, areas, gencost = t_case9_opf() ## save as .mat file savemat(matfile + '.mat', {'baseMVA': baseMVA, 'bus': bus, 'gen': gen, 'branch': branch, 'areas': areas, 'gencost': gencost}, oned_as='row') ## read version 2 OPF data matrices ppc = t_case9_opfv2() ## save as .mat file savemat(matfilev2 + '.mat', {'ppc': ppc}, oned_as='column') ## prepare expected matrices for v1 load ## (missing gen cap curve & branch ang diff lims) tmp1 = (ppc['baseMVA'], ppc['bus'].copy(), ppc['gen'].copy(), ppc['branch'].copy(), ppc['areas'].copy(), ppc['gencost'].copy()) tmp2 = (ppc['baseMVA'], ppc['bus'].copy(), ppc['gen'].copy(), ppc['branch'].copy(), ppc['areas'].copy(), ppc['gencost'].copy()) ## remove capability curves, angle difference limits tmp1[2][1:3, [PC1, PC2, QC1MIN, QC1MAX, QC2MIN, QC2MAX]] = zeros((2,6)) tmp1[3][0, ANGMAX] = 360 tmp1[3][8, ANGMIN] = -360 baseMVA, bus, gen, branch, areas, gencost = tmp1 ##----- load OPF data into individual matrices ----- t = 'loadcase(opf_PY_file_v1) without .py extension : ' baseMVA1, bus1, gen1, branch1, areas1, gencost1 = \ loadcase(casefile, False) t_is(baseMVA1, baseMVA, 12, [t, 'baseMVA']) t_is(bus1, bus, 12, [t, 'bus']) t_is(gen1, gen, 12, [t, 'gen']) t_is(branch1, branch, 12, [t, 'branch']) t_is(areas1, areas, 12, [t, 'areas']) t_is(gencost1, gencost, 12, [t, 'gencost']) t = 'loadcase(opf_PY_file_v1) with .py extension : ' baseMVA1, bus1, gen1, branch1, areas1, gencost1 = \ loadcase(casefile + '.py', False) t_is(baseMVA1, baseMVA, 12, [t, 'baseMVA']) t_is(bus1, bus, 12, [t, 'bus']) t_is(gen1, gen, 12, [t, 'gen']) t_is(branch1, branch, 12, [t, 'branch']) t_is(areas1, areas, 12, [t, 'areas']) t_is(gencost1, gencost, 12, [t, 'gencost']) t = 'loadcase(opf_MAT_file_v1) without .mat extension : ' baseMVA1, bus1, gen1, branch1, areas1, gencost1 = \ loadcase(matfile, False) t_is(baseMVA1, baseMVA, 12, [t, 'baseMVA']) t_is(bus1, bus, 12, [t, 'bus']) t_is(gen1, gen, 12, [t, 'gen']) t_is(branch1, branch, 12, [t, 'branch']) t_is(areas1, areas, 12, [t, 'areas']) t_is(gencost1, gencost, 12, [t, 'gencost']) t = 'loadcase(opf_MAT_file_v1) with .mat extension : ' baseMVA1, bus1, gen1, branch1, areas1, gencost1 = \ loadcase(matfile + '.mat', False) t_is(baseMVA1, baseMVA, 12, [t, 'baseMVA']) t_is(bus1, bus, 12, [t, 'bus']) t_is(gen1, gen, 12, [t, 'gen']) t_is(branch1, branch, 12, [t, 'branch']) t_is(areas1, areas, 12, [t, 'areas']) t_is(gencost1, gencost, 12, [t, 'gencost']) ## prepare expected matrices for v2 load baseMVA, bus, gen, branch, areas, gencost = tmp2 t = 'loadcase(opf_PY_file_v2) without .py extension : ' baseMVA1, bus1, gen1, branch1, areas1, gencost1 = \ loadcase(casefilev2, False) t_is(baseMVA1, baseMVA, 12, [t, 'baseMVA']) t_is(bus1, bus, 12, [t, 'bus']) t_is(gen1, gen, 12, [t, 'gen']) t_is(branch1, branch, 12, [t, 'branch']) t_is(areas1, areas, 12, [t, 'areas']) t_is(gencost1, gencost, 12, [t, 'gencost']) t = 'loadcase(opf_PY_file_v2) with .py extension : ' baseMVA1, bus1, gen1, branch1, areas1, gencost1 = \ loadcase(casefilev2 + '.py', False) t_is(baseMVA1, baseMVA, 12, [t, 'baseMVA']) t_is(bus1, bus, 12, [t, 'bus']) t_is(gen1, gen, 12, [t, 'gen']) t_is(branch1, branch, 12, [t, 'branch']) t_is(areas1, areas, 12, [t, 'areas']) t_is(gencost1, gencost, 12, [t, 'gencost']) t = 'loadcase(opf_MAT_file_v2) without .mat extension : ' baseMVA1, bus1, gen1, branch1, areas1, gencost1 = \ loadcase(matfilev2, False) t_is(baseMVA1, baseMVA, 12, [t, 'baseMVA']) t_is(bus1, bus, 12, [t, 'bus']) t_is(gen1, gen, 12, [t, 'gen']) t_is(branch1, branch, 12, [t, 'branch']) t_is(areas1, areas, 12, [t, 'areas']) t_is(gencost1, gencost, 12, [t, 'gencost']) t = 'loadcase(opf_MAT_file_v2) with .mat extension : ' baseMVA1, bus1, gen1, branch1, areas1, gencost1 = \ loadcase(matfilev2 + '.mat', False) t_is(baseMVA1, baseMVA, 12, [t, 'baseMVA']) t_is(bus1, bus, 12, [t, 'bus']) t_is(gen1, gen, 12, [t, 'gen']) t_is(branch1, branch, 12, [t, 'branch']) t_is(areas1, areas, 12, [t, 'areas']) t_is(gencost1, gencost, 12, [t, 'gencost']) ## prepare expected matrices for v1 load baseMVA, bus, gen, branch, areas, gencost = tmp1 t = 'loadcase(opf_struct_v1) (no version): ' baseMVA1, bus1, gen1, branch1, areas1, gencost1 = t_case9_opf() c = {} c['baseMVA'] = baseMVA1 c['bus'] = bus1.copy() c['gen'] = gen1.copy() c['branch'] = branch1.copy() c['areas'] = areas1.copy() c['gencost'] = gencost1.copy() baseMVA2, bus2, gen2, branch2, areas2, gencost2 = loadcase(c, False) t_is(baseMVA2, baseMVA, 12, [t, 'baseMVA']) t_is(bus2, bus, 12, [t, 'bus']) t_is(gen2, gen, 12, [t, 'gen']) t_is(branch2, branch, 12, [t, 'branch']) t_is(areas2, areas, 12, [t, 'areas']) t_is(gencost2, gencost, 12, [t, 'gencost']) t = 'loadcase(opf_struct_v1) (version=\'1\'): ' c['version'] = '1' baseMVA2, bus2, gen2, branch2, areas2, gencost2 = loadcase(c, False) t_is(baseMVA2, baseMVA, 12, [t, 'baseMVA']) t_is(bus2, bus, 12, [t, 'bus']) t_is(gen2, gen, 12, [t, 'gen']) t_is(branch2, branch, 12, [t, 'branch']) t_is(areas2, areas, 12, [t, 'areas']) t_is(gencost2, gencost, 12, [t, 'gencost']) ## prepare expected matrices for v2 load baseMVA, bus, gen, branch, areas, gencost = tmp2 t = 'loadcase(opf_struct_v2) (no version): ' c = {} c['baseMVA'] = baseMVA c['bus'] = bus.copy() c['gen'] = gen.copy() c['branch'] = branch.copy() c['areas'] = areas.copy() c['gencost'] = gencost.copy() baseMVA2, bus2, gen2, branch2, areas2, gencost2 = loadcase(c, False) t_is(baseMVA2, baseMVA, 12, [t, 'baseMVA']) t_is(bus2, bus, 12, [t, 'bus']) t_is(gen2, gen, 12, [t, 'gen']) t_is(branch2, branch, 12, [t, 'branch']) t_is(areas2, areas, 12, [t, 'areas']) t_is(gencost2, gencost, 12, [t, 'gencost']) t = 'loadcase(opf_struct_v2) (version=''2''): ' c = {} c['baseMVA'] = baseMVA c['bus'] = bus.copy() c['gen'] = gen.copy() c['branch'] = branch.copy() c['areas'] = areas.copy() c['gencost'] = gencost.copy() c['version'] = '2' baseMVA2, bus2, gen2, branch2, areas2, gencost2 = loadcase(c, False) t_is(baseMVA2, baseMVA, 12, [t, 'baseMVA']) t_is(bus2, bus, 12, [t, 'bus']) t_is(gen2, gen, 12, [t, 'gen']) t_is(branch2, branch, 12, [t, 'branch']) t_is(areas2, areas, 12, [t, 'areas']) t_is(gencost2, gencost, 12, [t, 'gencost']) ##----- load OPF data into struct ----- ## prepare expected matrices for v1 load baseMVA, bus, gen, branch, areas, gencost = tmp1 t = 'ppc = loadcase(opf_PY_file_v1) without .py extension : ' ppc1 = loadcase(casefile) t_is(ppc1['baseMVA'], baseMVA, 12, [t, 'baseMVA']) t_is(ppc1['bus'], bus, 12, [t, 'bus']) t_is(ppc1['gen'], gen, 12, [t, 'gen']) t_is(ppc1['branch'], branch, 12, [t, 'branch']) t_is(ppc1['areas'], areas, 12, [t, 'areas']) t_is(ppc1['gencost'], gencost, 12, [t, 'gencost']) t = 'ppc = loadcase(opf_PY_file_v1) with .py extension : ' ppc1 = loadcase(casefile + '.py') t_is(ppc1['baseMVA'], baseMVA, 12, [t, 'baseMVA']) t_is(ppc1['bus'], bus, 12, [t, 'bus']) t_is(ppc1['gen'], gen, 12, [t, 'gen']) t_is(ppc1['branch'], branch, 12, [t, 'branch']) t_is(ppc1['areas'], areas, 12, [t, 'areas']) t_is(ppc1['gencost'], gencost, 12, [t, 'gencost']) t = 'ppc = loadcase(opf_MAT_file_v1) without .mat extension : ' ppc1 = loadcase(matfile) t_is(ppc1['baseMVA'], baseMVA, 12, [t, 'baseMVA']) t_is(ppc1['bus'], bus, 12, [t, 'bus']) t_is(ppc1['gen'], gen, 12, [t, 'gen']) t_is(ppc1['branch'], branch, 12, [t, 'branch']) t_is(ppc1['areas'], areas, 12, [t, 'areas']) t_is(ppc1['gencost'], gencost, 12, [t, 'gencost']) t = 'ppc = loadcase(opf_MAT_file_v1) with .mat extension : ' ppc1 = loadcase(matfile + '.mat') t_is(ppc1['baseMVA'], baseMVA, 12, [t, 'baseMVA']) t_is(ppc1['bus'], bus, 12, [t, 'bus']) t_is(ppc1['gen'], gen, 12, [t, 'gen']) t_is(ppc1['branch'], branch, 12, [t, 'branch']) t_is(ppc1['areas'], areas, 12, [t, 'areas']) t_is(ppc1['gencost'], gencost, 12, [t, 'gencost']) ## prepare expected matrices for v2 load baseMVA, bus, gen, branch, areas, gencost = tmp2 t = 'ppc = loadcase(opf_PY_file_v2) without .m extension : ' ppc1 = loadcase(casefilev2) t_is(ppc1['baseMVA'], baseMVA, 12, [t, 'baseMVA']) t_is(ppc1['bus'], bus, 12, [t, 'bus']) t_is(ppc1['gen'], gen, 12, [t, 'gen']) t_is(ppc1['branch'], branch, 12, [t, 'branch']) t_is(ppc1['areas'], areas, 12, [t, 'areas']) t_is(ppc1['gencost'], gencost, 12, [t, 'gencost']) t = 'ppc = loadcase(opf_PY_file_v2) with .py extension : ' ppc1 = loadcase(casefilev2 + '.py') t_is(ppc1['baseMVA'], baseMVA, 12, [t, 'baseMVA']) t_is(ppc1['bus'], bus, 12, [t, 'bus']) t_is(ppc1['gen'], gen, 12, [t, 'gen']) t_is(ppc1['branch'], branch, 12, [t, 'branch']) t_is(ppc1['areas'], areas, 12, [t, 'areas']) t_is(ppc1['gencost'], gencost, 12, [t, 'gencost']) t = 'ppc = loadcase(opf_MAT_file_v2) without .mat extension : ' ppc1 = loadcase(matfilev2) t_is(ppc1['baseMVA'], baseMVA, 12, [t, 'baseMVA']) t_is(ppc1['bus'], bus, 12, [t, 'bus']) t_is(ppc1['gen'], gen, 12, [t, 'gen']) t_is(ppc1['branch'], branch, 12, [t, 'branch']) t_is(ppc1['areas'], areas, 12, [t, 'areas']) t_is(ppc1['gencost'], gencost, 12, [t, 'gencost']) t = 'ppc = loadcase(opf_MAT_file_v2) with .mat extension : ' ppc1 = loadcase(matfilev2 + '.mat') t_is(ppc1['baseMVA'], baseMVA, 12, [t, 'baseMVA']) t_is(ppc1['bus'], bus, 12, [t, 'bus']) t_is(ppc1['gen'], gen, 12, [t, 'gen']) t_is(ppc1['branch'], branch, 12, [t, 'branch']) t_is(ppc1['areas'], areas, 12, [t, 'areas']) t_is(ppc1['gencost'], gencost, 12, [t, 'gencost']) ## prepare expected matrices for v1 load baseMVA, bus, gen, branch, areas, gencost = tmp1 t = 'ppc = loadcase(opf_struct_v1) (no version): ' baseMVA1, bus1, gen1, branch1, areas1, gencost1 = t_case9_opf() c = {} c['baseMVA'] = baseMVA1 c['bus'] = bus1.copy() c['gen'] = gen1.copy() c['branch'] = branch1.copy() c['areas'] = areas1.copy() c['gencost'] = gencost1.copy() ppc2 = loadcase(c) t_is(ppc2['baseMVA'], baseMVA, 12, [t, 'baseMVA']) t_is(ppc2['bus'], bus, 12, [t, 'bus']) t_is(ppc2['gen'], gen, 12, [t, 'gen']) t_is(ppc2['branch'], branch, 12, [t, 'branch']) t_is(ppc2['areas'], areas, 12, [t, 'areas']) t_is(ppc2['gencost'], gencost, 12, [t, 'gencost']) t = 'ppc = loadcase(opf_struct_v1) (version=''1''): ' c['version'] = '1' ppc2 = loadcase(c) t_is(ppc2['baseMVA'], baseMVA, 12, [t, 'baseMVA']) t_is(ppc2['bus'], bus, 12, [t, 'bus']) t_is(ppc2['gen'], gen, 12, [t, 'gen']) t_is(ppc2['branch'], branch, 12, [t, 'branch']) t_is(ppc2['areas'], areas, 12, [t, 'areas']) t_is(ppc2['gencost'], gencost, 12, [t, 'gencost']) ## prepare expected matrices for v2 load baseMVA, bus, gen, branch, areas, gencost = tmp2 t = 'ppc = loadcase(opf_struct_v2) (no version): ' c = {} c['baseMVA'] = baseMVA c['bus'] = bus.copy() c['gen'] = gen.copy() c['branch'] = branch.copy() c['areas'] = areas.copy() c['gencost'] = gencost.copy() ppc2 = loadcase(c) t_is(ppc2['baseMVA'], baseMVA, 12, [t, 'baseMVA']) t_is(ppc2['bus'], bus, 12, [t, 'bus']) t_is(ppc2['gen'], gen, 12, [t, 'gen']) t_is(ppc2['branch'], branch, 12, [t, 'branch']) t_is(ppc2['areas'], areas, 12, [t, 'areas']) t_is(ppc2['gencost'], gencost, 12, [t, 'gencost']) t_ok(ppc2['version'] == '2', [t, 'version']) t = 'ppc = loadcase(opf_struct_v2) (version=''2''): ' c = {} c['baseMVA'] = baseMVA c['bus'] = bus.copy() c['gen'] = gen.copy() c['branch'] = branch.copy() c['areas'] = areas.copy() c['gencost'] = gencost.copy() c['version'] = '2' ppc2 = loadcase(c) t_is(ppc2['baseMVA'], baseMVA, 12, [t, 'baseMVA']) t_is(ppc2['bus'], bus, 12, [t, 'bus']) t_is(ppc2['gen'], gen, 12, [t, 'gen']) t_is(ppc2['branch'], branch, 12, [t, 'branch']) t_is(ppc2['areas'], areas, 12, [t, 'areas']) t_is(ppc2['gencost'], gencost, 12, [t, 'gencost']) ## read version 1 PF data matrices baseMVA, bus, gen, branch = t_case9_pf() savemat(pfmatfile + '.mat', {'baseMVA': baseMVA, 'bus': bus, 'gen': gen, 'branch': branch}, oned_as='column') ## read version 2 PF data matrices ppc = t_case9_pfv2() tmp = (ppc['baseMVA'], ppc['bus'].copy(), ppc['gen'].copy(), ppc['branch'].copy()) baseMVA, bus, gen, branch = tmp ## save as .mat file savemat(pfmatfilev2 + '.mat', {'ppc': ppc}, oned_as='column') ##----- load PF data into individual matrices ----- t = 'loadcase(pf_PY_file_v1) without .py extension : ' baseMVA1, bus1, gen1, branch1 = \ loadcase(pfcasefile, False, False, False) t_is(baseMVA1, baseMVA, 12, [t, 'baseMVA']) t_is(bus1, bus, 12, [t, 'bus']) t_is(gen1, gen, 12, [t, 'gen']) t_is(branch1, branch, 12, [t, 'branch']) t = 'loadcase(pf_PY_file_v1) with .py extension : ' baseMVA1, bus1, gen1, branch1 = \ loadcase(pfcasefile + '.py', False, False, False) t_is(baseMVA1, baseMVA, 12, [t, 'baseMVA']) t_is(bus1, bus, 12, [t, 'bus']) t_is(gen1, gen, 12, [t, 'gen']) t_is(branch1, branch, 12, [t, 'branch']) t = 'loadcase(pf_MAT_file_v1) without .mat extension : ' baseMVA1, bus1, gen1, branch1 = \ loadcase(pfmatfile, False, False, False) t_is(baseMVA1, baseMVA, 12, [t, 'baseMVA']) t_is(bus1, bus, 12, [t, 'bus']) t_is(gen1, gen, 12, [t, 'gen']) t_is(branch1, branch, 12, [t, 'branch']) t = 'loadcase(pf_MAT_file_v1) with .mat extension : ' baseMVA1, bus1, gen1, branch1 = \ loadcase(pfmatfile + '.mat', False, False, False) t_is(baseMVA1, baseMVA, 12, [t, 'baseMVA']) t_is(bus1, bus, 12, [t, 'bus']) t_is(gen1, gen, 12, [t, 'gen']) t_is(branch1, branch, 12, [t, 'branch']) t = 'loadcase(pf_PY_file_v2) without .py extension : ' baseMVA1, bus1, gen1, branch1 = \ loadcase(pfcasefilev2, False, False, False) t_is(baseMVA1, baseMVA, 12, [t, 'baseMVA']) t_is(bus1, bus, 12, [t, 'bus']) t_is(gen1, gen, 12, [t, 'gen']) t_is(branch1, branch, 12, [t, 'branch']) t = 'loadcase(pf_PY_file_v2) with .py extension : ' baseMVA1, bus1, gen1, branch1 = \ loadcase(pfcasefilev2 + '.py', False, False, False) t_is(baseMVA1, baseMVA, 12, [t, 'baseMVA']) t_is(bus1, bus, 12, [t, 'bus']) t_is(gen1, gen, 12, [t, 'gen']) t_is(branch1, branch, 12, [t, 'branch']) t = 'loadcase(pf_MAT_file_v2) without .mat extension : ' baseMVA1, bus1, gen1, branch1 = \ loadcase(pfmatfilev2, False, False, False) t_is(baseMVA1, baseMVA, 12, [t, 'baseMVA']) t_is(bus1, bus, 12, [t, 'bus']) t_is(gen1, gen, 12, [t, 'gen']) t_is(branch1, branch, 12, [t, 'branch']) t = 'loadcase(pf_MAT_file_v2) with .mat extension : ' baseMVA1, bus1, gen1, branch1 = \ loadcase(pfmatfilev2 + '.mat', False, False, False) t_is(baseMVA1, baseMVA, 12, [t, 'baseMVA']) t_is(bus1, bus, 12, [t, 'bus']) t_is(gen1, gen, 12, [t, 'gen']) t_is(branch1, branch, 12, [t, 'branch']) t = 'loadcase(pf_struct_v1) (no version): ' baseMVA1, bus1, gen1, branch1 = t_case9_pf() c = {} c['baseMVA'] = baseMVA1 c['bus'] = bus1.copy() c['gen'] = gen1.copy() c['branch'] = branch1.copy() baseMVA2, bus2, gen2, branch2 = loadcase(c, False, False, False) t_is(baseMVA2, baseMVA, 12, [t, 'baseMVA']) t_is(bus2, bus, 12, [t, 'bus']) t_is(gen2, gen, 12, [t, 'gen']) t_is(branch2, branch, 12, [t, 'branch']) t = 'loadcase(pf_struct_v1) (version=''1''): ' c['version'] = '1' baseMVA2, bus2, gen2, branch2 = loadcase(c, False, False, False) t_is(baseMVA2, baseMVA, 12, [t, 'baseMVA']) t_is(bus2, bus, 12, [t, 'bus']) t_is(gen2, gen, 12, [t, 'gen']) t_is(branch2, branch, 12, [t, 'branch']) t = 'loadcase(pf_struct_v2) : ' c = {} c['baseMVA'] = baseMVA c['bus'] = bus.copy() c['gen'] = gen.copy() c['branch'] = branch.copy() c['version'] = '2' baseMVA2, bus2, gen2, branch2 = loadcase(c, False, False, False) t_is(baseMVA2, baseMVA, 12, [t, 'baseMVA']) t_is(bus2, bus, 12, [t, 'bus']) t_is(gen2, gen, 12, [t, 'gen']) t_is(branch2, branch, 12, [t, 'branch']) ##----- load PF data into struct ----- t = 'ppc = loadcase(pf_PY_file_v1) without .py extension : ' ppc1 = loadcase(pfcasefile) t_is(ppc1['baseMVA'], baseMVA, 12, [t, 'baseMVA']) t_is(ppc1['bus'], bus, 12, [t, 'bus']) t_is(ppc1['gen'], gen, 12, [t, 'gen']) t_is(ppc1['branch'], branch, 12, [t, 'branch']) t = 'ppc = loadcase(pf_PY_file_v1) with .py extension : ' ppc1 = loadcase(pfcasefile + '.py') t_is(ppc1['baseMVA'], baseMVA, 12, [t, 'baseMVA']) t_is(ppc1['bus'], bus, 12, [t, 'bus']) t_is(ppc1['gen'], gen, 12, [t, 'gen']) t_is(ppc1['branch'], branch, 12, [t, 'branch']) t = 'ppc = loadcase(pf_MAT_file_v1) without .mat extension : ' ppc1 = loadcase(pfmatfile) t_is(ppc1['baseMVA'], baseMVA, 12, [t, 'baseMVA']) t_is(ppc1['bus'], bus, 12, [t, 'bus']) t_is(ppc1['gen'], gen, 12, [t, 'gen']) t_is(ppc1['branch'], branch, 12, [t, 'branch']) t = 'ppc = loadcase(pf_MAT_file_v1) with .mat extension : ' ppc1 = loadcase(pfmatfile + '.mat') t_is(ppc1['baseMVA'], baseMVA, 12, [t, 'baseMVA']) t_is(ppc1['bus'], bus, 12, [t, 'bus']) t_is(ppc1['gen'], gen, 12, [t, 'gen']) t_is(ppc1['branch'], branch, 12, [t, 'branch']) t = 'ppc = loadcase(pf_PY_file_v2) without .py extension : ' ppc1 = loadcase(pfcasefilev2) t_is(ppc1['baseMVA'], baseMVA, 12, [t, 'baseMVA']) t_is(ppc1['bus'], bus, 12, [t, 'bus']) t_is(ppc1['gen'], gen, 12, [t, 'gen']) t_is(ppc1['branch'], branch, 12, [t, 'branch']) t = 'ppc = loadcase(pf_PY_file_v2) with .py extension : ' ppc1 = loadcase(pfcasefilev2 + '.py') t_is(ppc1['baseMVA'], baseMVA, 12, [t, 'baseMVA']) t_is(ppc1['bus'], bus, 12, [t, 'bus']) t_is(ppc1['gen'], gen, 12, [t, 'gen']) t_is(ppc1['branch'], branch, 12, [t, 'branch']) t = 'ppc = loadcase(pf_MAT_file_v2) without .mat extension : ' ppc1 = loadcase(pfmatfilev2) t_is(ppc1['baseMVA'], baseMVA, 12, [t, 'baseMVA']) t_is(ppc1['bus'], bus, 12, [t, 'bus']) t_is(ppc1['gen'], gen, 12, [t, 'gen']) t_is(ppc1['branch'], branch, 12, [t, 'branch']) t = 'ppc = loadcase(pf_MAT_file_v2) with .mat extension : ' ppc1 = loadcase(pfmatfilev2 + '.mat') t_is(ppc1['baseMVA'], baseMVA, 12, [t, 'baseMVA']) t_is(ppc1['bus'], bus, 12, [t, 'bus']) t_is(ppc1['gen'], gen, 12, [t, 'gen']) t_is(ppc1['branch'], branch, 12, [t, 'branch']) t = 'ppc = loadcase(pf_struct_v1) (no version): ' baseMVA1, bus1, gen1, branch1 = t_case9_pf() c = {} c['baseMVA'] = baseMVA1 c['bus'] = bus1.copy() c['gen'] = gen1.copy() c['branch'] = branch1.copy() ppc2 = loadcase(c) t_is(ppc2['baseMVA'], baseMVA, 12, [t, 'baseMVA']) t_is(ppc2['bus'], bus, 12, [t, 'bus']) t_is(ppc2['gen'], gen, 12, [t, 'gen']) t_is(ppc2['branch'], branch, 12, [t, 'branch']) t = 'ppc = loadcase(pf_struct_v1) (version=''1''): ' c['version'] = '1' ppc2 = loadcase(c) t_is(ppc2['baseMVA'], baseMVA, 12, [t, 'baseMVA']) t_is(ppc2['bus'], bus, 12, [t, 'bus']) t_is(ppc2['gen'], gen, 12, [t, 'gen']) t_is(ppc2['branch'], branch, 12, [t, 'branch']) t = 'ppc = loadcase(pf_struct_v2) : ' c = {} c['baseMVA'] = baseMVA c['bus'] = bus.copy() c['gen'] = gen.copy() c['branch'] = branch.copy() c['version'] = '2' ppc2 = loadcase(c) t_is(ppc2['baseMVA'], baseMVA, 12, [t, 'baseMVA']) t_is(ppc2['bus'], bus, 12, [t, 'bus']) t_is(ppc2['gen'], gen, 12, [t, 'gen']) t_is(ppc2['branch'], branch, 12, [t, 'branch']) ## cleanup os.remove(matfile + '.mat') os.remove(pfmatfile + '.mat') os.remove(matfilev2 + '.mat') os.remove(pfmatfilev2 + '.mat') t = 'runpf(my_PY_file)' ppopt = ppoption(VERBOSE=0, OUT_ALL=0) results3, success = runpf(pfcasefile, ppopt) baseMVA3, bus3, gen3, branch3 = results3['baseMVA'], results3['bus'], \ results3['gen'], results3['branch'] t_ok( success, t ) t = 'runpf(my_object)' results4, success = runpf(c, ppopt) baseMVA4, bus4, gen4, branch4 = results4['baseMVA'], results4['bus'], \ results4['gen'], results4['branch'] t_ok( success, t ) t = 'runpf result comparison : ' t_is(baseMVA3, baseMVA4, 12, [t, 'baseMVA']) t_is(bus3, bus4, 12, [t, 'bus']) t_is(gen3, gen4, 12, [t, 'gen']) t_is(branch3, branch4, 12, [t, 'branch']) t = 'runpf(modified_struct)' c['gen'][2, 1] = c['gen'][2, 1] + 1 ## increase gen 3 output by 1 results5, success = runpf(c, ppopt) gen5 = results5['gen'] t_is(gen5[0, 1], gen4[0, 1] - 1, 1, t) ## slack bus output should decrease by 1 t_end()
def t_opf_userfcns(quiet=False): """Tests for userfcn callbacks (reserves/iflims) w/OPF. Includes high-level tests of reserves and iflims implementations. @author: Ray Zimmerman (PSERC Cornell) @author: Richard Lincoln """ t_begin(38, quiet) tdir = dirname(__file__) casefile = join(tdir, 't_case30_userfcns') verbose = 0 #not quiet ppopt = ppoption(OPF_VIOLATION=1e-6, PDIPM_GRADTOL=1e-8, PDIPM_COMPTOL=1e-8, PDIPM_COSTTOL=1e-9) ppopt = ppoption(ppopt, OUT_ALL=0, VERBOSE=verbose, OPF_ALG=560, OPF_ALG_DC=200) #ppopt = ppoption(ppopt, OUT_ALL=-1, VERBOSE=2, OUT_GEN=1) ## run the OPF with fixed reserves t = 'fixed reserves : ' ppc = loadcase(casefile) ppc = toggle_reserves(ppc, 'on') r = runopf(ppc, ppopt) t_ok(r['success'], [t, 'success']) t_is(r['reserves']['R'], [25, 15, 0, 0, 19.3906, 0.6094], 4, [t, 'reserves.R']) t_is(r['reserves']['prc'], [2, 2, 2, 2, 5.5, 5.5], 4, [t, 'reserves.prc']) t_is(r['reserves']['mu']['Pmax'], [0, 0, 0, 0, 0.5, 0], 4, [t, 'reserves.mu.Pmax']) t_is(r['reserves']['mu']['l'], [0, 0, 1, 2, 0, 0], 4, [t, 'reserves.mu.l']) t_is(r['reserves']['mu']['u'], [0.1, 0, 0, 0, 0, 0], 4, [t, 'reserves.mu.u']) t_ok('P' not in r['if'], [t, 'no iflims']) t_is(r['reserves']['totalcost'], 177.8047, 4, [t, 'totalcost']) t = 'toggle_reserves(ppc, \'off\') : ' ppc = toggle_reserves(ppc, 'off') r = runopf(ppc, ppopt) t_ok(r['success'], [t, 'success']) t_ok('R' not in r['reserves'], [t, 'no reserves']) t_ok('P' not in r['if'], [t, 'no iflims']) t = 'interface flow lims (DC) : ' ppc = loadcase(casefile) ppc = toggle_iflims(ppc, 'on') r = rundcopf(ppc, ppopt) t_ok(r['success'], [t, 'success']) t_is(r['if']['P'], [-15, 20], 4, [t, 'if.P']) t_is(r['if']['mu']['l'], [4.8427, 0], 4, [t, 'if.mu.l']) t_is(r['if']['mu']['u'], [0, 13.2573], 4, [t, 'if.mu.u']) t_is(r['branch'][13, PF], 8.244, 3, [t, 'flow in branch 14']) t_ok('R' not in r['reserves'], [t, 'no reserves']) t = 'reserves + interface flow lims (DC) : ' ppc = loadcase(casefile) ppc = toggle_reserves(ppc, 'on') ppc = toggle_iflims(ppc, 'on') r = rundcopf(ppc, ppopt) t_ok(r['success'], [t, 'success']) t_is(r['if']['P'], [-15, 20], 4, [t, 'if.P']) t_is(r['if']['mu']['l'], [4.8427, 0], 4, [t, 'if.mu.l']) t_is(r['if']['mu']['u'], [0, 38.2573], 4, [t, 'if.mu.u']) t_is(r['reserves']['R'], [25, 15, 0, 0, 16.9, 3.1], 4, [t, 'reserves.R']) t_is(r['reserves']['prc'], [2, 2, 2, 2, 5.5, 5.5], 4, [t, 'reserves.prc']) t_is(r['reserves']['mu']['Pmax'], [0, 0, 0, 0, 0.5, 0], 4, [t, 'reserves.mu.Pmax']) t_is(r['reserves']['mu']['l'], [0, 0, 1, 2, 0, 0], 4, [t, 'reserves.mu.l']) t_is(r['reserves']['mu']['u'], [0.1, 0, 0, 0, 0, 0], 4, [t, 'reserves.mu.u']) t_is(r['reserves']['totalcost'], 179.05, 4, [t, 'totalcost']) t = 'interface flow lims (AC) : ' ppc = toggle_reserves(ppc, 'off') r = runopf(ppc, ppopt) t_ok(r['success'], [t, 'success']) t_is(r['if']['P'], [-9.101, 21.432], 3, [t, 'if.P']) t_is(r['if']['mu']['l'], [0, 0], 4, [t, 'if.mu.l']) t_is(r['if']['mu']['u'], [0, 10.198], 3, [t, 'if.mu.u']) t_ok('R' not in r['reserves'], [t, 'no reserves']) t = 'interface flow lims (line out) : ' ppc = loadcase(casefile) ppc = toggle_iflims(ppc, 'on') ppc['branch'][11, BR_STATUS] = 0 ## take out line 6-10 r = rundcopf(ppc, ppopt) t_ok(r['success'], [t, 'success']) t_is(r['if']['P'], [-15, 20], 4, [t, 'if.P']) t_is(r['if']['mu']['l'], [4.8427, 0], 4, [t, 'if.mu.l']) t_is(r['if']['mu']['u'], [0, 13.2573], 4, [t, 'if.mu.u']) t_is(r['branch'][13, PF], 10.814, 3, [t, 'flow in branch 14']) t_ok('R' not in r['reserves'], [t, 'no reserves']) # r['reserves']['R'] # r['reserves']['prc'] # r['reserves']['mu.Pmax'] # r['reserves']['mu']['l'] # r['reserves']['mu']['u'] # r['reserves']['totalcost'] # # r['if']['P'] # r['if']['mu']['l'] # r['if']['mu']['u'] t_end()
def t_pips(quiet=False): """Tests of pips NLP solver. @author: Ray Zimmerman (PSERC Cornell) @author: Richard Lincoln """ t_begin(60, quiet) t = 'unconstrained banana function : ' ## from MATLAB Optimization Toolbox's bandem.m f_fcn = f2 x0 = array([-1.9, 2]) # solution = pips(f_fcn, x0, opt={'verbose': 2}) solution = pips(f_fcn, x0) x, f, s, lam, out = solution["x"], solution["f"], solution["eflag"], \ solution["lmbda"], solution["output"] t_is(s, 1, 13, [t, 'success']) t_is(x, [1, 1], 13, [t, 'x']) t_is(f, 0, 13, [t, 'f']) t_is(out['hist'][-1]['compcond'], 0, 6, [t, 'compcond']) t_ok(len(lam['mu_l']) == 0, [t, 'lam.mu_l']) t_ok(len(lam['mu_u']) == 0, [t, 'lam.mu_u']) t_is(lam['lower'], zeros(x.shape), 13, [t, 'lam[\'lower\']']) t_is(lam['upper'], zeros(x.shape), 13, [t, 'lam[\'upper\']']) t = 'unconstrained 3-d quadratic : ' ## from http://www.akiti.ca/QuadProgEx0Constr.html f_fcn = f3 x0 = array([0, 0, 0], float) # solution = pips(f_fcn, x0, opt={'verbose': 2}) solution = pips(f_fcn, x0) x, f, s, lam, out = solution["x"], solution["f"], solution["eflag"], \ solution["lmbda"], solution["output"] t_is(s, 1, 13, [t, 'success']) t_is(x, [3, 5, 7], 13, [t, 'x']) t_is(f, -244, 13, [t, 'f']) t_is(out['hist'][-1]['compcond'], 0, 6, [t, 'compcond']) t_ok(len(lam['mu_l']) == 0, [t, 'lam.mu_l']) t_ok(len(lam['mu_u']) == 0, [t, 'lam.mu_u']) t_is(lam['lower'], zeros(x.shape), 13, [t, 'lam[\'lower\']']) t_is(lam['upper'], zeros(x.shape), 13, [t, 'lam[\'upper\']']) t = 'constrained 4-d QP : ' ## from http://www.jmu.edu/docs/sasdoc/sashtml/iml/chap8/sect12.htm f_fcn = f4 x0 = array([1.0, 0.0, 0.0, 1.0]) A = array([ [1.0, 1.0, 1.0, 1.0 ], [0.17, 0.11, 0.10, 0.18] ]) l = array([1, 0.10]) u = array([1.0, Inf]) xmin = zeros(4) # solution = pips(f_fcn, x0, A, l, u, xmin, opt={'verbose': 2}) solution = pips(f_fcn, x0, A, l, u, xmin) x, f, s, lam, out = solution["x"], solution["f"], solution["eflag"], \ solution["lmbda"], solution["output"] t_is(s, 1, 13, [t, 'success']) t_is(x, array([0, 2.8, 0.2, 0]) / 3, 6, [t, 'x']) t_is(f, 3.29 / 3, 6, [t, 'f']) t_is(out['hist'][-1]['compcond'], 0, 6, [t, 'compcond']) t_is(lam['mu_l'], array([6.58, 0]) / 3, 6, [t, 'lam.mu_l']) t_is(lam['mu_u'], array([0, 0]), 13, [t, 'lam.mu_u']) t_is(lam['lower'], array([2.24, 0, 0, 1.7667]), 4, [t, 'lam[\'lower\']']) t_is(lam['upper'], zeros(x.shape), 13, [t, 'lam[\'upper\']']) # H = array([ # [1003.1, 4.3, 6.3, 5.9], # [ 4.3, 2.2, 2.1, 3.9], # [ 6.3, 2.1, 3.5, 4.8], # [ 5.9, 3.9, 4.8, 10.0] # ]) # c = zeros(4) # ## check with quadprog (for dev testing only) # x, f, s, out, lam = quadprog(H,c,-A(2,:), -0.10, A(1,:), 1, xmin) # t_is(s, 1, 13, [t, 'success']) # t_is(x, [0 2.8 0.2 0]/3, 6, [t, 'x']) # t_is(f, 3.29/3, 6, [t, 'f']) # t_is(lam['eqlin'], -6.58/3, 6, [t, 'lam.eqlin']) # t_is(lam.['ineqlin'], 0, 13, [t, 'lam.ineqlin']) # t_is(lam['lower'], [2.24001.7667], 4, [t, 'lam[\'lower\']']) # t_is(lam['upper'], [0000], 13, [t, 'lam[\'upper\']']) t = 'constrained 2-d nonlinear : ' ## from http://en.wikipedia.org/wiki/Nonlinear_programming#2-dimensional_example f_fcn = f5 gh_fcn = gh5 hess_fcn = hess5 x0 = array([1.1, 0.0]) xmin = zeros(2) # xmax = 3 * ones(2, 1) # solution = pips(f_fcn, x0, xmin=xmin, gh_fcn=gh_fcn, hess_fcn=hess_fcn, opt={'verbose': 2}) solution = pips(f_fcn, x0, xmin=xmin, gh_fcn=gh_fcn, hess_fcn=hess_fcn) x, f, s, lam, out = solution["x"], solution["f"], solution["eflag"], \ solution["lmbda"], solution["output"] t_is(s, 1, 13, [t, 'success']) t_is(x, [1, 1], 6, [t, 'x']) t_is(f, -2, 6, [t, 'f']) t_is(out['hist'][-1]['compcond'], 0, 6, [t, 'compcond']) t_is(lam['ineqnonlin'], array([0, 0.5]), 6, [t, 'lam.ineqnonlin']) t_ok(len(lam['mu_l']) == 0, [t, 'lam.mu_l']) t_ok(len(lam['mu_u']) == 0, [t, 'lam.mu_u']) t_is(lam['lower'], zeros(x.shape), 13, [t, 'lam[\'lower\']']) t_is(lam['upper'], zeros(x.shape), 13, [t, 'lam[\'upper\']']) # ## check with fmincon (for dev testing only) # # fmoptions = optimset('Algorithm', 'interior-point') # # [x, f, s, out, lam] = fmincon(f_fcn, x0, [], [], [], [], xmin, [], gh_fcn, fmoptions) # [x, f, s, out, lam] = fmincon(f_fcn, x0, [], [], [], [], [], [], gh_fcn) # t_is(s, 1, 13, [t, 'success']) # t_is(x, [1 1], 4, [t, 'x']) # t_is(f, -2, 6, [t, 'f']) # t_is(lam.ineqnonlin, [00.5], 6, [t, 'lam.ineqnonlin']) t = 'constrained 3-d nonlinear : ' ## from http://en.wikipedia.org/wiki/Nonlinear_programming#3-dimensional_example f_fcn = f6 gh_fcn = gh6 hess_fcn = hess6 x0 = array([1.0, 1.0, 0.0]) # solution = pips(f_fcn, x0, gh_fcn=gh_fcn, hess_fcn=hess_fcn, opt={'verbose': 2, 'comptol': 1e-9}) solution = pips(f_fcn, x0, gh_fcn=gh_fcn, hess_fcn=hess_fcn) x, f, s, lam, out = solution["x"], solution["f"], solution["eflag"], \ solution["lmbda"], solution["output"] t_is(s, 1, 13, [t, 'success']) t_is(x, [1.58113883, 2.23606798, 1.58113883], 6, [t, 'x']) t_is(f, -5 * sqrt(2), 6, [t, 'f']) t_is(out['hist'][-1]['compcond'], 0, 6, [t, 'compcond']) t_is(lam['ineqnonlin'], array([0, sqrt(2) / 2]), 7, [t, 'lam.ineqnonlin']) t_ok(len(lam['mu_l']) == 0, [t, 'lam.mu_l']) t_ok(len(lam['mu_u']) == 0, [t, 'lam.mu_u']) t_is(lam['lower'], zeros(x.shape), 13, [t, 'lam[\'lower\']']) t_is(lam['upper'], zeros(x.shape), 13, [t, 'lam[\'upper\']']) # ## check with fmincon (for dev testing only) # # fmoptions = optimset('Algorithm', 'interior-point') # # [x, f, s, out, lam] = fmincon(f_fcn, x0, [], [], [], [], xmin, [], gh_fcn, fmoptions) # [x, f, s, out, lam] = fmincon(f_fcn, x0, [], [], [], [], [], [], gh_fcn) # t_is(s, 1, 13, [t, 'success']) # t_is(x, [1.58113883 2.23606798 1.58113883], 4, [t, 'x']) # t_is(f, -5*sqrt(2), 8, [t, 'f']) # t_is(lam.ineqnonlin, [0sqrt(2)/2], 8, [t, 'lam.ineqnonlin']) t = 'constrained 3-d nonlinear (dict) : ' p = {'f_fcn': f_fcn, 'x0': x0, 'gh_fcn': gh_fcn, 'hess_fcn': hess_fcn} solution = pips(p) x, f, s, lam, out = solution["x"], solution["f"], solution["eflag"], \ solution["lmbda"], solution["output"] t_is(s, 1, 13, [t, 'success']) t_is(x, [1.58113883, 2.23606798, 1.58113883], 6, [t, 'x']) t_is(f, -5 * sqrt(2), 6, [t, 'f']) t_is(out['hist'][-1]['compcond'], 0, 6, [t, 'compcond']) t_is(lam['ineqnonlin'], [0, sqrt(2) / 2], 7, [t, 'lam.ineqnonlin']) t_ok(len(lam['mu_l']) == 0, [t, 'lam.mu_l']) t_ok(len(lam['mu_u']) == 0, [t, 'lam.mu_u']) t_is(lam['lower'], zeros(x.shape), 13, [t, 'lam[\'lower\']']) t_is(lam['upper'], zeros(x.shape), 13, [t, 'lam[\'upper\']']) t = 'constrained 4-d nonlinear : ' ## Hock & Schittkowski test problem #71 f_fcn = f7 gh_fcn = gh7 hess_fcn = hess7 x0 = array([1.0, 5.0, 5.0, 1.0]) xmin = ones(4) xmax = 5 * xmin # solution = pips(f_fcn, x0, xmin=xmin, xmax=xmax, gh_fcn=gh_fcn, hess_fcn=hess_fcn, opt={'verbose': 2, 'comptol': 1e-9}) solution = pips(f_fcn, x0, xmin=xmin, xmax=xmax, gh_fcn=gh_fcn, hess_fcn=hess_fcn) x, f, s, lam, _ = solution["x"], solution["f"], solution["eflag"], \ solution["lmbda"], solution["output"] t_is(s, 1, 13, [t, 'success']) t_is(x, [1, 4.7429994, 3.8211503, 1.3794082], 6, [t, 'x']) t_is(f, 17.0140173, 6, [t, 'f']) t_is(lam['eqnonlin'], 0.1614686, 5, [t, 'lam.eqnonlin']) t_is(lam['ineqnonlin'], 0.55229366, 5, [t, 'lam.ineqnonlin']) t_ok(len(lam['mu_l']) == 0, [t, 'lam.mu_l']) t_ok(len(lam['mu_u']) == 0, [t, 'lam.mu_u']) t_is(lam['lower'], [1.08787121024, 0, 0, 0], 5, [t, 'lam[\'lower\']']) t_is(lam['upper'], zeros(x.shape), 7, [t, 'lam[\'upper\']']) t_end()
def t_pips(quiet=False): """Tests of pips NLP solver. @author: Ray Zimmerman (PSERC Cornell) """ t_begin(60, quiet) t = 'unconstrained banana function : ' ## from MATLAB Optimization Toolbox's bandem.m f_fcn = f2 x0 = array([-1.9, 2]) # solution = pips(f_fcn, x0, opt={'verbose': 2}) solution = pips(f_fcn, x0) x, f, s, lam, out = solution["x"], solution["f"], solution["eflag"], \ solution["lmbda"], solution["output"] t_is(s, 1, 13, [t, 'success']) t_is(x, [1, 1], 13, [t, 'x']) t_is(f, 0, 13, [t, 'f']) t_is(out['hist'][-1]['compcond'], 0, 6, [t, 'compcond']) t_ok(len(lam['mu_l']) == 0, [t, 'lam.mu_l']) t_ok(len(lam['mu_u']) == 0, [t, 'lam.mu_u']) t_is(lam['lower'], zeros(x.shape), 13, [t, 'lam[\'lower\']']) t_is(lam['upper'], zeros(x.shape), 13, [t, 'lam[\'upper\']']) t = 'unconstrained 3-d quadratic : ' ## from http://www.akiti.ca/QuadProgEx0Constr.html f_fcn = f3 x0 = array([0, 0, 0], float) # solution = pips(f_fcn, x0, opt={'verbose': 2}) solution = pips(f_fcn, x0) x, f, s, lam, out = solution["x"], solution["f"], solution["eflag"], \ solution["lmbda"], solution["output"] t_is(s, 1, 13, [t, 'success']) t_is(x, [3, 5, 7], 13, [t, 'x']) t_is(f, -244, 13, [t, 'f']) t_is(out['hist'][-1]['compcond'], 0, 6, [t, 'compcond']) t_ok(len(lam['mu_l']) == 0, [t, 'lam.mu_l']) t_ok(len(lam['mu_u']) == 0, [t, 'lam.mu_u']) t_is(lam['lower'], zeros(x.shape), 13, [t, 'lam[\'lower\']']) t_is(lam['upper'], zeros(x.shape), 13, [t, 'lam[\'upper\']']) t = 'constrained 4-d QP : ' ## from http://www.jmu.edu/docs/sasdoc/sashtml/iml/chap8/sect12.htm f_fcn = f4 x0 = array([1.0, 0.0, 0.0, 1.0]) A = array([[1.0, 1.0, 1.0, 1.0], [0.17, 0.11, 0.10, 0.18]]) l = array([1, 0.10]) u = array([1.0, Inf]) xmin = zeros(4) # solution = pips(f_fcn, x0, A, l, u, xmin, opt={'verbose': 2}) solution = pips(f_fcn, x0, A, l, u, xmin) x, f, s, lam, out = solution["x"], solution["f"], solution["eflag"], \ solution["lmbda"], solution["output"] t_is(s, 1, 13, [t, 'success']) t_is(x, array([0, 2.8, 0.2, 0]) / 3, 6, [t, 'x']) t_is(f, 3.29 / 3, 6, [t, 'f']) t_is(out['hist'][-1]['compcond'], 0, 6, [t, 'compcond']) t_is(lam['mu_l'], array([6.58, 0]) / 3, 6, [t, 'lam.mu_l']) t_is(lam['mu_u'], array([0, 0]), 13, [t, 'lam.mu_u']) t_is(lam['lower'], array([2.24, 0, 0, 1.7667]), 4, [t, 'lam[\'lower\']']) t_is(lam['upper'], zeros(x.shape), 13, [t, 'lam[\'upper\']']) # H = array([ # [1003.1, 4.3, 6.3, 5.9], # [ 4.3, 2.2, 2.1, 3.9], # [ 6.3, 2.1, 3.5, 4.8], # [ 5.9, 3.9, 4.8, 10.0] # ]) # c = zeros(4) # ## check with quadprog (for dev testing only) # x, f, s, out, lam = quadprog(H,c,-A(2,:), -0.10, A(1,:), 1, xmin) # t_is(s, 1, 13, [t, 'success']) # t_is(x, [0 2.8 0.2 0]/3, 6, [t, 'x']) # t_is(f, 3.29/3, 6, [t, 'f']) # t_is(lam['eqlin'], -6.58/3, 6, [t, 'lam.eqlin']) # t_is(lam.['ineqlin'], 0, 13, [t, 'lam.ineqlin']) # t_is(lam['lower'], [2.24001.7667], 4, [t, 'lam[\'lower\']']) # t_is(lam['upper'], [0000], 13, [t, 'lam[\'upper\']']) t = 'constrained 2-d nonlinear : ' ## from http://en.wikipedia.org/wiki/Nonlinear_programming#2-dimensional_example f_fcn = f5 gh_fcn = gh5 hess_fcn = hess5 x0 = array([1.1, 0.0]) xmin = zeros(2) # xmax = 3 * ones(2, 1) # solution = pips(f_fcn, x0, xmin=xmin, gh_fcn=gh_fcn, hess_fcn=hess_fcn, opt={'verbose': 2}) solution = pips(f_fcn, x0, xmin=xmin, gh_fcn=gh_fcn, hess_fcn=hess_fcn) x, f, s, lam, out = solution["x"], solution["f"], solution["eflag"], \ solution["lmbda"], solution["output"] t_is(s, 1, 13, [t, 'success']) t_is(x, [1, 1], 6, [t, 'x']) t_is(f, -2, 6, [t, 'f']) t_is(out['hist'][-1]['compcond'], 0, 6, [t, 'compcond']) t_is(lam['ineqnonlin'], array([0, 0.5]), 6, [t, 'lam.ineqnonlin']) t_ok(len(lam['mu_l']) == 0, [t, 'lam.mu_l']) t_ok(len(lam['mu_u']) == 0, [t, 'lam.mu_u']) t_is(lam['lower'], zeros(x.shape), 13, [t, 'lam[\'lower\']']) t_is(lam['upper'], zeros(x.shape), 13, [t, 'lam[\'upper\']']) # ## check with fmincon (for dev testing only) # # fmoptions = optimset('Algorithm', 'interior-point') # # [x, f, s, out, lam] = fmincon(f_fcn, x0, [], [], [], [], xmin, [], gh_fcn, fmoptions) # [x, f, s, out, lam] = fmincon(f_fcn, x0, [], [], [], [], [], [], gh_fcn) # t_is(s, 1, 13, [t, 'success']) # t_is(x, [1 1], 4, [t, 'x']) # t_is(f, -2, 6, [t, 'f']) # t_is(lam.ineqnonlin, [00.5], 6, [t, 'lam.ineqnonlin']) t = 'constrained 3-d nonlinear : ' ## from http://en.wikipedia.org/wiki/Nonlinear_programming#3-dimensional_example f_fcn = f6 gh_fcn = gh6 hess_fcn = hess6 x0 = array([1.0, 1.0, 0.0]) # solution = pips(f_fcn, x0, gh_fcn=gh_fcn, hess_fcn=hess_fcn, opt={'verbose': 2, 'comptol': 1e-9}) solution = pips(f_fcn, x0, gh_fcn=gh_fcn, hess_fcn=hess_fcn) x, f, s, lam, out = solution["x"], solution["f"], solution["eflag"], \ solution["lmbda"], solution["output"] t_is(s, 1, 13, [t, 'success']) t_is(x, [1.58113883, 2.23606798, 1.58113883], 6, [t, 'x']) t_is(f, -5 * sqrt(2), 6, [t, 'f']) t_is(out['hist'][-1]['compcond'], 0, 6, [t, 'compcond']) t_is(lam['ineqnonlin'], array([0, sqrt(2) / 2]), 7, [t, 'lam.ineqnonlin']) t_ok(len(lam['mu_l']) == 0, [t, 'lam.mu_l']) t_ok(len(lam['mu_u']) == 0, [t, 'lam.mu_u']) t_is(lam['lower'], zeros(x.shape), 13, [t, 'lam[\'lower\']']) t_is(lam['upper'], zeros(x.shape), 13, [t, 'lam[\'upper\']']) # ## check with fmincon (for dev testing only) # # fmoptions = optimset('Algorithm', 'interior-point') # # [x, f, s, out, lam] = fmincon(f_fcn, x0, [], [], [], [], xmin, [], gh_fcn, fmoptions) # [x, f, s, out, lam] = fmincon(f_fcn, x0, [], [], [], [], [], [], gh_fcn) # t_is(s, 1, 13, [t, 'success']) # t_is(x, [1.58113883 2.23606798 1.58113883], 4, [t, 'x']) # t_is(f, -5*sqrt(2), 8, [t, 'f']) # t_is(lam.ineqnonlin, [0sqrt(2)/2], 8, [t, 'lam.ineqnonlin']) t = 'constrained 3-d nonlinear (dict) : ' p = {'f_fcn': f_fcn, 'x0': x0, 'gh_fcn': gh_fcn, 'hess_fcn': hess_fcn} solution = pips(p) x, f, s, lam, out = solution["x"], solution["f"], solution["eflag"], \ solution["lmbda"], solution["output"] t_is(s, 1, 13, [t, 'success']) t_is(x, [1.58113883, 2.23606798, 1.58113883], 6, [t, 'x']) t_is(f, -5 * sqrt(2), 6, [t, 'f']) t_is(out['hist'][-1]['compcond'], 0, 6, [t, 'compcond']) t_is(lam['ineqnonlin'], [0, sqrt(2) / 2], 7, [t, 'lam.ineqnonlin']) t_ok(len(lam['mu_l']) == 0, [t, 'lam.mu_l']) t_ok(len(lam['mu_u']) == 0, [t, 'lam.mu_u']) t_is(lam['lower'], zeros(x.shape), 13, [t, 'lam[\'lower\']']) t_is(lam['upper'], zeros(x.shape), 13, [t, 'lam[\'upper\']']) t = 'constrained 4-d nonlinear : ' ## Hock & Schittkowski test problem #71 f_fcn = f7 gh_fcn = gh7 hess_fcn = hess7 x0 = array([1.0, 5.0, 5.0, 1.0]) xmin = ones(4) xmax = 5 * xmin # solution = pips(f_fcn, x0, xmin=xmin, xmax=xmax, gh_fcn=gh_fcn, hess_fcn=hess_fcn, opt={'verbose': 2, 'comptol': 1e-9}) solution = pips(f_fcn, x0, xmin=xmin, xmax=xmax, gh_fcn=gh_fcn, hess_fcn=hess_fcn) x, f, s, lam, _ = solution["x"], solution["f"], solution["eflag"], \ solution["lmbda"], solution["output"] t_is(s, 1, 13, [t, 'success']) t_is(x, [1, 4.7429994, 3.8211503, 1.3794082], 6, [t, 'x']) t_is(f, 17.0140173, 6, [t, 'f']) t_is(lam['eqnonlin'], 0.1614686, 5, [t, 'lam.eqnonlin']) t_is(lam['ineqnonlin'], 0.55229366, 5, [t, 'lam.ineqnonlin']) t_ok(len(lam['mu_l']) == 0, [t, 'lam.mu_l']) t_ok(len(lam['mu_u']) == 0, [t, 'lam.mu_u']) t_is(lam['lower'], [1.08787121024, 0, 0, 0], 5, [t, 'lam[\'lower\']']) t_is(lam['upper'], zeros(x.shape), 7, [t, 'lam[\'upper\']']) t_end()
def t_pf(quiet=False): """Tests for power flow solvers. @author: Ray Zimmerman (PSERC Cornell) """ t_begin(33, quiet) tdir = dirname(__file__) casefile = join(tdir, 't_case9_pf') verbose = not quiet ppopt = ppoption(VERBOSE=verbose, OUT_ALL=0) ## get solved AC power flow case from MAT-file ## defines bus_soln, gen_soln, branch_soln soln9_pf = loadmat(join(tdir, 'soln9_pf.mat'), struct_as_record=False) bus_soln = soln9_pf['bus_soln'] gen_soln = soln9_pf['gen_soln'] branch_soln = soln9_pf['branch_soln'] ## run Newton PF t = 'Newton PF : '; ppopt = ppoption(ppopt, PF_ALG=1) results, success = runpf(casefile, ppopt) bus, gen, branch = results['bus'], results['gen'], results['branch'] t_ok(success, [t, 'success']) t_is(bus, bus_soln, 6, [t, 'bus']) t_is(gen, gen_soln, 6, [t, 'gen']) t_is(branch, branch_soln, 6, [t, 'branch']) ## run fast-decoupled PF (XB version) t = 'Fast Decoupled (XB) PF : '; ppopt = ppoption(ppopt, PF_ALG=2) results, success = runpf(casefile, ppopt) bus, gen, branch = results['bus'], results['gen'], results['branch'] t_ok(success, [t, 'success']) t_is(bus, bus_soln, 6, [t, 'bus']) t_is(gen, gen_soln, 6, [t, 'gen']) t_is(branch, branch_soln, 6, [t, 'branch']) ## run fast-decoupled PF (BX version) t = 'Fast Decoupled (BX) PF : '; ppopt = ppoption(ppopt, PF_ALG=3) results, success = runpf(casefile, ppopt) bus, gen, branch = results['bus'], results['gen'], results['branch'] t_ok(success, [t, 'success']) t_is(bus, bus_soln, 6, [t, 'bus']) t_is(gen, gen_soln, 6, [t, 'gen']) t_is(branch, branch_soln, 6, [t, 'branch']) ## run Gauss-Seidel PF t = 'Gauss-Seidel PF : '; ppopt = ppoption(ppopt, PF_ALG=4) results, success = runpf(casefile, ppopt) bus, gen, branch = results['bus'], results['gen'], results['branch'] t_ok(success, [t, 'success']) t_is(bus, bus_soln, 5, [t, 'bus']) t_is(gen, gen_soln, 5, [t, 'gen']) t_is(branch, branch_soln, 5, [t, 'branch']) ## get solved AC power flow case from MAT-file ## defines bus_soln, gen_soln, branch_soln soln9_dcpf = loadmat(join(tdir, 'soln9_dcpf.mat'), struct_as_record=False) bus_soln = soln9_dcpf['bus_soln'] gen_soln = soln9_dcpf['gen_soln'] branch_soln = soln9_dcpf['branch_soln'] ## run DC PF t = 'DC PF : ' results, success = rundcpf(casefile, ppopt) bus, gen, branch = results['bus'], results['gen'], results['branch'] t_ok(success, [t, 'success']) t_is(bus, bus_soln, 6, [t, 'bus']) t_is(gen, gen_soln, 6, [t, 'gen']) t_is(branch, branch_soln, 6, [t, 'branch']) ## check Qg distribution, when Qmin = Qmax t = 'check Qg : ' ppopt = ppoption(ppopt, PF_ALG=1, VERBOSE=0) ppc = loadcase(casefile) ppc['gen'][0, [QMIN, QMAX]] = [20, 20] results, success = runpf(ppc, ppopt) bus, gen, branch = results['bus'], results['gen'], results['branch'] t_is(gen[0, QG], 24.07, 2, [t, 'single gen, Qmin = Qmax']) ppc['gen'] = r_[array([ ppc['gen'][0, :] ]), ppc['gen']] ppc['gen'][0, [QMIN, QMAX]] = [10, 10] ppc['gen'][1, [QMIN, QMAX]] = [ 0, 50] results, success = runpf(ppc, ppopt) bus, gen, branch = results['bus'], results['gen'], results['branch'] t_is(gen[0:2, QG], [10, 14.07], 2, [t, '2 gens, Qmin = Qmax for one']) ppc['gen'][0, [QMIN, QMAX]] = [10, 10] ppc['gen'][1, [QMIN, QMAX]] = [-50, -50] results, success = runpf(ppc, ppopt) bus, gen, branch = results['bus'], results['gen'], results['branch'] t_is(gen[0:2, QG], [12.03, 12.03], 2, [t, '2 gens, Qmin = Qmax for both']) ppc['gen'][0, [QMIN, QMAX]] = [0, 50] ppc['gen'][1, [QMIN, QMAX]] = [0, 100] results, success = runpf(ppc, ppopt) bus, gen, branch = results['bus'], results['gen'], results['branch'] t_is(gen[0:2, QG], [8.02, 16.05], 2, [t, '2 gens, proportional']) ppc['gen'][0, [QMIN, QMAX]] = [-50, 0] ppc['gen'][1, [QMIN, QMAX]] = [50, 150] results, success = runpf(ppc, ppopt) bus, gen, branch = results['bus'], results['gen'], results['branch'] t_is(gen[0:2, QG], [-50 + 8.02, 50 + 16.05], 2, [t, '2 gens, proportional']) ## network with islands t = 'network w/islands : DC PF : ' ppc0 = loadcase(casefile) ppc0['gen'][0, PG] = 60 ppc0['gen'][0, [PMIN, PMAX, QMIN, QMAX, PG, QG]] = \ ppc0['gen'][0, [PMIN, PMAX, QMIN, QMAX, PG, QG]] / 2 ppc0['gen'] = r_[array([ ppc0['gen'][0, :] ]), ppc0['gen']] ppc1 = ppc0.copy() ppc = ppc0.copy() nb = ppc['bus'].shape[0] ppc1['bus'][:, BUS_I] = ppc1['bus'][:, BUS_I] + nb ppc1['branch'][:, F_BUS] = ppc1['branch'][:, F_BUS] + nb ppc1['branch'][:, T_BUS] = ppc1['branch'][:, T_BUS] + nb ppc1['gen'][:, GEN_BUS] = ppc1['gen'][:, GEN_BUS] + nb ppc['bus'] = r_[ppc['bus'], ppc1['bus']] ppc['branch'] = r_[ppc['branch'], ppc1['branch']] ppc['gen'] = r_[ppc['gen'], ppc1['gen']] #ppopt = ppoption(ppopt, OUT_BUS=1, OUT_GEN=1, OUT_ALL=-1, VERBOSE=2) ppopt = ppoption(ppopt, VERBOSE=verbose) r = rundcpf(ppc, ppopt) t_is(r['bus'][ :9, VA], bus_soln[:, VA], 8, [t, 'voltage angles 1']) t_is(r['bus'][10:18, VA], bus_soln[:, VA], 8, [t, 'voltage angles 2']) Pg = r_[gen_soln[0, PG] - 30, 30, gen_soln[1:3, PG]] t_is(r['gen'][ :4, PG], Pg, 8, [t, 'active power generation 1']) t_is(r['gen'][4:8, PG], Pg, 8, [t, 'active power generation 1']) t = 'network w/islands : AC PF : ' ## get solved AC power flow case from MAT-file soln9_pf = loadmat(join(tdir, 'soln9_pf.mat'), struct_as_record=False) bus_soln = soln9_pf['bus_soln'] gen_soln = soln9_pf['gen_soln'] branch_soln = soln9_pf['branch_soln'] r = runpf(ppc, ppopt) t_is(r['bus'][ :9, VA], bus_soln[:, VA], 8, [t, 'voltage angles 1']) t_is(r['bus'][9:18, VA], bus_soln[:, VA], 8, [t, 'voltage angles 2']) Pg = r_[gen_soln[0, PG] - 30, 30, gen_soln[1:3, PG]] t_is(r['gen'][ :4, PG], Pg, 8, [t, 'active power generation 1']) t_is(r['gen'][4:8, PG], Pg, 8, [t, 'active power generation 1']) t_end()
t_is(sum(bus[a[k], PD]), load[k] / area[k]['both']['p'] * area[k]['fixed']['p'], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) t_is(-sum(gen[lda[k], PMIN]), load[k] / area[k]['both']['p'] * area[k]['disp']['p'], 8, '%s area %d disp P' % (t, k)) t_is(-sum(gen[lda[k], QMIN]), area[k]['disp']['qmin'], 8, '%s area %d disp Qmin' % (t, k)) t_is(-sum(gen[lda[k], QMAX]), area[k]['disp']['qmax'], 8, '%s area %d disp Qmax' % (t, k)) t = 'area disp loads (PQ) => total = [100 80 60] : throws expected exception' load = array([100, 80, 60], float) opt = {'scale': 'QUANTITY', 'which': 'DISPATCHABLE'} err = 0 try: bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) except ScalingError, e: expected = 'scale_load: impossible to make zone 2 load equal 80 by scaling non-existent dispatchable load' err = expected not in str(e) t_ok(err, t) t = 'area disp loads (PQ) => total = [100 74.3941 60] : ' load = array([100, area[1]['fixed']['p'], 60], float) opt = {'scale': 'QUANTITY', 'which': 'DISPATCHABLE'} bus, gen = scale_load(load, ppc['bus'], ppc['gen'], None, opt) for k in range(len(load)): t_is(sum(bus[a[k], PD]), area[k]['fixed']['p'], 8, '%s area %d fixed P' % (t, k)) t_is(sum(bus[a[k], QD]), area[k]['fixed']['q'], 8, '%s area %d fixed Q' % (t, k)) t_is(-sum(gen[lda[k], PMIN]), load[k]-area[k]['fixed']['p'], 8, '%s area %d disp P' % (t, k)) if k == 1: t_is(-sum(gen[lda[k], QMIN]), area[k]['disp']['qmin'], 8, '%s area %d disp Qmin' % (t, k)) t_is(-sum(gen[lda[k], QMAX]), area[k]['disp']['qmax'], 8, '%s area %d disp Qmax' % (t, k)) else: t_is(-sum(gen[lda[k], QMIN]), (load[k] - area[k]['fixed']['p']) / area[k]['disp']['p'] * area[k]['disp']['qmin'], 8, '%s area %d disp Qmin' % (t, k)) t_is(-sum(gen[lda[k], QMAX]), (load[k] - area[k]['fixed']['p']) / area[k]['disp']['p'] * area[k]['disp']['qmax'], 8, '%s area %d disp Qmax' % (t, k))