Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
def convert_to_pm_structure(net):
net["OPF_converged"] = False
net["converged"] = False
_add_auxiliary_elements(net)
reset_results(net)
ppc, ppci = _pd2ppc(net)
ppci = build_ne_branch(net, ppci)
net["_ppc_opf"] = ppci
pm = ppc_to_pm(net, ppci)
pm = add_pm_options(pm, net)
net._pm = pm
return net, pm, ppc, ppci
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"]:
def _init_ppc(net, v_start, delta_start, calculate_voltage_angles):
# select elements in service and convert pandapower ppc to ppc
net._options = {}
_add_ppc_options(net, check_connectivity=False, init_vm_pu=v_start, init_va_degree=delta_start,
trafo_model="pi", mode="pf", enforce_q_lims=False,
calculate_voltage_angles=calculate_voltage_angles, switch_rx_ratio=2,
recycle=dict(_is_elements=False, ppc=False, Ybus=False))
net["_is_elements"] = _select_is_elements_numba(net)
_add_auxiliary_elements(net)
ppc, ppci = _pd2ppc(net)
# do dc power flow for phase shifting transformers
if np.any(net.trafo.shift_degree):
vm_backup = ppci["bus"][:, 7].copy()
ppci["bus"][:, [2, 3]] = 0.
ppci = _run_dc_pf(ppci)
ppci["bus"][:, 7] = vm_backup
return ppc, ppci
pp.create_std_type(net, {"r0_ohm_per_km" : .1005, "x0_ohm_per_km" : 0.4900884
, "c0_nf_per_km": 200.5, "max_i_ka" : 0.89
, "r_ohm_per_km": .0251, "x_ohm_per_km" : 0.1225221
, "c_nf_per_km" : 210}, "example_type4")
pp.create_line(net, from_bus = busn, to_bus = busm, length_km = 1.0, std_type="example_type3")
pp.create_line(net, from_bus = busn, to_bus = busp, length_km = 1.0, std_type="example_type3")
pp.create_line(net, from_bus = busn, to_bus = busk, length_km = 1.0, std_type="example_type4")
pp.create_line(net, from_bus = busk, to_bus = busm, length_km = 1.0, std_type="example_type1")
pp.create_line(net, from_bus = busk, to_bus = busp, length_km = 1.0, std_type="example_type2")
pp.add_zero_impedance_parameters(net)
net._options = {'calculate_voltage_angles': 'auto', 'check_connectivity': True, 'init': 'auto',
'r_switch': 0.0,'voltage_depend_loads': False, 'mode': "pf",'copy_constraints_to_ppc': False}
_, ppci1 = _pd2ppc(net)
_, ppci2 = _pd2ppc(net)
_add_ext_grid_sc_impedance(net, ppci2)
_, ppci0 = _pd2ppc_zero(net)
ppci0['bus'][0,4] = 0
ppci0['bus'][0,5] = 0
ppci1['bus'][0,4] = 0
ppci1['bus'][0,5] = 0
ppci2['bus'][0,4] = 0
ppci2['bus'][0,5] = 0
Y0_pu,_,_ = makeYbus(ppci0["baseMVA"], ppci0["bus"], ppci0["branch"])
Y1_pu,_,_ = makeYbus(ppci1["baseMVA"], ppci1["bus"], ppci1["branch"])
def _init_ppc_logging(self, table, variable, index, eval_function, eval_name):
var_name = self._get_output_name(table, variable)
ppc = self.net["_ppc"]
if ppc is None:
# if no ppc is in net-> create one
options = dict(algorithm='nr', calculate_voltage_angles="auto", init="auto",
max_iteration="auto", tolerance_mva=1e-8, trafo_model="t",
trafo_loading="current", enforce_q_lims=False, check_connectivity=True,
voltage_depend_loads=True, consider_line_temperature=False)
_init_runpp_options(self.net, **options)
ppc, _ = _pd2ppc(self.net)
self.net["_ppc"] = ppc
index = list(range(sum(ppc['bus'][:, BUS_TYPE] != NONE)))
self._append_output_list(table, variable, index, eval_function, eval_name, var_name, func=self._log_ppc)
return index
enforce_q_lims=enforce_q_lims, recycle=recycle,
voltage_depend_loads=False, delta=delta_q,\
neglect_open_switch_branches=neglect_open_switch_branches
)
_add_pf_options(net, tolerance_mva=tolerance_mva, trafo_loading=trafo_loading,
numba=numba, ac=ac, algorithm="nr", max_iteration=max_iteration,\
only_v_results=only_v_results,v_debug=v_debug)
net._options.update(overrule_options)
_check_bus_index_and_print_warning_if_high(net)
_check_gen_index_and_print_warning_if_high(net)
reset_results(net, balanced=False)
# =========================================================================
# pd2ppc conversion
# =========================================================================
net["_is_elements"] = None
_, ppci1 = _pd2ppc(net, 1)
_, ppci2 = _pd2ppc(net, 2)
gs_eg, bs_eg = _add_ext_grid_sc_impedance(net, ppci2)
_, ppci0 = _pd2ppc(net, 0)
_, bus0, gen0, branch0, _, _, _, _, _,\
v00, ref_gens = _get_pf_variables_from_ppci(ppci0)
base_mva, bus1, gen1, branch1, sl_bus, pv_bus, pq_bus, _, _, \
v01, ref_gens = _get_pf_variables_from_ppci(ppci1)
_, bus2, gen2, branch2, _, _, _, _, _, \
v02, ref_gens = _get_pf_variables_from_ppci(ppci2)
# =============================================================================
# P Q values aggragated and summed up for each bus to make s_abc matrix
# s_abc for wye connections ; s_abc_delta for delta connection
@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