def totcost(gencost, Pg):
"""Computes total cost for generators at given output level.
Computes total cost for generators given a matrix in gencost format and
a column vector or matrix of generation levels. The return value has the
same dimensions as PG. Each row of C{gencost} is used to evaluate the
cost at the points specified in the corresponding row of C{Pg}.
@author: Ray Zimmerman (PSERC Cornell)
@author: Carlos E. Murillo-Sanchez (PSERC Cornell & Universidad
Autonoma de Manizales)
@author: Richard Lincoln
"""
ng, m = gencost.shape
totalcost = zeros(ng)
if len(gencost) > 0:
ipwl = find(gencost[:, MODEL] == PW_LINEAR)
ipol = find(gencost[:, MODEL] == POLYNOMIAL)
if len(ipwl) > 0:
p = gencost[:, COST:(m-1):2]
c = gencost[:, (COST+1):m:2]
for i in ipwl:
ncost = gencost[i, NCOST]
for k in arange(ncost - 1):
p1, p2 = p[i, k], p[i, k+1]
c1, c2 = c[i, k], c[i, k+1]
m = (c2 - c1) / (p2 - p1)
b = c1 - m * p1
Pgen = Pg[i]
if Pgen < p2:
totalcost[i] = m * Pgen + b
break
totalcost[i] = m * Pgen + b
if len(ipol) > 0:
totalcost[ipol] = polycost(gencost[ipol, :], Pg[ipol])
return totalcost
def totcost(gencost, Pg):
"""Computes total cost for generators at given output level.
Computes total cost for generators given a matrix in gencost format and
a column vector or matrix of generation levels. The return value has the
same dimensions as PG. Each row of C{gencost} is used to evaluate the
cost at the points specified in the corresponding row of C{Pg}.
@author: Ray Zimmerman (PSERC Cornell)
@author: Carlos E. Murillo-Sanchez (PSERC Cornell & Universidad
Autonoma de Manizales)
@author: Richard Lincoln
"""
ng, m = gencost.shape
totalcost = zeros(ng)
if len(gencost) > 0:
ipwl = find(gencost[:, MODEL] == PW_LINEAR)
ipol = find(gencost[:, MODEL] == POLYNOMIAL)
if len(ipwl) > 0:
p = gencost[:, COST:(m-1):2]
c = gencost[:, (COST+1):m:2]
for i in ipwl:
ncost = gencost[i, NCOST]
for k in arange(ncost - 1):
p1, p2 = p[i, k], p[i, k+1]
c1, c2 = c[i, k], c[i, k+1]
m = (c2 - c1) / (p2 - p1)
b = c1 - m * p1
Pgen = Pg[i]
if Pgen < p2:
totalcost[i] = m * Pgen + b
break
totalcost[i] = m * Pgen + b
if len(ipol) > 0:
totalcost[ipol] = polycost(gencost[ipol, :], Pg[ipol])
return totalcost
def opf_costfcn(x, om, return_hessian=False):
"""Evaluates objective function, gradient and Hessian for OPF.
Objective function evaluation routine for AC optimal power flow,
suitable for use with L{pips}. Computes objective function value,
gradient and Hessian.
@param x: optimization vector
@param om: OPF model object
@return: C{F} - value of objective function. C{df} - (optional) gradient
of objective function (column vector). C{d2f} - (optional) Hessian of
objective function (sparse matrix).
@see: L{opf_consfcn}, L{opf_hessfcn}
@author: Carlos E. Murillo-Sanchez (PSERC Cornell & Universidad
Autonoma de Manizales)
@author: Ray Zimmerman (PSERC Cornell)
"""
##----- initialize -----
## unpack data
ppc = om.get_ppc()
baseMVA, gen, gencost = ppc["baseMVA"], ppc["gen"], ppc["gencost"]
cp = om.get_cost_params()
N, Cw, H, dd, rh, kk, mm = \
cp["N"], cp["Cw"], cp["H"], cp["dd"], cp["rh"], cp["kk"], cp["mm"]
vv, _, _, _ = om.get_idx()
## problem dimensions
ng = gen.shape[0] ## number of dispatchable injections
ny = om.getN('var', 'y') ## number of piece-wise linear costs
nxyz = len(x) ## total number of control vars of all types
## grab Pg & Qg
Pg = x[vv["i1"]["Pg"]:vv["iN"]["Pg"]] ## active generation in p.u.
Qg = x[vv["i1"]["Qg"]:vv["iN"]["Qg"]] ## reactive generation in p.u.
##----- evaluate objective function -----
## polynomial cost of P and Q
# use totcost only on polynomial cost in the minimization problem
# formulation, pwl cost is the sum of the y variables.
ipol = find(gencost[:, MODEL] == POLYNOMIAL) ## poly MW and MVAr costs
xx = r_[Pg, Qg] * baseMVA
if any(ipol):
f = sum(totcost(gencost[ipol, :], xx[ipol])) ## cost of poly P or Q
else:
f = 0
## piecewise linear cost of P and Q
if ny > 0:
ccost = sparse(
(ones(ny), (zeros(ny), arange(vv["i1"]["y"], vv["iN"]["y"]))),
(1, nxyz)).toarray().flatten()
f = f + dot(ccost, x)
else:
ccost = zeros(nxyz)
## generalized cost term
if issparse(N) and N.nnz > 0:
nw = N.shape[0]
r = N * x - rh ## Nx - rhat
iLT = find(r < -kk) ## below dead zone
iEQ = find((r == 0) & (kk == 0)) ## dead zone doesn't exist
iGT = find(r > kk) ## above dead zone
iND = r_[iLT, iEQ, iGT] ## rows that are Not in the Dead region
iL = find(dd == 1) ## rows using linear function
iQ = find(dd == 2) ## rows using quadratic function
LL = sparse((ones(len(iL)), (iL, iL)), (nw, nw))
QQ = sparse((ones(len(iQ)), (iQ, iQ)), (nw, nw))
kbar = sparse((r_[ones(len(iLT)),
zeros(len(iEQ)), -ones(len(iGT))], (iND, iND)),
(nw, nw)) * kk
rr = r + kbar ## apply non-dead zone shift
M = sparse((mm[iND], (iND, iND)), (nw, nw)) ## dead zone or scale
diagrr = sparse((rr, (arange(nw), arange(nw))), (nw, nw))
## linear rows multiplied by rr(i), quadratic rows by rr(i)^2
w = M * (LL + QQ * diagrr) * rr
f = f + dot(w * H, w) / 2 + dot(Cw, w)
##----- evaluate cost gradient -----
## index ranges
iPg = list(range(vv["i1"]["Pg"], vv["iN"]["Pg"]))
iQg = list(range(vv["i1"]["Qg"], vv["iN"]["Qg"]))
## polynomial cost of P and Q
df_dPgQg = zeros(2 * ng) ## w.r.t p.u. Pg and Qg
df_dPgQg[ipol] = baseMVA * polycost(gencost[ipol, :], xx[ipol], 1)
df = zeros(nxyz)
df[iPg] = df_dPgQg[:ng]
df[iQg] = df_dPgQg[ng:ng + ng]
## piecewise linear cost of P and Q
df = df + ccost # The linear cost row is additive wrt any nonlinear cost.
## generalized cost term
if issparse(N) and N.nnz > 0:
HwC = H * w + Cw
AA = N.T * M * (LL + 2 * QQ * diagrr)
df = df + AA * HwC
## numerical check
if 0: ## 1 to check, 0 to skip check
ddff = zeros(df.shape)
step = 1e-7
tol = 1e-3
for k in range(len(x)):
xx = x
xx[k] = xx[k] + step
ddff[k] = (opf_costfcn(xx, om) - f) / step
if max(abs(ddff - df)) > tol:
idx = find(abs(ddff - df) == max(abs(ddff - df)))
print('Mismatch in gradient')
print('idx df(num) df diff')
print(('%4d%16g%16g%16g' %
(list(range(len(df))), ddff.T, df.T, abs(ddff - df).T)))
print('MAX')
print(('%4d%16g%16g%16g' % (idx.T, ddff[idx].T, df[idx].T,
abs(ddff[idx] - df[idx]).T)))
if not return_hessian:
return f, df
## ---- evaluate cost Hessian -----
pcost = gencost[list(range(ng)), :]
if gencost.shape[0] > ng:
qcost = gencost[ng + 1:2 * ng, :]
else:
qcost = array([])
## polynomial generator costs
d2f_dPg2 = zeros(ng) ## w.r.t. p.u. Pg
d2f_dQg2 = zeros(ng) ## w.r.t. p.u. Qg
ipolp = find(pcost[:, MODEL] == POLYNOMIAL)
d2f_dPg2[ipolp] = \
baseMVA**2 * polycost(pcost[ipolp, :], Pg[ipolp]*baseMVA, 2)
if any(qcost): ## Qg is not free
ipolq = find(qcost[:, MODEL] == POLYNOMIAL)
d2f_dQg2[ipolq] = \
baseMVA**2 * polycost(qcost[ipolq, :], Qg[ipolq] * baseMVA, 2)
i = r_[iPg, iQg].T
d2f = sparse((r_[d2f_dPg2, d2f_dQg2], (i, i)), (nxyz, nxyz))
## generalized cost
if N is not None and issparse(N):
d2f = d2f + AA * H * AA.T + 2 * N.T * M * QQ * \
sparse((HwC, (list(range(nw)), list(range(nw)))), (nw, nw)) * N
return f, df, d2f
def opf_hessfcn(x, lmbda, om, Ybus, Yf, Yt, ppopt, il=None, cost_mult=1.0):
"""Evaluates Hessian of Lagrangian for AC OPF.
Hessian evaluation function for AC optimal power flow, suitable
for use with L{pips}.
Examples::
Lxx = opf_hessfcn(x, lmbda, om, Ybus, Yf, Yt, ppopt)
Lxx = opf_hessfcn(x, lmbda, om, Ybus, Yf, Yt, ppopt, il)
Lxx = opf_hessfcn(x, lmbda, om, Ybus, Yf, Yt, ppopt, il, cost_mult)
@param x: optimization vector
@param lmbda: C{eqnonlin} - Lagrange multipliers on power balance
equations. C{ineqnonlin} - Kuhn-Tucker multipliers on constrained
branch flows.
@param om: OPF model object
@param Ybus: bus admittance matrix
@param Yf: admittance matrix for "from" end of constrained branches
@param Yt: admittance matrix for "to" end of constrained branches
@param ppopt: PYPOWER options vector
@param il: (optional) vector of branch indices corresponding to
branches with flow limits (all others are assumed to be unconstrained).
The default is C{range(nl)} (all branches). C{Yf} and C{Yt} contain
only the rows corresponding to C{il}.
@param cost_mult: (optional) Scale factor to be applied to the cost
(default = 1).
@return: Hessian of the Lagrangian.
@see: L{opf_costfcn}, L{opf_consfcn}
@author: Ray Zimmerman (PSERC Cornell)
@author: Carlos E. Murillo-Sanchez (PSERC Cornell & Universidad
Autonoma de Manizales)
"""
##----- initialize -----
## unpack data
ppc = om.get_ppc()
baseMVA, bus, gen, branch, gencost = \
ppc["baseMVA"], ppc["bus"], ppc["gen"], ppc["branch"], ppc["gencost"]
cp = om.get_cost_params()
N, Cw, H, dd, rh, kk, mm = \
cp["N"], cp["Cw"], cp["H"], cp["dd"], cp["rh"], cp["kk"], cp["mm"]
vv, _, _, _ = om.get_idx()
## unpack needed parameters
nb = bus.shape[0] ## number of buses
nl = branch.shape[0] ## number of branches
ng = gen.shape[0] ## number of dispatchable injections
nxyz = len(x) ## total number of control vars of all types
## set default constrained lines
if il is None:
il = arange(nl) ## all lines have limits by default
nl2 = len(il) ## number of constrained lines
## grab Pg & Qg
Pg = x[vv["i1"]["Pg"]:vv["iN"]["Pg"]] ## active generation in p.u.
Qg = x[vv["i1"]["Qg"]:vv["iN"]["Qg"]] ## reactive generation in p.u.
## put Pg & Qg back in gen
gen[:, PG] = Pg * baseMVA ## active generation in MW
gen[:, QG] = Qg * baseMVA ## reactive generation in MVAr
## reconstruct V
Va = x[vv["i1"]["Va"]:vv["iN"]["Va"]]
Vm = x[vv["i1"]["Vm"]:vv["iN"]["Vm"]]
V = Vm * exp(1j * Va)
nxtra = nxyz - 2 * nb
pcost = gencost[arange(ng), :]
if gencost.shape[0] > ng:
qcost = gencost[arange(ng, 2 * ng), :]
else:
qcost = array([])
## ----- evaluate d2f -----
d2f_dPg2 = zeros(ng) #sparse((ng, 1)) ## w.r.t. p.u. Pg
d2f_dQg2 = zeros(ng) #sparse((ng, 1)) ## w.r.t. p.u. Qg
ipolp = find(pcost[:, MODEL] == POLYNOMIAL)
d2f_dPg2[ipolp] = \
baseMVA**2 * polycost(pcost[ipolp, :], Pg[ipolp] * baseMVA, 2)
if any(qcost): ## Qg is not free
ipolq = find(qcost[:, MODEL] == POLYNOMIAL)
d2f_dQg2[ipolq] = \
baseMVA**2 * polycost(qcost[ipolq, :], Qg[ipolq] * baseMVA, 2)
i = r_[arange(vv["i1"]["Pg"], vv["iN"]["Pg"]),
arange(vv["i1"]["Qg"], vv["iN"]["Qg"])]
# d2f = sparse((vstack([d2f_dPg2, d2f_dQg2]).toarray().flatten(),
# (i, i)), shape=(nxyz, nxyz))
d2f = sparse((r_[d2f_dPg2, d2f_dQg2], (i, i)), (nxyz, nxyz))
## generalized cost
if issparse(N) and N.nnz > 0:
nw = N.shape[0]
r = N * x - rh ## Nx - rhat
iLT = find(r < -kk) ## below dead zone
iEQ = find((r == 0) & (kk == 0)) ## dead zone doesn't exist
iGT = find(r > kk) ## above dead zone
iND = r_[iLT, iEQ, iGT] ## rows that are Not in the Dead region
iL = find(dd == 1) ## rows using linear function
iQ = find(dd == 2) ## rows using quadratic function
LL = sparse((ones(len(iL)), (iL, iL)), (nw, nw))
QQ = sparse((ones(len(iQ)), (iQ, iQ)), (nw, nw))
kbar = sparse((r_[ones(len(iLT)),
zeros(len(iEQ)), -ones(len(iGT))], (iND, iND)),
(nw, nw)) * kk
rr = r + kbar ## apply non-dead zone shift
M = sparse((mm[iND], (iND, iND)), (nw, nw)) ## dead zone or scale
diagrr = sparse((rr, (arange(nw), arange(nw))), (nw, nw))
## linear rows multiplied by rr(i), quadratic rows by rr(i)^2
w = M * (LL + QQ * diagrr) * rr
HwC = H * w + Cw
AA = N.T * M * (LL + 2 * QQ * diagrr)
d2f = d2f + AA * H * AA.T + 2 * N.T * M * QQ * \
sparse((HwC, (arange(nw), arange(nw))), (nw, nw)) * N
d2f = d2f * cost_mult
##----- evaluate Hessian of power balance constraints -----
nlam = len(lmbda["eqnonlin"]) / 2
lamP = lmbda["eqnonlin"][:nlam]
lamQ = lmbda["eqnonlin"][nlam:nlam + nlam]
Gpaa, Gpav, Gpva, Gpvv = d2Sbus_dV2(Ybus, V, lamP)
Gqaa, Gqav, Gqva, Gqvv = d2Sbus_dV2(Ybus, V, lamQ)
d2G = vstack([
hstack([
vstack([hstack([Gpaa, Gpav]),
hstack([Gpva, Gpvv])]).real +
vstack([hstack([Gqaa, Gqav]),
hstack([Gqva, Gqvv])]).imag,
sparse((2 * nb, nxtra))
]),
hstack([sparse(
(nxtra, 2 * nb)), sparse((nxtra, nxtra))])
], "csr")
##----- evaluate Hessian of flow constraints -----
nmu = len(lmbda["ineqnonlin"]) / 2
muF = lmbda["ineqnonlin"][:nmu]
muT = lmbda["ineqnonlin"][nmu:nmu + nmu]
if ppopt['OPF_FLOW_LIM'] == 2: ## current
dIf_dVa, dIf_dVm, dIt_dVa, dIt_dVm, If, It = dIbr_dV(branch, Yf, Yt, V)
Hfaa, Hfav, Hfva, Hfvv = d2AIbr_dV2(dIf_dVa, dIf_dVm, If, Yf, V, muF)
Htaa, Htav, Htva, Htvv = d2AIbr_dV2(dIt_dVa, dIt_dVm, It, Yt, V, muT)
else:
f = branch[il, F_BUS].astype(int) ## list of "from" buses
t = branch[il, T_BUS].astype(int) ## list of "to" buses
## connection matrix for line & from buses
Cf = sparse((ones(nl2), (arange(nl2), f)), (nl2, nb))
## connection matrix for line & to buses
Ct = sparse((ones(nl2), (arange(nl2), t)), (nl2, nb))
dSf_dVa, dSf_dVm, dSt_dVa, dSt_dVm, Sf, St = \
dSbr_dV(branch[il,:], Yf, Yt, V)
if ppopt['OPF_FLOW_LIM'] == 1: ## real power
Hfaa, Hfav, Hfva, Hfvv = d2ASbr_dV2(dSf_dVa.real, dSf_dVm.real,
Sf.real, Cf, Yf, V, muF)
Htaa, Htav, Htva, Htvv = d2ASbr_dV2(dSt_dVa.real, dSt_dVm.real,
St.real, Ct, Yt, V, muT)
else: ## apparent power
Hfaa, Hfav, Hfva, Hfvv = \
d2ASbr_dV2(dSf_dVa, dSf_dVm, Sf, Cf, Yf, V, muF)
Htaa, Htav, Htva, Htvv = \
d2ASbr_dV2(dSt_dVa, dSt_dVm, St, Ct, Yt, V, muT)
d2H = vstack([
hstack([
vstack([hstack([Hfaa, Hfav]),
hstack([Hfva, Hfvv])]) +
vstack([hstack([Htaa, Htav]),
hstack([Htva, Htvv])]),
sparse((2 * nb, nxtra))
]),
hstack([sparse(
(nxtra, 2 * nb)), sparse((nxtra, nxtra))])
], "csr")
##----- do numerical check using (central) finite differences -----
if 0:
nx = len(x)
step = 1e-5
num_d2f = sparse((nx, nx))
num_d2G = sparse((nx, nx))
num_d2H = sparse((nx, nx))
for i in range(nx):
xp = x
xm = x
xp[i] = x[i] + step / 2
xm[i] = x[i] - step / 2
# evaluate cost & gradients
_, dfp = opf_costfcn(xp, om)
_, dfm = opf_costfcn(xm, om)
# evaluate constraints & gradients
_, _, dHp, dGp = opf_consfcn(xp, om, Ybus, Yf, Yt, ppopt, il)
_, _, dHm, dGm = opf_consfcn(xm, om, Ybus, Yf, Yt, ppopt, il)
num_d2f[:, i] = cost_mult * (dfp - dfm) / step
num_d2G[:, i] = (dGp - dGm) * lmbda["eqnonlin"] / step
num_d2H[:, i] = (dHp - dHm) * lmbda["ineqnonlin"] / step
d2f_err = max(max(abs(d2f - num_d2f)))
d2G_err = max(max(abs(d2G - num_d2G)))
d2H_err = max(max(abs(d2H - num_d2H)))
if d2f_err > 1e-6:
print('Max difference in d2f: %g' % d2f_err)
if d2G_err > 1e-5:
print('Max difference in d2G: %g' % d2G_err)
if d2H_err > 1e-6:
print('Max difference in d2H: %g' % d2H_err)
return d2f + d2G + d2H
def opf_hessfcn(x, lmbda, om, Ybus, Yf, Yt, ppopt, il=None, cost_mult=1.0):
"""Evaluates Hessian of Lagrangian for AC OPF.
Hessian evaluation function for AC optimal power flow, suitable
for use with L{pips}.
Examples::
Lxx = opf_hessfcn(x, lmbda, om, Ybus, Yf, Yt, ppopt)
Lxx = opf_hessfcn(x, lmbda, om, Ybus, Yf, Yt, ppopt, il)
Lxx = opf_hessfcn(x, lmbda, om, Ybus, Yf, Yt, ppopt, il, cost_mult)
@param x: optimization vector
@param lmbda: C{eqnonlin} - Lagrange multipliers on power balance
equations. C{ineqnonlin} - Kuhn-Tucker multipliers on constrained
branch flows.
@param om: OPF model object
@param Ybus: bus admittance matrix
@param Yf: admittance matrix for "from" end of constrained branches
@param Yt: admittance matrix for "to" end of constrained branches
@param ppopt: PYPOWER options vector
@param il: (optional) vector of branch indices corresponding to
branches with flow limits (all others are assumed to be unconstrained).
The default is C{range(nl)} (all branches). C{Yf} and C{Yt} contain
only the rows corresponding to C{il}.
@param cost_mult: (optional) Scale factor to be applied to the cost
(default = 1).
@return: Hessian of the Lagrangian.
@see: L{opf_costfcn}, L{opf_consfcn}
@author: Ray Zimmerman (PSERC Cornell)
@author: Carlos E. Murillo-Sanchez (PSERC Cornell & Universidad
Autonoma de Manizales)
"""
##----- initialize -----
## unpack data
ppc = om.get_ppc()
baseMVA, bus, gen, branch, gencost = \
ppc["baseMVA"], ppc["bus"], ppc["gen"], ppc["branch"], ppc["gencost"]
cp = om.get_cost_params()
N, Cw, H, dd, rh, kk, mm = \
cp["N"], cp["Cw"], cp["H"], cp["dd"], cp["rh"], cp["kk"], cp["mm"]
vv, _, _, _ = om.get_idx()
## unpack needed parameters
nb = bus.shape[0] ## number of buses
nl = branch.shape[0] ## number of branches
ng = gen.shape[0] ## number of dispatchable injections
nxyz = len(x) ## total number of control vars of all types
## set default constrained lines
if il is None:
il = arange(nl) ## all lines have limits by default
nl2 = len(il) ## number of constrained lines
## grab Pg & Qg
Pg = x[vv["i1"]["Pg"]:vv["iN"]["Pg"]] ## active generation in p.u.
Qg = x[vv["i1"]["Qg"]:vv["iN"]["Qg"]] ## reactive generation in p.u.
## put Pg & Qg back in gen
gen[:, PG] = Pg * baseMVA ## active generation in MW
gen[:, QG] = Qg * baseMVA ## reactive generation in MVAr
## reconstruct V
Va = x[vv["i1"]["Va"]:vv["iN"]["Va"]]
Vm = x[vv["i1"]["Vm"]:vv["iN"]["Vm"]]
V = Vm * exp(1j * Va)
nxtra = nxyz - 2 * nb
pcost = gencost[arange(ng), :]
if gencost.shape[0] > ng:
qcost = gencost[arange(ng, 2 * ng), :]
else:
qcost = array([])
## ----- evaluate d2f -----
d2f_dPg2 = zeros(ng)#sparse((ng, 1)) ## w.r.t. p.u. Pg
d2f_dQg2 = zeros(ng)#sparse((ng, 1)) ## w.r.t. p.u. Qg
ipolp = find(pcost[:, MODEL] == POLYNOMIAL)
d2f_dPg2[ipolp] = \
baseMVA**2 * polycost(pcost[ipolp, :], Pg[ipolp] * baseMVA, 2)
if any(qcost): ## Qg is not free
ipolq = find(qcost[:, MODEL] == POLYNOMIAL)
d2f_dQg2[ipolq] = \
baseMVA**2 * polycost(qcost[ipolq, :], Qg[ipolq] * baseMVA, 2)
i = r_[arange(vv["i1"]["Pg"], vv["iN"]["Pg"]),
arange(vv["i1"]["Qg"], vv["iN"]["Qg"])]
# d2f = sparse((vstack([d2f_dPg2, d2f_dQg2]).toarray().flatten(),
# (i, i)), shape=(nxyz, nxyz))
d2f = sparse((r_[d2f_dPg2, d2f_dQg2], (i, i)), (nxyz, nxyz))
## generalized cost
if issparse(N) and N.nnz > 0:
nw = N.shape[0]
r = N * x - rh ## Nx - rhat
iLT = find(r < -kk) ## below dead zone
iEQ = find((r == 0) & (kk == 0)) ## dead zone doesn't exist
iGT = find(r > kk) ## above dead zone
iND = r_[iLT, iEQ, iGT] ## rows that are Not in the Dead region
iL = find(dd == 1) ## rows using linear function
iQ = find(dd == 2) ## rows using quadratic function
LL = sparse((ones(len(iL)), (iL, iL)), (nw, nw))
QQ = sparse((ones(len(iQ)), (iQ, iQ)), (nw, nw))
kbar = sparse((r_[ones(len(iLT)), zeros(len(iEQ)), -ones(len(iGT))],
(iND, iND)), (nw, nw)) * kk
rr = r + kbar ## apply non-dead zone shift
M = sparse((mm[iND], (iND, iND)), (nw, nw)) ## dead zone or scale
diagrr = sparse((rr, (arange(nw), arange(nw))), (nw, nw))
## linear rows multiplied by rr(i), quadratic rows by rr(i)^2
w = M * (LL + QQ * diagrr) * rr
HwC = H * w + Cw
AA = N.T * M * (LL + 2 * QQ * diagrr)
d2f = d2f + AA * H * AA.T + 2 * N.T * M * QQ * \
sparse((HwC, (arange(nw), arange(nw))), (nw, nw)) * N
d2f = d2f * cost_mult
##----- evaluate Hessian of power balance constraints -----
nlam = len(lmbda["eqnonlin"]) / 2
lamP = lmbda["eqnonlin"][:nlam]
lamQ = lmbda["eqnonlin"][nlam:nlam + nlam]
Gpaa, Gpav, Gpva, Gpvv = d2Sbus_dV2(Ybus, V, lamP)
Gqaa, Gqav, Gqva, Gqvv = d2Sbus_dV2(Ybus, V, lamQ)
d2G = vstack([
hstack([
vstack([hstack([Gpaa, Gpav]),
hstack([Gpva, Gpvv])]).real +
vstack([hstack([Gqaa, Gqav]),
hstack([Gqva, Gqvv])]).imag,
sparse((2 * nb, nxtra))]),
hstack([
sparse((nxtra, 2 * nb)),
sparse((nxtra, nxtra))
])
], "csr")
##----- evaluate Hessian of flow constraints -----
nmu = len(lmbda["ineqnonlin"]) / 2
muF = lmbda["ineqnonlin"][:nmu]
muT = lmbda["ineqnonlin"][nmu:nmu + nmu]
if ppopt['OPF_FLOW_LIM'] == 2: ## current
dIf_dVa, dIf_dVm, dIt_dVa, dIt_dVm, If, It = dIbr_dV(Yf, Yt, V)
Hfaa, Hfav, Hfva, Hfvv = d2AIbr_dV2(dIf_dVa, dIf_dVm, If, Yf, V, muF)
Htaa, Htav, Htva, Htvv = d2AIbr_dV2(dIt_dVa, dIt_dVm, It, Yt, V, muT)
else:
f = branch[il, F_BUS].astype(int) ## list of "from" buses
t = branch[il, T_BUS].astype(int) ## list of "to" buses
## connection matrix for line & from buses
Cf = sparse((ones(nl2), (arange(nl2), f)), (nl2, nb))
## connection matrix for line & to buses
Ct = sparse((ones(nl2), (arange(nl2), t)), (nl2, nb))
dSf_dVa, dSf_dVm, dSt_dVa, dSt_dVm, Sf, St = \
dSbr_dV(branch[il,:], Yf, Yt, V)
if ppopt['OPF_FLOW_LIM'] == 1: ## real power
Hfaa, Hfav, Hfva, Hfvv = d2ASbr_dV2(dSf_dVa.real, dSf_dVm.real,
Sf.real, Cf, Yf, V, muF)
Htaa, Htav, Htva, Htvv = d2ASbr_dV2(dSt_dVa.real, dSt_dVm.real,
St.real, Ct, Yt, V, muT)
else: ## apparent power
Hfaa, Hfav, Hfva, Hfvv = \
d2ASbr_dV2(dSf_dVa, dSf_dVm, Sf, Cf, Yf, V, muF)
Htaa, Htav, Htva, Htvv = \
d2ASbr_dV2(dSt_dVa, dSt_dVm, St, Ct, Yt, V, muT)
d2H = vstack([
hstack([
vstack([hstack([Hfaa, Hfav]),
hstack([Hfva, Hfvv])]) +
vstack([hstack([Htaa, Htav]),
hstack([Htva, Htvv])]),
sparse((2 * nb, nxtra))
]),
hstack([
sparse((nxtra, 2 * nb)),
sparse((nxtra, nxtra))
])
], "csr")
##----- do numerical check using (central) finite differences -----
if 0:
nx = len(x)
step = 1e-5
num_d2f = sparse((nx, nx))
num_d2G = sparse((nx, nx))
num_d2H = sparse((nx, nx))
for i in range(nx):
xp = x
xm = x
xp[i] = x[i] + step / 2
xm[i] = x[i] - step / 2
# evaluate cost & gradients
_, dfp = opf_costfcn(xp, om)
_, dfm = opf_costfcn(xm, om)
# evaluate constraints & gradients
_, _, dHp, dGp = opf_consfcn(xp, om, Ybus, Yf, Yt, ppopt, il)
_, _, dHm, dGm = opf_consfcn(xm, om, Ybus, Yf, Yt, ppopt, il)
num_d2f[:, i] = cost_mult * (dfp - dfm) / step
num_d2G[:, i] = (dGp - dGm) * lmbda["eqnonlin"] / step
num_d2H[:, i] = (dHp - dHm) * lmbda["ineqnonlin"] / step
d2f_err = max(max(abs(d2f - num_d2f)))
d2G_err = max(max(abs(d2G - num_d2G)))
d2H_err = max(max(abs(d2H - num_d2H)))
if d2f_err > 1e-6:
print('Max difference in d2f: %g' % d2f_err)
if d2G_err > 1e-5:
print('Max difference in d2G: %g' % d2G_err)
if d2H_err > 1e-6:
print('Max difference in d2H: %g' % d2H_err)
return d2f + d2G + d2H
def opf_costfcn(x, om, return_hessian=False):
"""Evaluates objective function, gradient and Hessian for OPF.
Objective function evaluation routine for AC optimal power flow,
suitable for use with L{pips}. Computes objective function value,
gradient and Hessian.
@param x: optimization vector
@param om: OPF model object
@return: C{F} - value of objective function. C{df} - (optional) gradient
of objective function (column vector). C{d2f} - (optional) Hessian of
objective function (sparse matrix).
@see: L{opf_consfcn}, L{opf_hessfcn}
@author: Carlos E. Murillo-Sanchez (PSERC Cornell & Universidad
Autonoma de Manizales)
@author: Ray Zimmerman (PSERC Cornell)
@author: Richard Lincoln
"""
##----- initialize -----
## unpack data
ppc = om.get_ppc()
baseMVA, gen, gencost = ppc["baseMVA"], ppc["gen"], ppc["gencost"]
cp = om.get_cost_params()
N, Cw, H, dd, rh, kk, mm = \
cp["N"], cp["Cw"], cp["H"], cp["dd"], cp["rh"], cp["kk"], cp["mm"]
vv, _, _, _ = om.get_idx()
## problem dimensions
ng = gen.shape[0] ## number of dispatchable injections
ny = om.getN('var', 'y') ## number of piece-wise linear costs
nxyz = len(x) ## total number of control vars of all types
## grab Pg & Qg
Pg = x[vv["i1"]["Pg"]:vv["iN"]["Pg"]] ## active generation in p.u.
Qg = x[vv["i1"]["Qg"]:vv["iN"]["Qg"]] ## reactive generation in p.u.
##----- evaluate objective function -----
## polynomial cost of P and Q
# use totcost only on polynomial cost in the minimization problem
# formulation, pwl cost is the sum of the y variables.
ipol = find(gencost[:, MODEL] == POLYNOMIAL) ## poly MW and MVAr costs
xx = r_[ Pg, Qg ] * baseMVA
if any(ipol):
f = sum( totcost(gencost[ipol, :], xx[ipol]) ) ## cost of poly P or Q
else:
f = 0
## piecewise linear cost of P and Q
if ny > 0:
ccost = sparse((ones(ny),
(zeros(ny), arange(vv["i1"]["y"], vv["iN"]["y"]))),
(1, nxyz)).toarray().flatten()
f = f + dot(ccost, x)
else:
ccost = zeros(nxyz)
## generalized cost term
if issparse(N) and N.nnz > 0:
nw = N.shape[0]
r = N * x - rh ## Nx - rhat
iLT = find(r < -kk) ## below dead zone
iEQ = find((r == 0) & (kk == 0)) ## dead zone doesn't exist
iGT = find(r > kk) ## above dead zone
iND = r_[iLT, iEQ, iGT] ## rows that are Not in the Dead region
iL = find(dd == 1) ## rows using linear function
iQ = find(dd == 2) ## rows using quadratic function
LL = sparse((ones(len(iL)), (iL, iL)), (nw, nw))
QQ = sparse((ones(len(iQ)), (iQ, iQ)), (nw, nw))
kbar = sparse((r_[ones(len(iLT)), zeros(len(iEQ)), -ones(len(iGT))],
(iND, iND)), (nw, nw)) * kk
rr = r + kbar ## apply non-dead zone shift
M = sparse((mm[iND], (iND, iND)), (nw, nw)) ## dead zone or scale
diagrr = sparse((rr, (arange(nw), arange(nw))), (nw, nw))
## linear rows multiplied by rr(i), quadratic rows by rr(i)^2
w = M * (LL + QQ * diagrr) * rr
f = f + dot(w * H, w) / 2 + dot(Cw, w)
##----- evaluate cost gradient -----
## index ranges
iPg = range(vv["i1"]["Pg"], vv["iN"]["Pg"])
iQg = range(vv["i1"]["Qg"], vv["iN"]["Qg"])
## polynomial cost of P and Q
df_dPgQg = zeros(2 * ng) ## w.r.t p.u. Pg and Qg
df_dPgQg[ipol] = baseMVA * polycost(gencost[ipol, :], xx[ipol], 1)
df = zeros(nxyz)
df[iPg] = df_dPgQg[:ng]
df[iQg] = df_dPgQg[ng:ng + ng]
## piecewise linear cost of P and Q
df = df + ccost # The linear cost row is additive wrt any nonlinear cost.
## generalized cost term
if issparse(N) and N.nnz > 0:
HwC = H * w + Cw
AA = N.T * M * (LL + 2 * QQ * diagrr)
df = df + AA * HwC
## numerical check
if 0: ## 1 to check, 0 to skip check
ddff = zeros(df.shape)
step = 1e-7
tol = 1e-3
for k in range(len(x)):
xx = x
xx[k] = xx[k] + step
ddff[k] = (opf_costfcn(xx, om) - f) / step
if max(abs(ddff - df)) > tol:
idx = find(abs(ddff - df) == max(abs(ddff - df)))
print('Mismatch in gradient')
print('idx df(num) df diff')
print('%4d%16g%16g%16g' %
(range(len(df)), ddff.T, df.T, abs(ddff - df).T))
print('MAX')
print('%4d%16g%16g%16g' %
(idx.T, ddff[idx].T, df[idx].T,
abs(ddff[idx] - df[idx]).T))
if not return_hessian:
return f, df
## ---- evaluate cost Hessian -----
pcost = gencost[range(ng), :]
if gencost.shape[0] > ng:
qcost = gencost[ng + 1:2 * ng, :]
else:
qcost = array([])
## polynomial generator costs
d2f_dPg2 = zeros(ng) ## w.r.t. p.u. Pg
d2f_dQg2 = zeros(ng) ## w.r.t. p.u. Qg
ipolp = find(pcost[:, MODEL] == POLYNOMIAL)
d2f_dPg2[ipolp] = \
baseMVA**2 * polycost(pcost[ipolp, :], Pg[ipolp]*baseMVA, 2)
if any(qcost): ## Qg is not free
ipolq = find(qcost[:, MODEL] == POLYNOMIAL)
d2f_dQg2[ipolq] = \
baseMVA**2 * polycost(qcost[ipolq, :], Qg[ipolq] * baseMVA, 2)
i = r_[iPg, iQg].T
d2f = sparse((r_[d2f_dPg2, d2f_dQg2], (i, i)), (nxyz, nxyz))
## generalized cost
if N is not None and issparse(N):
d2f = d2f + AA * H * AA.T + 2 * N.T * M * QQ * \
sparse((HwC, (range(nw), range(nw))), (nw, nw)) * N
return f, df, d2f
