def initUI(self):
self.resize(1700, 800)
self.centre()
self.setWindowTitle('PYPOWER | Editor')
self.setWindowIcon(QtGui.QIcon('icons\sigma.png'))
"""
Tabs
"""
tab_widget = QtGui.QTabWidget()
tab1 = QtGui.QWidget()
tab2 = QtGui.QWidget()
tab3 = QtGui.QWidget()
tab4 = QtGui.QWidget()
self.tab_widget = tab_widget
tab_widget.addTab(tab1, "Buses")
tab_widget.addTab(tab2, "Generators")
tab_widget.addTab(tab3, "Branches")
tab_widget.addTab(tab4, "Message Log")
self.page1 = gui_buses.buses_ui(tab1)
self.page2 = gui_gens.gens_ui(tab2)
self.page3 = gui_branches.branches_ui(tab3)
self.log = gui_log.log_ui(tab4)
self.page1.setup(self)
self.page2.setup(self)
self.page3.setup(self)
self.log.setup(self)
self.setCentralWidget(tab_widget)
"""
Actions
"""
exitAction = QtGui.QAction(QtGui.QIcon('icons/exit.png'), '&Exit', self)
exitAction.setShortcut('Ctrl+Q')
exitAction.setStatusTip('Exit application')
exitAction.triggered.connect(QtGui.qApp.quit)
refreshAction = QtGui.QAction(QtGui.QIcon('icons/refresh.ico'), '&Refresh', self)
refreshAction.setShortcut('F5')
refreshAction.setStatusTip('Refresh')
refreshAction.triggered.connect(self.page1.refresh_data)
refreshAction.triggered.connect(self.page2.refresh_data)
ldfAction = QtGui.QAction(QtGui.QIcon('icons/powerflow.png'), '&Power Flow', self)
#ldfAction.setShortcut('F5')
ldfAction.setStatusTip('Calculate power flow')
ldfAction.triggered.connect(self.calc_power_flow)
resetAction = QtGui.QAction(QtGui.QIcon('icons/reset.png'), '&Reset Voltages', self)
resetAction.setStatusTip('Reset bus voltages and angles')
resetAction.triggered.connect(self.reset_voltages)
newAction = QtGui.QAction(QtGui.QIcon('icons/new.png'), '&New', self)
newAction.setShortcut('Ctrl+N')
newAction.setStatusTip('New grid')
newAction.triggered.connect(self.new_fn)
###########################
# TO DO - Add Save button which will be greyed out if no changes from saved data
# Save button should bring up Save As if no open file
###########################
saveAction = QtGui.QAction(QtGui.QIcon('icons/saveas.ico'), '&Save', self)
saveAction.setShortcut('Ctrl+S')
saveAction.setStatusTip('Save grid file')
saveAction.triggered.connect(self.save_fn)
saveAsAction = QtGui.QAction(QtGui.QIcon('icons/saveas.ico'), 'Save &As', self)
saveAsAction.setShortcut('Ctrl+A')
saveAsAction.setStatusTip('Save grid file as')
saveAsAction.triggered.connect(self.save_as_fn)
openAction = QtGui.QAction(QtGui.QIcon('icons/open.ico'), '&Open', self)
openAction.setShortcut('Ctrl+O')
openAction.setStatusTip('Open grid file')
openAction.triggered.connect(self.open_fn)
aboutAction = QtGui.QAction('&About', self)
aboutAction.setStatusTip('About')
aboutAction.triggered.connect(self.about_dialog)
helpAction = QtGui.QAction('&Documentation', self)
helpAction.setShortcut('F1')
helpAction.setStatusTip('User documentation')
helpAction.triggered.connect(self.user_docs)
"""
Menubar
"""
menu_bar = self.menuBar()
fileMenu = menu_bar.addMenu('&File')
fileMenu.addAction(newAction)
fileMenu.addAction(openAction)
fileMenu.addAction(saveAction)
fileMenu.addAction(saveAsAction)
fileMenu.addSeparator()
fileMenu.addAction(exitAction)
helpMenu = menu_bar.addMenu('&Help')
helpMenu.addAction(helpAction)
helpMenu.addSeparator()
helpMenu.addAction(aboutAction)
"""
Toolbar
"""
self.toolbar = self.addToolBar('Exit')
self.toolbar.addAction(exitAction)
self.toolbar = self.addToolBar('Refresh')
self.toolbar.addAction(refreshAction)
self.toolbar = self.addToolBar('Power Flow')
self.toolbar.addAction(ldfAction)
self.toolbar = self.addToolBar('Reset Voltages')
self.toolbar.addAction(resetAction)
"""
Status bar and log messages
"""
self.statusBar()
v = ppver('all')
self.log.write("PYPOWER v" + v["Version"] + ", " + v["Date"] + "\n")
self.log.write("===========================\n")
sys.stdout = self.log
import pypsa
from pypower.api import ppoption, runpf, case118 as case
from pypower.ppver import ppver
from distutils.version import StrictVersion
pypower_version = StrictVersion(ppver()['Version'])
import pandas as pd
import numpy as np
import pytest
from numpy.testing import assert_array_almost_equal as equal
@pytest.mark.skipif(
pypower_version <= '5.0.0',
reason=
"PyPOWER 5.0.0 is broken with recent numpy and unmaintained since Aug 2017."
)
def test_pypower_case():
#ppopt is a dictionary with the details of the optimization routine to run
ppopt = ppoption(PF_ALG=2)
#choose DC or AC
ppopt["PF_DC"] = False
#ppc is a dictionary with details about the network, including baseMVA, branches and generators
ppc = case()
def about_dialog(self):
"""Show about dialog box"""
v = ppver('all')
QtGui.QMessageBox.about(self, "About PYPOWER",
"<b>PYPOWER</b> is a power flow and optimal power flow solver. <p>Version " + v["Version"] + ", " + v["Date"])
def runpf(casedata=None, ppopt=None, fname='', solvedcase=''):
"""Runs a power flow.
Runs a power flow [full AC Newton's method by default] and optionally
returns the solved values in the data matrices, a flag which is C{True} if
the algorithm was successful in finding a solution, and the elapsed
time in seconds. All input arguments are optional. If C{casename} is
provided it specifies the name of the input data file or dict
containing the power flow data. The default value is 'case9'.
If the ppopt is provided it overrides the default PYPOWER options
vector and can be used to specify the solution algorithm and output
options among other things. If the 3rd argument is given the pretty
printed output will be appended to the file whose name is given in
C{fname}. If C{solvedcase} is specified the solved case will be written
to a case file in PYPOWER format with the specified name. If C{solvedcase}
ends with '.mat' it saves the case as a MAT-file otherwise it saves it
as a Python-file.
If the C{ENFORCE_Q_LIMS} options is set to C{True} [default is false] then
if any generator reactive power limit is violated after running the AC
power flow, the corresponding bus is converted to a PQ bus, with Qg at
the limit, and the case is re-run. The voltage magnitude at the bus
will deviate from the specified value in order to satisfy the reactive
power limit. If the reference bus is converted to PQ, the first
remaining PV bus will be used as the slack bus for the next iteration.
This may result in the real power output at this generator being
slightly off from the specified values.
Enforcing of generator Q limits inspired by contributions from Mu Lin,
Lincoln University, New Zealand (1/14/05).
@author: Ray Zimmerman (PSERC Cornell)
"""
## default arguments
if casedata is None:
casedata = join(dirname(__file__), 'case9')
ppopt = ppoption(ppopt)
## options
verbose = ppopt["VERBOSE"]
qlim = ppopt["ENFORCE_Q_LIMS"] ## enforce Q limits on gens?
dc = ppopt["PF_DC"] ## use DC formulation?
## read data
ppc = loadcase(casedata)
## add zero columns to branch for flows if needed
if ppc["branch"].shape[1] < QT:
ppc["branch"] = c_[ppc["branch"],
zeros((ppc["branch"].shape[0],
QT - ppc["branch"].shape[1] + 1))]
## convert to internal indexing
ppc = ext2int(ppc)
baseMVA, bus, gen, branch = \
ppc["baseMVA"], ppc["bus"], ppc["gen"], ppc["branch"]
## get bus index lists of each type of bus
ref, pv, pq = bustypes(bus, gen)
## generator info
on = find(gen[:, GEN_STATUS] > 0) ## which generators are on?
gbus = gen[on, GEN_BUS].astype(int) ## what buses are they at?
##----- run the power flow -----
t0 = time()
if verbose > 0:
v = ppver('all')
stdout.write('PYPOWER Version %s, %s' % (v["Version"], v["Date"]))
if dc: # DC formulation
if verbose:
stdout.write(' -- DC Power Flow\n')
## initial state
Va0 = bus[:, VA] * (pi / 180)
## build B matrices and phase shift injections
B, Bf, Pbusinj, Pfinj = makeBdc(baseMVA, bus, branch)
## compute complex bus power injections [generation - load]
## adjusted for phase shifters and real shunts
Pbus = makeSbus(baseMVA, bus,
gen).real - Pbusinj - bus[:, GS] / baseMVA
## "run" the power flow
Va = dcpf(B, Pbus, Va0, ref, pv, pq)
## update data matrices with solution
branch[:, [QF, QT]] = zeros((branch.shape[0], 2))
branch[:, PF] = (Bf * Va + Pfinj) * baseMVA
branch[:, PT] = -branch[:, PF]
bus[:, VM] = ones(bus.shape[0])
bus[:, VA] = Va * (180 / pi)
## update Pg for slack generator (1st gen at ref bus)
## (note: other gens at ref bus are accounted for in Pbus)
## Pg = Pinj + Pload + Gs
## newPg = oldPg + newPinj - oldPinj
refgen = zeros(len(ref), dtype=int)
for k in range(len(ref)):
temp = find(gbus == ref[k])
refgen[k] = on[temp[0]]
gen[refgen,
PG] = gen[refgen, PG] + (B[ref, :] * Va - Pbus[ref]) * baseMVA
success = 1
else: ## AC formulation
alg = ppopt['PF_ALG']
if verbose > 0:
if alg == 1:
solver = 'Newton'
elif alg == 2:
solver = 'fast-decoupled, XB'
elif alg == 3:
solver = 'fast-decoupled, BX'
elif alg == 4:
solver = 'Gauss-Seidel'
else:
solver = 'unknown'
print(' -- AC Power Flow (%s)\n' % solver)
## initial state
# V0 = ones(bus.shape[0]) ## flat start
V0 = bus[:, VM] * exp(1j * pi / 180 * bus[:, VA])
V0[gbus] = gen[on, VG] / abs(V0[gbus]) * V0[gbus]
if qlim:
ref0 = ref ## save index and angle of
Varef0 = bus[ref0, VA] ## original reference bus(es)
limited = [] ## list of indices of gens @ Q lims
fixedQg = zeros(gen.shape[0]) ## Qg of gens at Q limits
repeat = True
while repeat:
## build admittance matrices
Ybus, Yf, Yt = makeYbus(baseMVA, bus, branch)
## compute complex bus power injections [generation - load]
Sbus = makeSbus(baseMVA, bus, gen)
## run the power flow
alg = ppopt["PF_ALG"]
if alg == 1:
V, success, _ = newtonpf(Ybus, Sbus, V0, ref, pv, pq, ppopt)
elif alg == 2 or alg == 3:
Bp, Bpp = makeB(baseMVA, bus, branch, alg)
V, success, _ = fdpf(Ybus, Sbus, V0, Bp, Bpp, ref, pv, pq,
ppopt)
elif alg == 4:
V, success, _ = gausspf(Ybus, Sbus, V0, ref, pv, pq, ppopt)
else:
stderr.write('Only Newton'
's method, fast-decoupled, and '
'Gauss-Seidel power flow algorithms currently '
'implemented.\n')
## update data matrices with solution
bus, gen, branch = pfsoln(baseMVA, bus, gen, branch, Ybus, Yf, Yt,
V, ref, pv, pq)
if qlim: ## enforce generator Q limits
## find gens with violated Q constraints
gen_status = gen[:, GEN_STATUS] > 0
qg_max_lim = gen[:, QG] > gen[:, QMAX]
qg_min_lim = gen[:, QG] < gen[:, QMIN]
mx = find(gen_status & qg_max_lim)
mn = find(gen_status & qg_min_lim)
if len(mx) > 0 or len(
mn) > 0: ## we have some Q limit violations
# No PV generators
if len(pv) == 0:
if verbose:
if len(mx) > 0:
print(
'Gen %d [only one left] exceeds upper Q limit : INFEASIBLE PROBLEM\n'
% mx + 1)
else:
print(
'Gen %d [only one left] exceeds lower Q limit : INFEASIBLE PROBLEM\n'
% mn + 1)
success = 0
break
## one at a time?
if qlim == 2: ## fix largest violation, ignore the rest
k = argmax(r_[gen[mx, QG] - gen[mx, QMAX],
gen[mn, QMIN] - gen[mn, QG]])
if k > len(mx):
mn = mn[k - len(mx)]
mx = []
else:
mx = mx[k]
mn = []
if verbose and len(mx) > 0:
for i in range(len(mx)):
print('Gen ' + str(mx[i] + 1) +
' at upper Q limit, converting to PQ bus\n')
if verbose and len(mn) > 0:
for i in range(len(mn)):
print('Gen ' + str(mn[i] + 1) +
' at lower Q limit, converting to PQ bus\n')
## save corresponding limit values
fixedQg[mx] = gen[mx, QMAX]
fixedQg[mn] = gen[mn, QMIN]
mx = r_[mx, mn].astype(int)
## convert to PQ bus
gen[mx, QG] = fixedQg[mx] ## set Qg to binding
for i in range(
len(mx)
): ## [one at a time, since they may be at same bus]
gen[mx[i],
GEN_STATUS] = 0 ## temporarily turn off gen,
bi = gen[mx[i], GEN_BUS] ## adjust load accordingly,
bus[bi, [PD, QD]] = (bus[bi, [PD, QD]] -
gen[mx[i], [PG, QG]])
if len(ref) > 1 and any(bus[gen[mx, GEN_BUS],
BUS_TYPE] == REF):
raise ValueError('Sorry, PYPOWER cannot enforce Q '
'limits for slack buses in systems '
'with multiple slacks.')
bus[gen[mx, GEN_BUS].astype(int),
BUS_TYPE] = PQ ## & set bus type to PQ
## update bus index lists of each type of bus
ref_temp = ref
ref, pv, pq = bustypes(bus, gen)
if verbose and ref != ref_temp:
print('Bus %d is new slack bus\n' % ref)
limited = r_[limited, mx].astype(int)
else:
repeat = 0 ## no more generator Q limits violated
else:
repeat = 0 ## don't enforce generator Q limits, once is enough
if qlim and len(limited) > 0:
## restore injections from limited gens [those at Q limits]
gen[limited, QG] = fixedQg[limited] ## restore Qg value,
for i in range(
len(limited
)): ## [one at a time, since they may be at same bus]
bi = gen[limited[i], GEN_BUS] ## re-adjust load,
bus[bi,
[PD, QD]] = bus[bi, [PD, QD]] + gen[limited[i], [PG, QG]]
gen[limited[i], GEN_STATUS] = 1 ## and turn gen back on
if ref != ref0:
## adjust voltage angles to make original ref bus correct
bus[:, VA] = bus[:, VA] - bus[ref0, VA] + Varef0
ppc["et"] = time() - t0
ppc["success"] = success
##----- output results -----
## convert back to original bus numbering & print results
ppc["bus"], ppc["gen"], ppc["branch"] = bus, gen, branch
results = int2ext(ppc)
## zero out result fields of out-of-service gens & branches
if len(results["order"]["gen"]["status"]["off"]) > 0:
results["gen"][ix_(results["order"]["gen"]["status"]["off"],
[PG, QG])] = 0
if len(results["order"]["branch"]["status"]["off"]) > 0:
results["branch"][ix_(results["order"]["branch"]["status"]["off"],
[PF, QF, PT, QT])] = 0
if fname:
fd = None
try:
fd = open(fname, "a")
except Exception as detail:
stderr.write("Error opening %s: %s.\n" % (fname, detail))
finally:
if fd is not None:
printpf(results, fd, ppopt)
fd.close()
else:
printpf(results, stdout, ppopt)
## save solved case
if solvedcase:
savecase(solvedcase, results)
return results, success
def runpf(casedata=None, ppopt=None, fname='', solvedcase=''):
"""Runs a power flow.
Runs a power flow [full AC Newton's method by default] and optionally
returns the solved values in the data matrices, a flag which is C{True} if
the algorithm was successful in finding a solution, and the elapsed
time in seconds. All input arguments are optional. If C{casename} is
provided it specifies the name of the input data file or dict
containing the power flow data. The default value is 'case9'.
If the ppopt is provided it overrides the default PYPOWER options
vector and can be used to specify the solution algorithm and output
options among other things. If the 3rd argument is given the pretty
printed output will be appended to the file whose name is given in
C{fname}. If C{solvedcase} is specified the solved case will be written
to a case file in PYPOWER format with the specified name. If C{solvedcase}
ends with '.mat' it saves the case as a MAT-file otherwise it saves it
as a Python-file.
If the C{ENFORCE_Q_LIMS} options is set to C{True} [default is false] then
if any generator reactive power limit is violated after running the AC
power flow, the corresponding bus is converted to a PQ bus, with Qg at
the limit, and the case is re-run. The voltage magnitude at the bus
will deviate from the specified value in order to satisfy the reactive
power limit. If the reference bus is converted to PQ, the first
remaining PV bus will be used as the slack bus for the next iteration.
This may result in the real power output at this generator being
slightly off from the specified values.
Enforcing of generator Q limits inspired by contributions from Mu Lin,
Lincoln University, New Zealand (1/14/05).
@author: Ray Zimmerman (PSERC Cornell)
"""
## default arguments
if casedata is None:
casedata = join(dirname(__file__), 'case9')
ppopt = ppoption(ppopt)
## options
verbose = ppopt["VERBOSE"]
qlim = ppopt["ENFORCE_Q_LIMS"] ## enforce Q limits on gens?
dc = ppopt["PF_DC"] ## use DC formulation?
## read data
ppc = loadcase(casedata)
## add zero columns to branch for flows if needed
if ppc["branch"].shape[1] < QT:
ppc["branch"] = c_[ppc["branch"],
zeros((ppc["branch"].shape[0],
QT - ppc["branch"].shape[1] + 1))]
## convert to internal indexing
ppc = ext2int(ppc)
baseMVA, bus, gen, branch = \
ppc["baseMVA"], ppc["bus"], ppc["gen"], ppc["branch"]
## get bus index lists of each type of bus
ref, pv, pq = bustypes(bus, gen)
## generator info
on = find(gen[:, GEN_STATUS] > 0) ## which generators are on?
gbus = gen[on, GEN_BUS].astype(int) ## what buses are they at?
##----- run the power flow -----
t0 = time()
if verbose > 0:
v = ppver('all')
stdout.write('PYPOWER Version %s, %s' % (v["Version"], v["Date"]))
if dc: # DC formulation
if verbose:
stdout.write(' -- DC Power Flow\n')
## initial state
Va0 = bus[:, VA] * (pi / 180)
## build B matrices and phase shift injections
B, Bf, Pbusinj, Pfinj = makeBdc(baseMVA, bus, branch)
## compute complex bus power injections [generation - load]
## adjusted for phase shifters and real shunts
Pbus = makeSbus(baseMVA, bus, gen).real - Pbusinj - bus[:, GS] / baseMVA
## "run" the power flow
Va = dcpf(B, Pbus, Va0, ref, pv, pq)
## update data matrices with solution
branch[:, [QF, QT]] = zeros((branch.shape[0], 2))
branch[:, PF] = (Bf * Va + Pfinj) * baseMVA
branch[:, PT] = -branch[:, PF]
bus[:, VM] = ones(bus.shape[0])
bus[:, VA] = Va * (180 / pi)
## update Pg for slack generator (1st gen at ref bus)
## (note: other gens at ref bus are accounted for in Pbus)
## Pg = Pinj + Pload + Gs
## newPg = oldPg + newPinj - oldPinj
refgen = zeros(len(ref), dtype=int)
for k in range(len(ref)):
temp = find(gbus == ref[k])
refgen[k] = on[temp[0]]
gen[refgen, PG] = gen[refgen, PG] + (B[ref, :] * Va - Pbus[ref]) * baseMVA
success = 1
else: ## AC formulation
alg = ppopt['PF_ALG']
if verbose > 0:
if alg == 1:
solver = 'Newton'
elif alg == 2:
solver = 'fast-decoupled, XB'
elif alg == 3:
solver = 'fast-decoupled, BX'
elif alg == 4:
solver = 'Gauss-Seidel'
else:
solver = 'unknown'
print(' -- AC Power Flow (%s)\n' % solver)
## initial state
# V0 = ones(bus.shape[0]) ## flat start
V0 = bus[:, VM] * exp(1j * pi/180 * bus[:, VA])
V0[gbus] = gen[on, VG] / abs(V0[gbus]) * V0[gbus]
if qlim:
ref0 = ref ## save index and angle of
Varef0 = bus[ref0, VA] ## original reference bus(es)
limited = [] ## list of indices of gens @ Q lims
fixedQg = zeros(gen.shape[0]) ## Qg of gens at Q limits
repeat = True
while repeat:
## build admittance matrices
Ybus, Yf, Yt = makeYbus(baseMVA, bus, branch)
## compute complex bus power injections [generation - load]
Sbus = makeSbus(baseMVA, bus, gen)
## run the power flow
alg = ppopt["PF_ALG"]
if alg == 1:
V, success, _ = newtonpf(Ybus, Sbus, V0, ref, pv, pq, ppopt)
elif alg == 2 or alg == 3:
Bp, Bpp = makeB(baseMVA, bus, branch, alg)
V, success, _ = fdpf(Ybus, Sbus, V0, Bp, Bpp, ref, pv, pq, ppopt)
elif alg == 4:
V, success, _ = gausspf(Ybus, Sbus, V0, ref, pv, pq, ppopt)
else:
stderr.write('Only Newton''s method, fast-decoupled, and '
'Gauss-Seidel power flow algorithms currently '
'implemented.\n')
## update data matrices with solution
bus, gen, branch = pfsoln(baseMVA, bus, gen, branch, Ybus, Yf, Yt, V, ref, pv, pq)
if qlim: ## enforce generator Q limits
## find gens with violated Q constraints
gen_status = gen[:, GEN_STATUS] > 0
qg_max_lim = gen[:, QG] > gen[:, QMAX]
qg_min_lim = gen[:, QG] < gen[:, QMIN]
mx = find( gen_status & qg_max_lim )
mn = find( gen_status & qg_min_lim )
if len(mx) > 0 or len(mn) > 0: ## we have some Q limit violations
# No PV generators
if len(pv) == 0:
if verbose:
if len(mx) > 0:
print('Gen %d [only one left] exceeds upper Q limit : INFEASIBLE PROBLEM\n' % mx + 1)
else:
print('Gen %d [only one left] exceeds lower Q limit : INFEASIBLE PROBLEM\n' % mn + 1)
success = 0
break
## one at a time?
if qlim == 2: ## fix largest violation, ignore the rest
k = argmax(r_[gen[mx, QG] - gen[mx, QMAX],
gen[mn, QMIN] - gen[mn, QG]])
if k > len(mx):
mn = mn[k - len(mx)]
mx = []
else:
mx = mx[k]
mn = []
if verbose and len(mx) > 0:
for i in range(len(mx)):
print('Gen ' + str(mx[i] + 1) + ' at upper Q limit, converting to PQ bus\n')
if verbose and len(mn) > 0:
for i in range(len(mn)):
print('Gen ' + str(mn[i] + 1) + ' at lower Q limit, converting to PQ bus\n')
## save corresponding limit values
fixedQg[mx] = gen[mx, QMAX]
fixedQg[mn] = gen[mn, QMIN]
mx = r_[mx, mn].astype(int)
## convert to PQ bus
gen[mx, QG] = fixedQg[mx] ## set Qg to binding
for i in range(len(mx)): ## [one at a time, since they may be at same bus]
gen[mx[i], GEN_STATUS] = 0 ## temporarily turn off gen,
bi = gen[mx[i], GEN_BUS] ## adjust load accordingly,
bus[bi, [PD, QD]] = (bus[bi, [PD, QD]] - gen[mx[i], [PG, QG]])
if len(ref) > 1 and any(bus[gen[mx, GEN_BUS], BUS_TYPE] == REF):
raise ValueError('Sorry, PYPOWER cannot enforce Q '
'limits for slack buses in systems '
'with multiple slacks.')
bus[gen[mx, GEN_BUS].astype(int), BUS_TYPE] = PQ ## & set bus type to PQ
## update bus index lists of each type of bus
ref_temp = ref
ref, pv, pq = bustypes(bus, gen)
if verbose and ref != ref_temp:
print('Bus %d is new slack bus\n' % ref)
limited = r_[limited, mx].astype(int)
else:
repeat = 0 ## no more generator Q limits violated
else:
repeat = 0 ## don't enforce generator Q limits, once is enough
if qlim and len(limited) > 0:
## restore injections from limited gens [those at Q limits]
gen[limited, QG] = fixedQg[limited] ## restore Qg value,
for i in range(len(limited)): ## [one at a time, since they may be at same bus]
bi = gen[limited[i], GEN_BUS] ## re-adjust load,
bus[bi, [PD, QD]] = bus[bi, [PD, QD]] + gen[limited[i], [PG, QG]]
gen[limited[i], GEN_STATUS] = 1 ## and turn gen back on
if ref != ref0:
## adjust voltage angles to make original ref bus correct
bus[:, VA] = bus[:, VA] - bus[ref0, VA] + Varef0
ppc["et"] = time() - t0
ppc["success"] = success
##----- output results -----
## convert back to original bus numbering & print results
ppc["bus"], ppc["gen"], ppc["branch"] = bus, gen, branch
results = int2ext(ppc)
## zero out result fields of out-of-service gens & branches
if len(results["order"]["gen"]["status"]["off"]) > 0:
results["gen"][ix_(results["order"]["gen"]["status"]["off"], [PG, QG])] = 0
if len(results["order"]["branch"]["status"]["off"]) > 0:
results["branch"][ix_(results["order"]["branch"]["status"]["off"], [PF, QF, PT, QT])] = 0
if fname:
fd = None
try:
fd = open(fname, "a")
except Exception as detail:
stderr.write("Error opening %s: %s.\n" % (fname, detail))
finally:
if fd is not None:
printpf(results, fd, ppopt)
fd.close()
else:
printpf(results, stdout, ppopt)
## save solved case
if solvedcase:
savecase(solvedcase, results)
return results, success
def runcpf(basecasedata=None,
targetcasedata=None,
ppopt=None,
fname='',
solvedcase=''):
# default arguments
if basecasedata is None:
basecasedata = join(dirname(__file__), 'case9')
if targetcasedata is None:
targetcasedata = join(dirname(__file__), 'case9target')
ppopt = ppoption(ppopt)
# options
verbose = ppopt["VERBOSE"]
step = ppopt["CPF_STEP"]
parameterization = ppopt["CPF_PARAMETERIZATION"]
adapt_step = ppopt["CPF_ADAPT_STEP"]
cb_args = ppopt["CPF_USER_CALLBACK_ARGS"]
# set up callbacks
callback_names = ["cpf_default_callback"]
if len(ppopt["CPF_USER_CALLBACK"]) > 0:
if isinstance(ppopt["CPF_USER_CALLBACK"], list):
callback_names = r_[callback_names, ppopt["CPF_USER_CALLBACK"]]
else:
callback_names.append(ppopt["CPF_USER_CALLBACK"])
callbacks = []
for callback_name in callback_names:
callbacks.append(getattr(cpf_callbacks, callback_name))
# read base case data
ppcbase = loadcase(basecasedata)
nb = ppcbase["bus"].shape[0]
# add zero columns to branch for flows if needed
if ppcbase["branch"].shape[1] < QT:
ppcbase["branch"] = c_[ppcbase["branch"],
zeros((ppcbase["branch"].shape[0],
QT - ppcbase["branch"].shape[1] + 1))]
# convert to internal indexing
ppcbase = ext2int(ppcbase)
baseMVAb, busb, genb, branchb = \
ppcbase["baseMVA"], ppcbase["bus"], ppcbase["gen"], ppcbase["branch"]
# get bus index lists of each type of bus
ref, pv, pq = bustypes(busb, genb)
# generator info
onb = find(genb[:, GEN_STATUS] > 0) # which generators are on?
gbusb = genb[onb, GEN_BUS].astype(int) # what buses are they at?
# read target case data
ppctarget = loadcase(targetcasedata)
# add zero columns to branch for flows if needed
if ppctarget["branch"].shape[1] < QT:
ppctarget["branch"] = c_[ppctarget["branch"],
zeros(
(ppctarget["branch"].shape[0],
QT - ppctarget["branch"].shape[1] + 1))]
# convert to internal indexing
ppctarget = ext2int(ppctarget)
baseMVAt, bust, gent, brancht = \
ppctarget["baseMVA"], ppctarget["bus"], ppctarget["gen"], ppctarget["branch"]
# get bus index lists of each type of bus
# ref, pv, pq = bustypes(bust, gent)
# generator info
ont = find(gent[:, GEN_STATUS] > 0) # which generators are on?
gbust = gent[ont, GEN_BUS].astype(int) # what buses are they at?
# ----- run the power flow -----
t0 = time()
if verbose > 0:
v = ppver('all')
stdout.write('PYPOWER Version %s, %s' % (v["Version"], v["Date"]))
stdout.write(' -- AC Continuation Power Flow\n')
# initial state
# V0 = ones(bus.shape[0]) ## flat start
V0 = busb[:, VM] * exp(1j * pi / 180 * busb[:, VA])
vcb = ones(V0.shape) # create mask of voltage-controlled buses
vcb[pq] = 0 # exclude PQ buses
k = find(vcb[gbusb]) # in-service gens at v-c buses
V0[gbusb[k]] = genb[onb[k], VG] / abs(V0[gbusb[k]]) * V0[gbusb[k]]
# build admittance matrices
Ybus, Yf, Yt = makeYbus(baseMVAb, busb, branchb)
# compute base case complex bus power injections (generation - load)
Sbusb = makeSbus(baseMVAb, busb, genb)
# compute target case complex bus power injections (generation - load)
Sbust = makeSbus(baseMVAt, bust, gent)
# scheduled transfer
Sxfr = Sbust - Sbusb
# Run the base case power flow solution
if verbose > 2:
ppopt_pf = ppoption(ppopt, VERBOSE=max(0, verbose - 1))
else:
ppopt_pf = ppoption(ppopt, VERBOSE=max(0, verbose - 2))
lam = 0
V, success, iterations = newtonpf(Ybus, Sbusb, V0, ref, pv, pq, ppopt_pf)
if verbose > 2:
print('step %3d : lambda = %6.3f\n' % (0, 0))
elif verbose > 1:
print('step %3d : lambda = %6.3f, %2d Newton steps\n',
(0, 0, iterations))
lamprv = lam # lam at previous step
Vprv = V # V at previous step
continuation = 1
cont_steps = 0
# input args for callbacks
cb_data = {
"ppc_base": ppcbase,
"ppc_target": ppctarget,
"Sxfr": Sxfr,
"Ybus": Ybus,
"Yf": Yf,
"Yt": Yt,
"ref": ref,
"pv": pv,
"pq": pq,
"ppopt": ppopt
}
cb_state = {}
# invoke callbacks
for k in range(len(callbacks)):
cb_state, _ = callbacks[k](cont_steps, V, lam, V, lam, cb_data,
cb_state, cb_args)
if linalg.norm(Sxfr) == 0:
if verbose:
print(
'base case and target case have identical load and generation\n'
)
continuation = 0
V0 = V
lam0 = lam
# tangent predictor z = [dx;dlam]
z = zeros(2 * len(V) + 1)
z[-1] = 1.0
while continuation:
cont_steps = cont_steps + 1
# prediction for next step
V0, lam0, z = cpf_predictor(V, lam, Ybus, Sxfr, pv, pq, step, z, Vprv,
lamprv, parameterization)
# save previous voltage, lambda before updating
Vprv = V
lamprv = lam
# correction
V, success, i, lam = cpf_corrector(Ybus, Sbusb, V0, ref, pv, pq, lam0,
Sxfr, Vprv, lamprv, z, step,
parameterization, ppopt_pf)
if not success:
continuation = 0
if verbose:
print(
'step %3d : lambda = %6.3f, corrector did not converge in %d iterations\n'
% (cont_steps, lam, i))
break
if verbose > 2:
print('step %3d : lambda = %6.3f\n' % (cont_steps, lam))
elif verbose > 1:
print('step %3d : lambda = %6.3f, %2d corrector Newton steps\n' %
(cont_steps, lam, i))
# invoke callbacks
for k in range(len(callbacks)):
cb_state, _ = callbacks[k](cont_steps, V, lam, V0, lam0, cb_data,
cb_state, cb_args)
if isinstance(ppopt["CPF_STOP_AT"], str):
if ppopt["CPF_STOP_AT"].upper() == "FULL":
if abs(lam) < 1e-8: # traced the full continuation curve
if verbose:
print(
'\nTraced full continuation curve in %d continuation steps\n'
% cont_steps)
continuation = 0
elif lam < lamprv and lam - step < 0: # next step will overshoot
step = lam # modify step-size
parameterization = 1 # change to natural parameterization
adapt_step = False # disable step-adaptivity
else: # == 'NOSE'
if lam < lamprv: # reached the nose point
if verbose:
print(
'\nReached steady state loading limit in %d continuation steps\n'
% cont_steps)
continuation = 0
else:
if lam < lamprv:
if verbose:
print(
'\nReached steady state loading limit in %d continuation steps\n'
% cont_steps)
continuation = 0
elif abs(ppopt["CPF_STOP_AT"] -
lam) < 1e-8: # reached desired lambda
if verbose:
print(
'\nReached desired lambda %3.2f in %d continuation steps\n'
% (ppopt["CPF_STOP_AT"], cont_steps))
continuation = 0
# will reach desired lambda in next step
elif lam + step > ppopt["CPF_STOP_AT"]:
step = ppopt["CPF_STOP_AT"] - lam # modify step-size
parameterization = 1 # change to natural parameterization
adapt_step = False # disable step-adaptivity
if adapt_step and continuation:
pvpq = r_[pv, pq]
# Adapt stepsize
cpf_error = linalg.norm(
r_[angle(V[pq]), abs(V[pvpq]), lam] -
r_[angle(V0[pq]), abs(V0[pvpq]), lam0], inf)
if cpf_error < ppopt["CPF_ERROR_TOL"]:
# Increase stepsize
step = step * ppopt["CPF_ERROR_TOL"] / cpf_error
if step > ppopt["CPF_STEP_MAX"]:
step = ppopt["CPF_STEP_MAX"]
else:
# decrese stepsize
step = step * ppopt["CPF_ERROR_TOL"] / cpf_error
if step < ppopt["CPF_STEP_MIN"]:
step = ppopt["CPF_STEP_MIN"]
# invoke callbacks
if success:
cpf_results = {}
for k in range(len(callbacks)):
cb_state, cpf_results = callbacks[k](cont_steps,
V,
lam,
V0,
lam0,
cb_data,
cb_state,
cb_args,
results=cpf_results,
is_final=True)
else:
cpf_results["iterations"] = i
# update bus and gen matrices to reflect the loading and generation
# at the noise point
bust[:, PD] = busb[:, PD] + lam * (bust[:, PD] - busb[:, PD])
bust[:, QD] = busb[:, QD] + lam * (bust[:, QD] - busb[:, QD])
gent[:, PG] = genb[:, PG] + lam * (gent[:, PG] - genb[:, PG])
# update data matrices with solution
bust, gent, brancht = pfsoln(baseMVAt, bust, gent, brancht, Ybus, Yf, Yt,
V, ref, pv, pq)
ppctarget["et"] = time() - t0
ppctarget["success"] = success
# ----- output results -----
# convert back to original bus numbering & print results
ppctarget["bus"], ppctarget["gen"], ppctarget[
"branch"] = bust, gent, brancht
if success:
n = cpf_results["iterations"] + 1
cpf_results["V_p"] = i2e_data(ppctarget, cpf_results["V_p"],
full((nb, n), nan), "bus", 0)
cpf_results["V_c"] = i2e_data(ppctarget, cpf_results["V_c"],
full((nb, n), nan), "bus", 0)
results = int2ext(ppctarget)
results["cpf"] = cpf_results
# zero out result fields of out-of-service gens & branches
if len(results["order"]["gen"]["status"]["off"]) > 0:
results["gen"][ix_(results["order"]["gen"]["status"]["off"],
[PG, QG])] = 0
if len(results["order"]["branch"]["status"]["off"]) > 0:
results["branch"][ix_(results["order"]["branch"]["status"]["off"],
[PF, QF, PT, QT])] = 0
if fname:
fd = None
try:
fd = open(fname, "a")
except Exception as detail:
stderr.write("Error opening %s: %s.\n" % (fname, detail))
finally:
if fd is not None:
printpf(results, fd, ppopt)
fd.close()
else:
printpf(results, stdout, ppopt)
# save solved case
if solvedcase:
savecase(solvedcase, results)
return results, success
def opf_execute(om, ppopt):
"""Executes the OPF specified by an OPF model object.
C{results} are returned with internal indexing, all equipment
in-service, etc.
@see: L{opf}, L{opf_setup}
@author: Ray Zimmerman (PSERC Cornell)
@author: Richard Lincoln
"""
##----- setup -----
## options
dc = ppopt['PF_DC'] ## 1 = DC OPF, 0 = AC OPF
alg = ppopt['OPF_ALG']
verbose = ppopt['VERBOSE']
## build user-defined costs
om.build_cost_params()
## get indexing
vv, ll, nn, _ = om.get_idx()
if verbose > 0:
v = ppver('all')
stdout.write('PYPOWER Version %s, %s' % (v['Version'], v['Date']))
##----- run DC OPF solver -----
if dc:
if verbose > 0:
stdout.write(' -- DC Optimal Power Flow\n')
results, success, raw = dcopf_solver(om, ppopt)
else:
##----- run AC OPF solver -----
if verbose > 0:
stdout.write(' -- AC Optimal Power Flow\n')
## if OPF_ALG not set, choose best available option
if alg == 0:
alg = 560 ## MIPS
## update deprecated algorithm codes to new, generalized formulation equivalents
if alg == 100 | alg == 200: ## CONSTR
alg = 300
elif alg == 120 | alg == 220: ## dense LP
alg = 320
elif alg == 140 | alg == 240: ## sparse (relaxed) LP
alg = 340
elif alg == 160 | alg == 260: ## sparse (full) LP
alg = 360
ppopt['OPF_ALG_POLY'] = alg
## run specific AC OPF solver
if alg == 560 or alg == 565: ## PIPS
results, success, raw = pipsopf_solver(om, ppopt)
elif alg == 580: ## IPOPT # pragma: no cover
try:
__import__('pyipopt')
results, success, raw = ipoptopf_solver(om, ppopt)
except ImportError:
raise ImportError('OPF_ALG %d requires IPOPT '
'(see https://projects.coin-or.org/Ipopt/)' %
alg)
else:
stderr.write(
'opf_execute: OPF_ALG %d is not a valid algorithm code\n' %
alg)
if ('output' not in raw) or ('alg' not in raw['output']):
raw['output']['alg'] = alg
if success:
if not dc:
## copy bus voltages back to gen matrix
results['gen'][:, VG] = results['bus'][
results['gen'][:, GEN_BUS].astype(int), VM]
## gen PQ capability curve multipliers
if (ll['N']['PQh'] > 0) | (ll['N']['PQl'] > 0): # pragma: no cover
mu_PQh = results['mu']['lin']['l'][
ll['i1']['PQh']:ll['iN']['PQh']] - results['mu']['lin'][
'u'][ll['i1']['PQh']:ll['iN']['PQh']]
mu_PQl = results['mu']['lin']['l'][
ll['i1']['PQl']:ll['iN']['PQl']] - results['mu']['lin'][
'u'][ll['i1']['PQl']:ll['iN']['PQl']]
Apqdata = om.userdata('Apqdata')
results['gen'] = update_mupq(results['baseMVA'],
results['gen'], mu_PQh, mu_PQl,
Apqdata)
## compute g, dg, f, df, d2f if requested by RETURN_RAW_DER = 1
if ppopt['RETURN_RAW_DER']: # pragma: no cover
## move from results to raw if using v4.0 of MINOPF or TSPOPF
if 'dg' in results:
raw = {}
raw['dg'] = results['dg']
raw['g'] = results['g']
## compute g, dg, unless already done by post-v4.0 MINOPF or TSPOPF
if 'dg' not in raw:
ppc = om.get_ppc()
Ybus, Yf, Yt = makeYbus(ppc['baseMVA'], ppc['bus'],
ppc['branch'])
g, geq, dg, dgeq = opf_consfcn(results['x'], om, Ybus, Yf,
Yt, ppopt)
raw['g'] = r_[geq, g]
raw['dg'] = r_[dgeq.T, dg.T] ## true Jacobian organization
## compute df, d2f
_, df, d2f = opf_costfcn(results['x'], om, True)
raw['df'] = df
raw['d2f'] = d2f
## delete g and dg fieldsfrom results if using v4.0 of MINOPF or TSPOPF
if 'dg' in results:
del results['dg']
del results['g']
## angle limit constraint multipliers
if ll['N']['ang'] > 0:
iang = om.userdata('iang')
results['branch'][iang, MU_ANGMIN] = results['mu']['lin']['l'][
ll['i1']['ang']:ll['iN']['ang']] * pi / 180
results['branch'][iang, MU_ANGMAX] = results['mu']['lin']['u'][
ll['i1']['ang']:ll['iN']['ang']] * pi / 180
else:
## assign empty g, dg, f, df, d2f if requested by RETURN_RAW_DER = 1
if not dc and ppopt['RETURN_RAW_DER']:
raw['dg'] = array([])
raw['g'] = array([])
raw['df'] = array([])
raw['d2f'] = array([])
## assign values and limit shadow prices for variables
if om.var['order']:
results['var'] = {'val': {}, 'mu': {'l': {}, 'u': {}}}
for name in om.var['order']:
if om.getN('var', name):
idx = arange(vv['i1'][name], vv['iN'][name])
results['var']['val'][name] = results['x'][idx]
results['var']['mu']['l'][name] = results['mu']['var']['l'][idx]
results['var']['mu']['u'][name] = results['mu']['var']['u'][idx]
## assign shadow prices for linear constraints
if om.lin['order']:
results['lin'] = {'mu': {'l': {}, 'u': {}}}
for name in om.lin['order']:
if om.getN('lin', name):
idx = arange(ll['i1'][name], ll['iN'][name])
results['lin']['mu']['l'][name] = results['mu']['lin']['l'][idx]
results['lin']['mu']['u'][name] = results['mu']['lin']['u'][idx]
## assign shadow prices for nonlinear constraints
if not dc:
if om.nln['order']:
results['nln'] = {'mu': {'l': {}, 'u': {}}}
for name in om.nln['order']:
if om.getN('nln', name):
idx = arange(nn['i1'][name], nn['iN'][name])
results['nln']['mu']['l'][name] = results['mu']['nln']['l'][
idx]
results['nln']['mu']['u'][name] = results['mu']['nln']['u'][
idx]
## assign values for components of user cost
if om.cost['order']:
results['cost'] = {}
for name in om.cost['order']:
if om.getN('cost', name):
results['cost'][name] = om.compute_cost(results['x'], name)
## if single-block PWL costs were converted to POLY, insert dummy y into x
## Note: The "y" portion of x will be nonsense, but everything should at
## least be in the expected locations.
pwl1 = om.userdata('pwl1')
if (len(pwl1) > 0) and (alg != 545) and (alg != 550):
## get indexing
vv, _, _, _ = om.get_idx()
if dc:
nx = vv['iN']['Pg']
else:
nx = vv['iN']['Qg']
y = zeros(len(pwl1))
raw['xr'] = r_[raw['xr'][:nx], y, raw['xr'][nx:]]
results['x'] = r_[results['x'][:nx], y, results['x'][nx:]]
return results, success, raw
def opf_execute(om, ppopt):
"""Executes the OPF specified by an OPF model object.
C{results} are returned with internal indexing, all equipment
in-service, etc.
@see: L{opf}, L{opf_setup}
@author: Ray Zimmerman (PSERC Cornell)
"""
##----- setup -----
## options
dc = ppopt['PF_DC'] ## 1 = DC OPF, 0 = AC OPF
alg = ppopt['OPF_ALG']
verbose = ppopt['VERBOSE']
## build user-defined costs
om.build_cost_params()
## get indexing
vv, ll, nn, _ = om.get_idx()
if verbose > 0:
v = ppver('all')
stdout.write('PYPOWER Version %s, %s' % (v['Version'], v['Date']))
##----- run DC OPF solver -----
if dc:
if verbose > 0:
stdout.write(' -- DC Optimal Power Flow\n')
results, success, raw = dcopf_solver(om, ppopt)
else:
##----- run AC OPF solver -----
if verbose > 0:
stdout.write(' -- AC Optimal Power Flow\n')
## if OPF_ALG not set, choose best available option
if alg == 0:
alg = 560 ## MIPS
## update deprecated algorithm codes to new, generalized formulation equivalents
if alg == 100 | alg == 200: ## CONSTR
alg = 300
elif alg == 120 | alg == 220: ## dense LP
alg = 320
elif alg == 140 | alg == 240: ## sparse (relaxed) LP
alg = 340
elif alg == 160 | alg == 260: ## sparse (full) LP
alg = 360
ppopt['OPF_ALG_POLY'] = alg
## run specific AC OPF solver
if alg == 560 or alg == 565: ## PIPS
results, success, raw = pipsopf_solver(om, ppopt)
elif alg == 580: ## IPOPT
try:
__import__('pyipopt')
results, success, raw = ipoptopf_solver(om, ppopt)
except ImportError:
raise ImportError('OPF_ALG %d requires IPOPT '
'(see https://projects.coin-or.org/Ipopt/)' %
alg)
else:
stderr.write('opf_execute: OPF_ALG %d is not a valid algorithm code\n' % alg)
if ('output' not in raw) or ('alg' not in raw['output']):
raw['output']['alg'] = alg
if success:
if not dc:
## copy bus voltages back to gen matrix
results['gen'][:, VG] = results['bus'][results['gen'][:, GEN_BUS].astype(int), VM]
## gen PQ capability curve multipliers
if (ll['N']['PQh'] > 0) | (ll['N']['PQl'] > 0):
mu_PQh = results['mu']['lin']['l'][ll['i1']['PQh']:ll['iN']['PQh']] - results['mu']['lin']['u'][ll['i1']['PQh']:ll['iN']['PQh']]
mu_PQl = results['mu']['lin']['l'][ll['i1']['PQl']:ll['iN']['PQl']] - results['mu']['lin']['u'][ll['i1']['PQl']:ll['iN']['PQl']]
Apqdata = om.userdata('Apqdata')
results['gen'] = update_mupq(results['baseMVA'], results['gen'], mu_PQh, mu_PQl, Apqdata)
## compute g, dg, f, df, d2f if requested by RETURN_RAW_DER = 1
if ppopt['RETURN_RAW_DER']:
## move from results to raw if using v4.0 of MINOPF or TSPOPF
if 'dg' in results:
raw = {}
raw['dg'] = results['dg']
raw['g'] = results['g']
## compute g, dg, unless already done by post-v4.0 MINOPF or TSPOPF
if 'dg' not in raw:
ppc = om.get_ppc()
Ybus, Yf, Yt = makeYbus(ppc['baseMVA'], ppc['bus'], ppc['branch'])
g, geq, dg, dgeq = opf_consfcn(results['x'], om, Ybus, Yf, Yt, ppopt)
raw['g'] = r_[geq, g]
raw['dg'] = r_[dgeq.T, dg.T] ## true Jacobian organization
## compute df, d2f
_, df, d2f = opf_costfcn(results['x'], om, True)
raw['df'] = df
raw['d2f'] = d2f
## delete g and dg fieldsfrom results if using v4.0 of MINOPF or TSPOPF
if 'dg' in results:
del results['dg']
del results['g']
## angle limit constraint multipliers
if ll['N']['ang'] > 0:
iang = om.userdata('iang')
results['branch'][iang, MU_ANGMIN] = results['mu']['lin']['l'][ll['i1']['ang']:ll['iN']['ang']] * pi / 180
results['branch'][iang, MU_ANGMAX] = results['mu']['lin']['u'][ll['i1']['ang']:ll['iN']['ang']] * pi / 180
else:
## assign empty g, dg, f, df, d2f if requested by RETURN_RAW_DER = 1
if not dc and ppopt['RETURN_RAW_DER']:
raw['dg'] = array([])
raw['g'] = array([])
raw['df'] = array([])
raw['d2f'] = array([])
## assign values and limit shadow prices for variables
if om.var['order']:
results['var'] = {'val': {}, 'mu': {'l': {}, 'u': {}}}
for name in om.var['order']:
if om.getN('var', name):
idx = arange(vv['i1'][name], vv['iN'][name])
results['var']['val'][name] = results['x'][idx]
results['var']['mu']['l'][name] = results['mu']['var']['l'][idx]
results['var']['mu']['u'][name] = results['mu']['var']['u'][idx]
## assign shadow prices for linear constraints
if om.lin['order']:
results['lin'] = {'mu': {'l': {}, 'u': {}}}
for name in om.lin['order']:
if om.getN('lin', name):
idx = arange(ll['i1'][name], ll['iN'][name])
results['lin']['mu']['l'][name] = results['mu']['lin']['l'][idx]
results['lin']['mu']['u'][name] = results['mu']['lin']['u'][idx]
## assign shadow prices for nonlinear constraints
if not dc:
if om.nln['order']:
results['nln'] = {'mu': {'l': {}, 'u': {}}}
for name in om.nln['order']:
if om.getN('nln', name):
idx = arange(nn['i1'][name], nn['iN'][name])
results['nln']['mu']['l'][name] = results['mu']['nln']['l'][idx]
results['nln']['mu']['u'][name] = results['mu']['nln']['u'][idx]
## assign values for components of user cost
if om.cost['order']:
results['cost'] = {}
for name in om.cost['order']:
if om.getN('cost', name):
results['cost'][name] = om.compute_cost(results['x'], name)
## if single-block PWL costs were converted to POLY, insert dummy y into x
## Note: The "y" portion of x will be nonsense, but everything should at
## least be in the expected locations.
pwl1 = om.userdata('pwl1')
if (len(pwl1) > 0) and (alg != 545) and (alg != 550):
## get indexing
vv, _, _, _ = om.get_idx()
if dc:
nx = vv['iN']['Pg']
else:
nx = vv['iN']['Qg']
y = zeros(len(pwl1))
raw['xr'] = r_[raw['xr'][:nx], y, raw['xr'][nx:]]
results['x'] = r_[results['x'][:nx], y, results['x'][nx:]]
return results, success, raw
