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
