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))