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