def _optimal_powerflow(net, verbose, suppress_warnings, **kwargs):
ac = net["_options"]["ac"]
ppopt = ppoption(VERBOSE=verbose, OPF_FLOW_LIM=2, PF_DC=not ac, **kwargs)
net["OPF_converged"] = False
net["converged"] = False
_add_auxiliary_elements(net)
reset_results(net)
ppc, ppci = _pd2ppc(net)
if not ac:
ppci["bus"][:, VM] = 1.0
net["_ppc_opf"] = ppc
if len(net.dcline) > 0:
ppci = add_userfcn(ppci, 'formulation', _add_dcline_constraints, args=net)
if suppress_warnings:
with warnings.catch_warnings():
warnings.simplefilter("ignore")
result = opf(ppci, ppopt)
else:
result = opf(ppci, ppopt)
net["_ppc_opf"] = result
if not result["success"]:
raise OPFNotConverged("Optimal Power Flow did not converge!")
# ppci doesn't contain out of service elements, but ppc does -> copy results accordingly
mode = net["_options"]["mode"]
result = _copy_results_ppci_to_ppc(result, ppc, mode=mode)
net["_ppc_opf"] = result
net["OPF_converged"] = True
_extract_results_opf(net, result)
_clean_up(net)
def _calc_sc_1ph(net):
"""
calculation method for single phase to ground short-circuit currents
"""
_add_auxiliary_elements(net)
# pos. seq bus impedance
ppc, ppci = _pd2ppc(net)
_calc_ybus(ppci)
try:
_calc_zbus(ppci)
except Exception as e:
_clean_up(net, res=False)
raise(e)
_calc_rx(net, ppci)
_add_kappa_to_ppc(net, ppci)
# zero seq bus impedance
ppc_0, ppci_0 = _pd2ppc_zero(net)
_calc_ybus(ppci_0)
try:
_calc_zbus(ppci_0)
except Exception as e:
_clean_up(net, res=False)
raise(e)
_calc_rx(net, ppci_0)
_calc_ikss_1ph(net, ppci, ppci_0)
ppc_0 = _copy_results_ppci_to_ppc(ppci_0, ppc_0, "sc")
ppc = _copy_results_ppci_to_ppc(ppci, ppc, "sc")
_extract_results(net, ppc, ppc_0)
_clean_up(net)
def _calc_sc(net):
# t0 = time.perf_counter()
_add_auxiliary_elements(net)
ppc, ppci = _pd2ppc(net)
# t1 = time.perf_counter()
_calc_ybus(ppci)
# t2 = time.perf_counter()
try:
_calc_zbus(ppci)
except Exception as e:
_clean_up(net, res=False)
raise(e)
_calc_rx(net, ppci)
# t3 = time.perf_counter()
_add_kappa_to_ppc(net, ppci)
# t4 = time.perf_counter()
_calc_ikss(net, ppci)
if net["_options"]["ip"]:
_calc_ip(net, ppci)
if net["_options"]["ith"]:
_calc_ith(net, ppci)
if net._options["branch_results"]:
_calc_branch_currents(net, ppci)
ppc = _copy_results_ppci_to_ppc(ppci, ppc, "sc")
_extract_results(net, ppc, ppc_0=None)
_clean_up(net)
def init_timeseries_newton(self):
"""
This function is called in the first iteration and variables needed in every loop are stored (Ybus, ppci...)
@param net:
@return:
"""
self.init_newton_variables()
net = self.net
# get ppc and ppci
# pp.runpp(net, init_vm_pu="flat", init_va_degree="dc")
# pp.runpp(net, init_vm_pu="results", init_va_degree="results")
pp.runpp(net, init="dc")
pp.runpp(net, init="results")
net._options["init_results"] = True
net._options["init_vm_pu"] = "results"
net._options["init_va_degree"] = "results"
options = net._options
_add_auxiliary_elements(net)
self.ppc, self.ppci = _pd2ppc(net)
net["_ppc"] = self.ppc
self.baseMVA, bus, gen, branch, self.ref, self.pv, self.pq, _, _, self.V, self.ref_gens = \
nr_pf._get_pf_variables_from_ppci(self.ppci)
self.ppci, self.Ybus, self.Yf, self.Yt = \
nr_pf._get_Y_bus(self.ppci, options, nr_pf.makeYbus_numba, self.baseMVA, bus, branch)
self.Ibus = zeros(len(self.V), dtype=complex128)
# self.Cg = _get_Cg(gen, bus) # assumes that all gens are on!
if "controller" in net:
self.get_update_ctrl()
return net
def _calc_sc(net):
# t0 = time.perf_counter()
_add_auxiliary_elements(net)
ppc, ppci = _pd2ppc(net)
# t1 = time.perf_counter()
_calc_ybus(ppci)
# t2 = time.perf_counter()
_calc_zbus(ppci)
_calc_rx(net, ppci)
# t3 = time.perf_counter()
_add_kappa_to_ppc(net, ppci)
# t4 = time.perf_counter()
_calc_ikss(net, ppci)
if net["_options"]["ip"]:
_calc_ip(net, ppci)
if net["_options"]["ith"]:
_calc_ith(net, ppci)
if net._options["branch_results"]:
_calc_branch_currents(net, ppci)
ppc = _copy_results_ppci_to_ppc(ppci, ppc, "sc")
_extract_results(net, ppc)
_clean_up(net)
# t5 = time.perf_counter()
# net._et = {"sum": t5-t0, "model": t1-t0, "ybus": t2-t1, "zbus": t3-t2, "kappa": t4-t3,
# "currents": t5-t4}
def _calc_sc(net):
# net["_is_elements"] = _select_is_elements(net)
_add_auxiliary_elements(net)
ppc, ppci = _pd2ppc(net)
_calc_equiv_sc_impedance(net, ppci)
_add_kappa_to_ppc(net, ppci)
_calc_ikss(net, ppci)
_calc_ip(ppci)
_calc_ith(net, ppci)
ppc = _copy_results_ppci_to_ppc(ppci, ppc, "sc")
_extract_results(net, ppc)
_clean_up(net)
def _runpm(net, julia_file=None, pp_to_pm_callback=None):
net["OPF_converged"] = False
net["converged"] = False
_add_auxiliary_elements(net)
reset_results(net)
ppc, ppci = _pd2ppc(net)
pm = ppc_to_pm(net, ppci)
net._pm = pm
if pp_to_pm_callback is not None:
pp_to_pm_callback(net, ppci, pm)
result_pm = _call_powermodels(pm, julia_file)
net._result_pm = result_pm
result = pm_results_to_ppc_results(net, ppc, ppci, result_pm)
success = ppc["success"]
net["_ppc_opf"] = ppci
if success:
_extract_results_opf(net, result)
_clean_up(net)
net["OPF_converged"] = True
else:
_clean_up(net)
logger.warning("OPF did not converge!")