def _run_newton_raphson_pf(ppci, options): """ Runs a Newton-Raphson power flow. INPUT ppci (dict) - the "internal" ppc (without out ot service elements and sorted elements) options(dict) - options for the power flow """ t0 = perf_counter() # we cannot run DC pf before running newton with distributed slack because the slacks come pre-solved after the DC pf if isinstance(options["init_va_degree"], str) and options["init_va_degree"] == "dc": if options['distributed_slack']: pg_copy = ppci['gen'][:, PG].copy() pd_copy = ppci['bus'][:, PD].copy() ppci = _run_dc_pf(ppci) ppci['gen'][:, PG] = pg_copy ppci['bus'][:, PD] = pd_copy else: ppci = _run_dc_pf(ppci) if options["enforce_q_lims"]: ppci, success, iterations, bus, gen, branch = _run_ac_pf_with_qlims_enforced( ppci, options) else: ppci, success, iterations = _run_ac_pf_without_qlims_enforced( ppci, options) # update data matrices with solution store in ppci bus, gen, branch = ppci_to_pfsoln(ppci, options) et = perf_counter() - t0 ppci = _store_results_from_pf_in_ppci(ppci, bus, gen, branch, success, iterations, et) return ppci
def _run_pf_algorithm(ppci, options, **kwargs): algorithm = options["algorithm"] ac = options["ac"] if ac: _, pv, pq = bustypes(ppci["bus"], ppci["gen"]) # ----- run the powerflow ----- if pq.shape[0] == 0 and pv.shape[ 0] == 0 and not options['distributed_slack']: # ommission not correct if distributed slack is used result = _bypass_pf_and_set_results(ppci, options) elif algorithm == 'bfsw': # forward/backward sweep power flow algorithm result = _run_bfswpf(ppci, options, **kwargs)[0] elif algorithm in ['nr', 'iwamoto_nr']: result = _run_newton_raphson_pf(ppci, options) elif algorithm in ['fdbx', 'fdxb', 'gs']: # algorithms existing within pypower result = _runpf_pypower(ppci, options, **kwargs)[0] else: raise AlgorithmUnknown( "Algorithm {0} is unknown!".format(algorithm)) else: result = _run_dc_pf(ppci) return result
def _run_newton_raphson_pf(ppci, options): """ Runs a Newton-Raphson power flow. INPUT ppci (dict) - the "internal" ppc (without out ot service elements and sorted elements) options(dict) - options for the power flow """ t0 = time() if isinstance(options["init_va_degree"], str) and options["init_va_degree"] == "dc": ppci = _run_dc_pf(ppci) if options["enforce_q_lims"]: ppci, success, iterations, bus, gen, branch = _run_ac_pf_with_qlims_enforced( ppci, options) else: ppci, success, iterations = _run_ac_pf_without_qlims_enforced( ppci, options) # update data matrices with solution store in ppci bus, gen, branch = ppci_to_pfsoln(ppci, options) et = time() - t0 ppci = _store_results_from_pf_in_ppci(ppci, bus, gen, branch, success, iterations, et) return ppci
def _recycled_powerflow(net, **kwargs): options = net["_options"] options["recycle"] = kwargs.get("recycle", None) options["init_vm_pu"] = "results" options["init_va_degree"] = "results" algorithm = options["algorithm"] ac = options["ac"] ppci = {"bus": net["_ppc"]["internal"]["bus"], "gen": net["_ppc"]["internal"]["gen"], "branch": net["_ppc"]["internal"]["branch"], "baseMVA": net["_ppc"]["internal"]["baseMVA"], "internal": net["_ppc"]["internal"], } if not ac: # DC recycle result = _run_dc_pf(ppci) _ppci_to_net(result, net) return if algorithm not in ['nr', 'iwamoto_nr'] and ac: raise ValueError("recycle is only available with Newton-Raphson power flow. Choose " "algorithm='nr'") recycle = options["recycle"] ppc = net["_ppc"] ppc["success"] = False ppc["iterations"] = 0. ppc["et"] = 0. if "bus_pq" in recycle and recycle["bus_pq"]: # update pq values in bus _calc_pq_elements_and_add_on_ppc(net, ppc) if "trafo" in recycle and recycle["trafo"]: # update trafo in branch and Ybus lookup = net._pd2ppc_lookups["branch"] if "trafo" in lookup: _calc_trafo_parameter(net, ppc) if "trafo3w" in lookup: _calc_trafo3w_parameter(net, ppc) if "gen" in recycle and recycle["gen"]: # updates the ppc["gen"] part _build_gen_ppc(net, ppc) ppc["gen"] = nan_to_num(ppc["gen"]) ppci = _ppc2ppci(ppc, net, ppci=ppci) ppci["internal"] = net["_ppc"]["internal"] net["_ppc"] = ppc # run the Newton-Raphson power flow result = _run_newton_raphson_pf(ppci, options) ppc["success"] = ppci["success"] ppc["iterations"] = ppci["iterations"] ppc["et"] = ppci["et"] if options["only_v_results"]: _ppci_bus_to_ppc(result, ppc) _ppci_other_to_ppc(result, ppc, options["mode"]) return # read the results from result (==ppci) to net _ppci_to_net(result, net)
def _run_newton_raphson_pf(ppci, options): """Runs a newton raphson power flow. """ ##----- run the power flow ----- t0 = time() init = options["init"] if init == "dc": ppci = _run_dc_pf(ppci) ppci, success = _nr_ac_pf(ppci, options) ppci["et"] = time() - t0 ppci["success"] = success return ppci
def _run_pf_algorithm(ppci, options, **kwargs): algorithm = options["algorithm"] ac = options["ac"] if ac: # ----- run the powerflow ----- if algorithm == 'bfsw': # forward/backward sweep power flow algorithm result = _run_bfswpf(ppci, options, **kwargs)[0] elif algorithm == 'nr': result = _run_newton_raphson_pf(ppci, options) elif algorithm in ['fdbx', 'fdxb', 'gs']: # algorithms existing within pypower result = _runpf_pypower(ppci, options, **kwargs)[0] else: raise AlgorithmUnknown("Algorithm {0} is unknown!".format(algorithm)) else: result = _run_dc_pf(ppci) return result
def _run_newton_raphson_pf(ppci, options): """Runs a newton raphson power flow. """ ##----- run the power flow ----- t0 = time() if options["init_va_degree"] == "dc": ppci = _run_dc_pf(ppci) if options["enforce_q_lims"]: ppci, success, iterations, bus, gen, branch = _run_ac_pf_with_qlims_enforced( ppci, options) else: ppci, success, iterations, bus, gen, branch = _run_ac_pf_without_qlims_enforced( ppci, options) et = time() - t0 ppci = _store_results_from_pf_in_ppci(ppci, bus, gen, branch, success, iterations, et) return ppci
def _run_fast_decoupled_pf(ppci, options): """ This is a modified version of _run_newton_raphson to run fast decoupled algorithms. """ t0 = time() if options["init_va_degree"] == "dc": ppci = _run_dc_pf(ppci) if options["enforce_q_lims"]: ppci, success, iterations, bus, gen, branch = \ _run_ac_pf_with_qlims_enforced(ppci, options) else: ppci, success, iterations = \ _run_ac_pf_without_qlims_enforced(ppci, options) # update data matrices with the solution stores in ppci bus, gen, branch = ppci_to_pfsoln(ppci, options) et = time() - t0 ppci = _store_results_from_pf_in_ppci(ppci, bus, gen, branch, success, iterations, et) return ppci
def _run_pf_algorithm(ppci, options, **kwargs): algorithm = options["algorithm"] ac = options["ac"] if ac: # ----- run the powerflow ----- if ppci["branch"].shape[0] == 0: result = _pf_without_branches(ppci, options) elif algorithm == 'bfsw': # forward/backward sweep power flow algorithm result = _run_bfswpf(ppci, options, **kwargs)[0] elif algorithm in ['nr', 'iwamoto_nr']: result = _run_newton_raphson_pf(ppci, options) elif algorithm in ['fdbx', 'fdxb']: # fdbx/xb new algos # this implematation will much like be the newton_raphson result = _run_fast_decoupled_pf(ppci, options) elif algorithm == 'gs': # last algorithm imported from pypower result = _runpf_pypower(ppci, options, **kwargs)[0] else: raise AlgorithmUnknown( "Algorithm {0} is unknown!".format(algorithm)) else: result = _run_dc_pf(ppci) return result