def _pd2ppc_recycle(net, sequence, recycle):
key = "_ppc" if sequence is None else "_ppc%d" % sequence
if not recycle or not net.get(key, None):
return _pd2ppc(net, sequence=sequence)
ppc = net[key]
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, sequence=sequence)
# 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"] = np.nan_to_num(ppc["gen"])
ppci = _ppc2ppci(ppc, net)
ppci["internal"] = net[key]["internal"]
net[key] = ppc
return ppc, ppci
def _pd2ppc_zero(net):
"""
Builds the ppc data structure for zero impedance system. Includes the impedance values of
lines and transformers, but no load or generation data.
For short-circuit calculation, the short-circuit impedance of external grids is also considered.
"""
# select elements in service (time consuming, so we do it once)
net["_is_elements"] = aux._select_is_elements_numba(net)
ppc = _init_ppc(net)
# init empty ppci
ppci = copy.deepcopy(ppc)
_build_bus_ppc(net, ppc)
_build_gen_ppc(net, ppc)
_add_ext_grid_sc_impedance_zero(net, ppc)
_build_branch_ppc_zero(net, ppc)
# adds auxilary buses for open switches at branches
_switch_branches(net, ppc)
# add auxilary buses for out of service buses at in service lines.
# Also sets lines out of service if they are connected to two out of service buses
_branches_with_oos_buses(net, ppc)
if hasattr(net, "_isolated_buses"):
ppc["bus"][net._isolated_buses, 1] = 4.
# generates "internal" ppci format (for powerflow calc) from "external" ppc format and updates the bus lookup
# Note: Also reorders buses and gens in ppc
ppci = _ppc2ppci(ppc, ppci, net)
net._ppc0 = ppc
return ppc, 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 _pd2ppc(net, sequence=None):
"""
Converter Flow:
1. Create an empty pypower datatructure
2. Calculate loads and write the bus matrix
3. Build the gen (Infeeder)- Matrix
4. Calculate the line parameter and the transformer parameter,
and fill it in the branch matrix.
Order: 1st: Line values, 2nd: Trafo values
5. if opf: make opf objective (gencost)
6. convert internal ppci format for pypower powerflow /
opf without out of service elements and rearanged buses
INPUT:
**net** - The pandapower format network
**sequence** - Used for three phase analysis
( 0 - Zero Sequence
1 - Positive Sequence
2 - Negative Sequence
)
OUTPUT:
**ppc** - The simple matpower format network. Which consists of:
ppc = {
"baseMVA": 1., *float*
"version": 2, *int*
"bus": np.array([], dtype=float),
"branch": np.array([], dtype=np.complex128),
"gen": np.array([], dtype=float),
"gencost" = np.array([], dtype=float), only for OPF
"internal": {
"Ybus": np.array([], dtype=np.complex128)
, "Yf": np.array([], dtype=np.complex128)
, "Yt": np.array([], dtype=np.complex128)
, "branch_is": np.array([], dtype=bool)
, "gen_is": np.array([], dtype=bool)
}
**ppci** - The "internal" pypower format network for PF calculations
"""
# select elements in service (time consuming, so we do it once)
net["_is_elements"] = aux._select_is_elements_numba(net, sequence=sequence)
# Gets network configurations
mode = net["_options"]["mode"]
check_connectivity = net["_options"]["check_connectivity"]
calculate_voltage_angles = net["_options"]["calculate_voltage_angles"]
ppc = _init_ppc(net, mode=mode, sequence=sequence)
# generate ppc['bus'] and the bus lookup
_build_bus_ppc(net, ppc)
if sequence == 0:
from pandapower.pd2ppc_zero import _add_ext_grid_sc_impedance_zero, _build_branch_ppc_zero
# Adds external grid impedance for 3ph and sc calculations in ppc0
_add_ext_grid_sc_impedance_zero(net, ppc)
# Calculates ppc0 branch impedances from branch elements
_build_branch_ppc_zero(net, ppc)
else:
# Calculates ppc1/ppc2 branch impedances from branch elements
_build_branch_ppc(net, ppc)
# Adds P and Q for loads / sgens in ppc['bus'] (PQ nodes)
if mode == "sc":
_add_gen_impedances_ppc(net, ppc)
_add_motor_impedances_ppc(net, ppc)
else:
_calc_pq_elements_and_add_on_ppc(net, ppc, sequence=sequence)
# adds P and Q for shunts, wards and xwards (to PQ nodes)
_calc_shunts_and_add_on_ppc(net, ppc)
# adds auxilary buses for open switches at branches
_switch_branches(net, ppc)
# Adds auxilary buses for in service lines with out of service buses.
# Also deactivates lines if they are connected to two out of service buses
_branches_with_oos_buses(net, ppc)
if check_connectivity:
if sequence in [None, 1, 2]:
# sets islands (multiple isolated nodes) out of service
if "opf" in mode:
net["_isolated_buses"], _, _ = aux._check_connectivity_opf(ppc)
else:
net["_isolated_buses"], _, _ = aux._check_connectivity(ppc)
net["_is_elements_final"] = aux._select_is_elements_numba(
net, net._isolated_buses, sequence)
else:
ppc["bus"][net._isolated_buses, BUS_TYPE] = NONE
net["_is_elements"] = net["_is_elements_final"]
else:
# sets buses out of service, which aren't connected to branches / REF buses
aux._set_isolated_buses_out_of_service(net, ppc)
_build_gen_ppc(net, ppc)
if "pf" in mode:
_check_for_reference_bus(ppc)
aux._replace_nans_with_default_limits(net, ppc)
# generates "internal" ppci format (for powerflow calc)
# from "external" ppc format and updates the bus lookup
# Note: Also reorders buses and gens in ppc
ppci = _ppc2ppci(ppc, net)
if mode == "pf":
# check if any generators connected to the same bus have different voltage setpoints
_check_voltage_setpoints_at_same_bus(ppc)
if calculate_voltage_angles:
_check_voltage_angles_at_same_bus(net, ppci)
if mode == "opf":
# make opf objective
ppci = _make_objective(ppci, net)
return ppc, ppci
def _pd2ppc(net):
"""
Converter Flow:
1. Create an empty pypower datatructure
2. Calculate loads and write the bus matrix
3. Build the gen (Infeeder)- Matrix
4. Calculate the line parameter and the transformer parameter,
and fill it in the branch matrix.
Order: 1st: Line values, 2nd: Trafo values
5. if opf: make opf objective (gencost)
6. convert internal ppci format for pypower powerflow / opf without out of service elements and rearanged buses
INPUT:
**net** - The pandapower format network
OUTPUT:
**ppc** - The simple matpower format network. Which consists of:
ppc = {
"baseMVA": 1., *float*
"version": 2, *int*
"bus": np.array([], dtype=float),
"branch": np.array([], dtype=np.complex128),
"gen": np.array([], dtype=float),
"gencost" = np.array([], dtype=float), only for OPF
"internal": {
"Ybus": np.array([], dtype=np.complex128)
, "Yf": np.array([], dtype=np.complex128)
, "Yt": np.array([], dtype=np.complex128)
, "branch_is": np.array([], dtype=bool)
, "gen_is": np.array([], dtype=bool)
}
**ppci** - The "internal" pypower format network for PF calculations
"""
# select elements in service (time consuming, so we do it once)
use_numba = ("numba" in net["_options"] and net["_options"]["numba"] and
(net["_options"]["recycle"] is None or
not net["_options"]["recycle"]["_is_elements"]))
#use_numba = False
if use_numba:
net["_is_elements"] = aux._select_is_elements_numba(net)
else:
net["_is_elements"] = aux._select_is_elements(net)
# get options
mode = net["_options"]["mode"]
check_connectivity = net["_options"]["check_connectivity"]
ppc = _init_ppc(net)
if mode == "opf":
# additional fields in ppc
ppc["gencost"] = np.array([], dtype=float)
# init empty ppci
ppci = copy.deepcopy(ppc)
# generate ppc['bus'] and the bus lookup
_build_bus_ppc(net, ppc)
# generate ppc['gen'] and fills ppc['bus'] with generator values (PV, REF nodes)
_build_gen_ppc(net, ppc)
# generate ppc['branch'] and directly generates branch values
_build_branch_ppc(net, ppc)
# adds P and Q for loads / sgens in ppc['bus'] (PQ nodes)
if mode == "sc":
_add_gen_impedances_ppc(net, ppc)
_add_motor_impedances_ppc(net, ppc)
else:
_calc_loads_and_add_on_ppc(net, ppc)
# adds P and Q for shunts, wards and xwards (to PQ nodes)
_calc_shunts_and_add_on_ppc(net, ppc)
# adds auxilary buses for open switches at branches
_switch_branches(net, ppc)
# add auxilary buses for out of service buses at in service lines.
# Also sets lines out of service if they are connected to two out of service buses
_branches_with_oos_buses(net, ppc)
# sets buses out of service, which aren't connected to branches / REF buses
if check_connectivity:
isolated_nodes, _, _ = aux._check_connectivity(ppc)
if use_numba:
net["_is_elements"] = aux._select_is_elements_numba(net, isolated_nodes)
else:
aux._create_ppc2pd_bus_lookup(net)
aux._remove_isolated_elements_from_is_elements(net, isolated_nodes)
# ToDo: The reverse lookup (ppc2pd) needs to be updated in ppc2ppci!
else:
aux._set_isolated_buses_out_of_service(net, ppc)
# generates "internal" ppci format (for powerflow calc) from "external" ppc format and updates the bus lookup
# Note: Also reorders buses and gens in ppc
ppci = _ppc2ppci(ppc, ppci, net)
if mode == "opf":
# make opf objective
ppci = _make_objective(ppci, net)
return ppc, ppci
def _pd2ppc(net):
"""
Converter Flow:
1. Create an empty pypower datatructure
2. Calculate loads and write the bus matrix
3. Build the gen (Infeeder)- Matrix
4. Calculate the line parameter and the transformer parameter,
and fill it in the branch matrix.
Order: 1st: Line values, 2nd: Trafo values
5. if opf: make opf objective (gencost)
6. convert internal ppci format for pypower powerflow / opf without out of service elements and rearanged buses
INPUT:
**net** - The pandapower format network
OUTPUT:
**ppc** - The simple matpower format network. Which consists of:
ppc = {
"baseMVA": 1., *float*
"version": 2, *int*
"bus": np.array([], dtype=float),
"branch": np.array([], dtype=np.complex128),
"gen": np.array([], dtype=float),
"gencost" = np.array([], dtype=float), only for OPF
"internal": {
"Ybus": np.array([], dtype=np.complex128)
, "Yf": np.array([], dtype=np.complex128)
, "Yt": np.array([], dtype=np.complex128)
, "branch_is": np.array([], dtype=bool)
, "gen_is": np.array([], dtype=bool)
}
**ppci** - The "internal" pypower format network for PF calculations
"""
# select elements in service (time consuming, so we do it once)
net["_is_elements"] = aux._select_is_elements_numba(net)
# get options
mode = net["_options"]["mode"]
check_connectivity = net["_options"]["check_connectivity"]
calculate_voltage_angles = net["_options"]["calculate_voltage_angles"]
ppc = _init_ppc(net, mode=mode)
# generate ppc['bus'] and the bus lookup
_build_bus_ppc(net, ppc)
# generate ppc['branch'] and directly generates branch values
_build_branch_ppc(net, ppc)
# adds P and Q for loads / sgens in ppc['bus'] (PQ nodes)
if mode == "sc":
_add_gen_impedances_ppc(net, ppc)
_add_motor_impedances_ppc(net, ppc)
else:
_calc_pq_elements_and_add_on_ppc(net, ppc)
# adds P and Q for shunts, wards and xwards (to PQ nodes)
_calc_shunts_and_add_on_ppc(net, ppc)
# adds auxilary buses for open switches at branches
_switch_branches(net, ppc)
# add auxilary buses for out of service buses at in service lines.
# Also sets lines out of service if they are connected to two out of service buses
_branches_with_oos_buses(net, ppc)
if check_connectivity:
# sets islands (multiple isolated nodes) out of service
if "opf" in mode:
isolated_nodes, _, _ = aux._check_connectivity_opf(ppc)
else:
isolated_nodes, _, _ = aux._check_connectivity(ppc)
net["_is_elements"] = aux._select_is_elements_numba(
net, isolated_nodes)
# sets buses out of service, which aren't connected to branches / REF buses
aux._set_isolated_buses_out_of_service(net, ppc)
_build_gen_ppc(net, ppc)
if "pf" in mode:
_check_for_reference_bus(ppc)
aux._replace_nans_with_default_limits(net, ppc)
# generates "internal" ppci format (for powerflow calc) from "external" ppc format and updates the bus lookup
# Note: Also reorders buses and gens in ppc
ppci = _ppc2ppci(ppc, net)
if mode == "pf":
# check if any generators connected to the same bus have different voltage setpoints
_check_voltage_setpoints_at_same_bus(ppc)
if calculate_voltage_angles:
_check_voltage_angles_at_same_bus(net, ppci)
if mode == "opf":
# make opf objective
ppci = _make_objective(ppci, net)
return ppc, ppci
def _pd2ppc(net, is_elems, calculate_voltage_angles=False, enforce_q_lims=False,
trafo_model="pi", init_results=False):
"""
Converter Flow:
1. Create an empty pypower datatructure
2. Calculate loads and write the bus matrix
3. Build the gen (Infeeder)- Matrix
4. Calculate the line parameter and the transformer parameter,
and fill it in the branch matrix.
Order: 1st: Line values, 2nd: Trafo values
INPUT:
**net** - The Pandapower format network
**is_elems** - In service elements from the network (see _select_is_elements())
RETURN:
**ppc** - The simple matpower format network. Which consists of:
ppc = {
"baseMVA": 1., *float*
"version": 2, *int*
"bus": np.array([], dtype=float),
"branch": np.array([], dtype=np.complex128),
"gen": np.array([], dtype=float)
**ppci** - The "internal" pypower format network for PF calculations
**bus_lookup** - Lookup Pandapower -> ppc / ppci indices
"""
# init empty ppc
ppc = {"baseMVA": 1.,
"version": 2,
"bus": np.array([], dtype=float),
"branch": np.array([], dtype=np.complex128),
"gen": np.array([], dtype=float)}
# generate ppc['bus'] and the bus lookup
bus_lookup = _build_bus_ppc(net, ppc, is_elems, init_results)
# generate ppc['gen'] and fills ppc['bus'] with generator values (PV, REF nodes)
_build_gen_ppc(net, ppc, is_elems, bus_lookup, enforce_q_lims, calculate_voltage_angles)
# generate ppc['branch'] and directly generates branch values
_build_branch_ppc(net, ppc, is_elems, bus_lookup, calculate_voltage_angles, trafo_model)
# adds P and Q for loads / sgens in ppc['bus'] (PQ nodes)
_calc_loads_and_add_on_ppc(net, ppc, is_elems, bus_lookup)
# adds P and Q for shunts, wards and xwards (to PQ nodes)
_calc_shunts_and_add_on_ppc(net, ppc, is_elems, bus_lookup)
# adds auxilary buses for open switches at branches
_switch_branches(net, ppc, is_elems, bus_lookup)
# add auxilary buses for out of service buses at in service lines.
# Also sets lines out of service if they are connected to two out of service buses
_branches_with_oos_buses(net, ppc, is_elems, bus_lookup)
# sets buses out of service, which aren't connected to branches / REF buses
_set_isolated_buses_out_of_service(net, ppc)
# generates "internal" ppci format (for powerflow calc) from "external" ppc format and updates the bus lookup
# Note: Also reorders buses and gens in ppc
ppci, bus_lookup = _ppc2ppci(ppc, bus_lookup)
# add lookup with indices before any busses were fused
bus_lookup["before_fuse"] = dict(
zip(net["bus"].index.values, np.arange(len(net["bus"].index.values))))
return ppc, ppci, bus_lookup
