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 _get_pf_variables_from_ppci(ppci):
"""
Used for getting values for pfsoln function in one convinient function
"""
# default arguments
if ppci is None:
ValueError('ppci is empty')
# get data for calc
base_mva, bus, gen, branch = \
ppci["baseMVA"], ppci["bus"], ppci["gen"], ppci["branch"]
# get bus index lists of each type of bus
ref, pv, pq = bustypes(bus, gen)
return base_mva, bus, gen, branch, ref, pv, pq
def _get_pf_variables_from_ppci(ppci):
"""
Used for getting values for pfsoln function in one convinient function
"""
# default arguments
if ppci is None:
ValueError('ppci is empty')
# get data for calc
base_mva, bus, gen, branch = \
ppci["baseMVA"], ppci["bus"], ppci["gen"], ppci["branch"]
# get bus index lists of each type of bus
ref, pv, pq = bustypes(bus, gen)
# generator info
on = find(gen[:, GEN_STATUS] > 0) # which generators are on?
gbus = gen[on, GEN_BUS].astype(int) # what buses are they at?
# initial state
v0 = bus[:, VM] * exp(1j * pi / 180 * bus[:, VA])
v0[gbus] = gen[on, VG] / abs(v0[gbus]) * v0[gbus]
ref_gens = ppci["internal"]["ref_gens"]
return base_mva, bus, gen, branch, ref, pv, pq, on, gbus, v0, ref_gens
def _get_pf_variables_from_ppci(ppci):
## default arguments
if ppci is None:
ValueError('ppci is empty')
# ppopt = ppoption(ppopt)
# get data for calc
baseMVA, bus, gen, branch = \
ppci["baseMVA"], ppci["bus"], ppci["gen"], ppci["branch"]
## get bus index lists of each type of bus
ref, pv, pq = bustypes(bus, gen)
## generator info
on = find(gen[:, GEN_STATUS] > 0) ## which generators are on?
gbus = gen[on, GEN_BUS].astype(int) ## what buses are they at?
## initial state
# V0 = ones(bus.shape[0]) ## flat start
V0 = bus[:, VM] * exp(1j * pi / 180. * bus[:, VA])
V0[gbus] = gen[on, VG] / abs(V0[gbus]) * V0[gbus]
ref_gens = ppci["internal"]["ref_gens"]
return baseMVA, bus, gen, branch, ref, pv, pq, on, gbus, V0, ref_gens
def _run_ac_pf_with_qlims_enforced(ppci, options):
baseMVA, bus, gen, branch, ref, pv, pq, on, _, V0, ref_gens = _get_pf_variables_from_ppci(ppci)
qlim = options["enforce_q_lims"]
limited = [] # list of indices of gens @ Q lims
fixedQg = zeros(gen.shape[0]) # Qg of gens at Q limits
while True:
ppci, success, iterations = _run_ac_pf_without_qlims_enforced(ppci, options)
bus, gen, branch = ppci_to_pfsoln(ppci, options)
# find gens with violated Q constraints
gen_status = gen[:, GEN_STATUS] > 0
qg_max_lim = gen[:, QG] > gen[:, QMAX]
qg_min_lim = gen[:, QG] < gen[:, QMIN]
mx = setdiff1d(find(gen_status & qg_max_lim), ref_gens)
mn = setdiff1d(find(gen_status & qg_min_lim), ref_gens)
if len(mx) > 0 or len(mn) > 0: # we have some Q limit violations
# one at a time?
if qlim == 2: # fix largest violation, ignore the rest
k = argmax(r_[gen[mx, QG] - gen[mx, QMAX],
gen[mn, QMIN] - gen[mn, QG]])
if k > len(mx):
mn = mn[k - len(mx)]
mx = []
else:
mx = mx[k]
mn = []
# save corresponding limit values
fixedQg[mx] = gen[mx, QMAX]
fixedQg[mn] = gen[mn, QMIN]
mx = r_[mx, mn].astype(int)
# convert to PQ bus
gen[mx, QG] = fixedQg[mx] # set Qg to binding
for i in range(len(mx)): # [one at a time, since they may be at same bus]
gen[mx[i], GEN_STATUS] = 0 # temporarily turn off gen,
bi = gen[mx[i], GEN_BUS].astype(int) # adjust load accordingly,
bus[bi, [PD, QD]] = (bus[bi, [PD, QD]] - gen[mx[i], [PG, QG]])
# if len(ref) > 1 and any(bus[gen[mx, GEN_BUS].astype(int), BUS_TYPE] == REF):
# raise ValueError('Sorry, pandapower cannot enforce Q '
# 'limits for slack buses in systems '
# 'with multiple slacks.')
changed_gens = gen[mx, GEN_BUS].astype(int)
bus[setdiff1d(changed_gens, ref), BUS_TYPE] = PQ # & set bus type to PQ
# update bus index lists of each type of bus
ref, pv, pq = bustypes(bus, gen)
limited = r_[limited, mx].astype(int)
else:
break # no more generator Q limits violated
if len(limited) > 0:
# restore injections from limited gens [those at Q limits]
gen[limited, QG] = fixedQg[limited] # restore Qg value,
for i in range(len(limited)): # [one at a time, since they may be at same bus]
bi = gen[limited[i], GEN_BUS].astype(int) # re-adjust load,
bus[bi, [PD, QD]] = bus[bi, [PD, QD]] + gen[limited[i], [PG, QG]]
gen[limited[i], GEN_STATUS] = 1 # and turn gen back on
return ppci, success, iterations, bus, gen, branch
def _bfswpf(DLF, bus, gen, branch, baseMVA, Ybus, Sbus, V0, ref, pv, pq, buses_ordered_bfs_nets,
options, **kwargs):
"""
distribution power flow solution according to [1]
:param DLF: direct-Load-Flow matrix which relates bus current injections to voltage drops from the root bus
:param bus: buses martix
:param gen: generators matrix
:param branch: branches matrix
:param baseMVA:
:param Ybus: bus admittance matrix
:param Sbus: vector of power injections
:param V0: initial voltage state vector
:param ref: reference bus index
:param pv: PV buses indices
:param pq: PQ buses indices
:param buses_ordered_bfs_nets: buses ordered according to breadth-first search
:return: power flow result
"""
enforce_q_lims = options["enforce_q_lims"]
tolerance_mva = options["tolerance_mva"]
max_iteration = options["max_iteration"]
voltage_depend_loads = options["voltage_depend_loads"]
# setting options
max_it = max_iteration # maximum iterations
verbose = kwargs["VERBOSE"] # verbose is set in run._runpppf() #
# tolerance for the inner loop for PV nodes
if 'tolerance_mva_pv' in kwargs:
tol_mva_inner = kwargs['tolerance_mva_pv']
else:
tol_mva_inner = 1.e-2
if 'max_iter_pv' in kwargs:
max_iter_pv = kwargs['max_iter_pv']
else:
max_iter_pv = 20
nobus = bus.shape[0]
ngen = gen.shape[0]
mask_root = ~ (bus[:, BUS_TYPE] == 3) # mask for eliminating root bus
norefs = len(ref)
Ysh = _makeYsh_bfsw(bus, branch, baseMVA)
# detect generators on PV buses which have status ON
gen_pv = np.in1d(gen[:, GEN_BUS], pv) & (gen[:, GEN_STATUS] > 0)
qg_lim = np.zeros(ngen, dtype=bool) # initialize generators which violated Q limits
Iinj = np.conj(Sbus / V0) - Ysh * V0 # Initial current injections
# initiate reference voltage vector
V_ref = np.ones(nobus, dtype=complex)
for neti, buses_ordered_bfs in enumerate(buses_ordered_bfs_nets):
V_ref[buses_ordered_bfs] *= V0[ref[neti]]
V = V0.copy()
n_iter = 0
converged = 0
if verbose:
print(' -- AC Power Flow (Backward/Forward sweep)\n')
while not converged and n_iter < max_it:
n_iter_inner = 0
n_iter += 1
deltaV = DLF * Iinj[mask_root]
V[mask_root] = V_ref[mask_root] + deltaV
# ##
# inner loop for considering PV buses
# TODO improve PV buses inner loop
inner_loop_converged = False
while not inner_loop_converged and len(pv) > 0:
pvi = pv - norefs # internal PV buses indices, assuming reference node is always 0
Vmis = (np.abs(gen[gen_pv, VG])) ** 2 - (np.abs(V[pv])) ** 2
# TODO improve getting values from sparse DLF matrix - DLF[pvi, pvi] is unefficient
dQ = (Vmis / (2 * DLF[pvi, pvi].A1.imag)).flatten()
gen[gen_pv, QG] += dQ
if enforce_q_lims: # check Q violation limits
## find gens with violated Q constraints
qg_max_lim = (gen[:, QG] > gen[:, QMAX]) & gen_pv
qg_min_lim = (gen[:, QG] < gen[:, QMIN]) & gen_pv
if qg_min_lim.any():
gen[qg_min_lim, QG] = gen[qg_min_lim, QMIN]
bus[gen[qg_min_lim, GEN_BUS].astype(int), BUS_TYPE] = 1 # convert to PQ bus
if qg_max_lim.any():
gen[qg_max_lim, QG] = gen[qg_max_lim, QMAX]
bus[gen[qg_max_lim, GEN_BUS].astype(int), BUS_TYPE] = 1 # convert to PQ bus
# TODO: correct: once all the PV buses are converted to PQ buses, conversion back to PV is not possible
qg_lim_new = qg_min_lim | qg_max_lim
if qg_lim_new.any():
pq2pv = (qg_lim != qg_lim_new) & qg_lim
# convert PQ to PV bus
if pq2pv.any():
bus[gen[qg_max_lim, GEN_BUS].astype(int), BUS_TYPE] = 2 # convert to PV bus
qg_lim = qg_lim_new.copy()
ref, pv, pq = bustypes(bus, gen)
# avoid calling makeSbus, update only Sbus for pv nodes
Sbus = (makeSbus(baseMVA, bus, gen, vm=abs(V))
if voltage_depend_loads else
makeSbus(baseMVA, bus, gen))
Iinj = np.conj(Sbus / V) - Ysh * V
deltaV = DLF * Iinj[mask_root]
V[mask_root] = V_ref[mask_root] + deltaV
if n_iter_inner > max_iter_pv:
raise LoadflowNotConverged(" FBSW Power Flow did not converge - inner iterations for PV nodes "
"reached maximum value of {0}!".format(max_iter_pv))
n_iter_inner += 1
if np.all(np.abs(dQ) < tol_mva_inner): # inner loop termination criterion
inner_loop_converged = True
# testing termination criterion -
if voltage_depend_loads:
Sbus = makeSbus(baseMVA, bus, gen, vm=abs(V))
F = _evaluate_Fx(Ybus, V, Sbus, pv, pq)
# check tolerance
converged = _check_for_convergence(F, tolerance_mva)
if converged and verbose:
print("\nFwd-back sweep power flow converged in "
"{0} iterations.\n".format(n_iter))
# updating injected currents
Iinj = np.conj(Sbus / V) - Ysh * V
return V, converged
def _run_ac_pf_with_qlims_enforced(ppci, recycle, makeYbus, ppopt):
baseMVA, bus, gen, branch, ref, pv, pq, on, gbus, V0, _ = _get_pf_variables_from_ppci(
ppci)
qlim = ppopt["ENFORCE_Q_LIMS"]
limited = [] ## list of indices of gens @ Q lims
fixedQg = zeros(gen.shape[0]) ## Qg of gens at Q limits
it = 0
while True:
ppci, success, bus, gen, branch, it_inner = _run_ac_pf_without_qlims_enforced(
ppci, recycle, makeYbus, ppopt)
it += it_inner
## find gens with violated Q constraints
gen_status = gen[:, GEN_STATUS] > 0
qg_max_lim = gen[:, QG] > gen[:, QMAX]
qg_min_lim = gen[:, QG] < gen[:, QMIN]
non_refs = (gen[:, QMAX] != 0.) & (gen[:, QMIN] != 0.)
mx = find(gen_status & qg_max_lim & non_refs)
mn = find(gen_status & qg_min_lim & non_refs)
if len(mx) > 0 or len(mn) > 0: ## we have some Q limit violations
## one at a time?
if qlim == 2: ## fix largest violation, ignore the rest
k = argmax(r_[gen[mx, QG] - gen[mx, QMAX],
gen[mn, QMIN] - gen[mn, QG]])
if k > len(mx):
mn = mn[k - len(mx)]
mx = []
else:
mx = mx[k]
mn = []
## save corresponding limit values
fixedQg[mx] = gen[mx, QMAX]
fixedQg[mn] = gen[mn, QMIN]
mx = r_[mx, mn].astype(int)
## convert to PQ bus
gen[mx, QG] = fixedQg[mx] ## set Qg to binding
for i in mx: ## [one at a time, since they may be at same bus]
gen[i, GEN_STATUS] = 0 ## temporarily turn off gen,
bi = gen[i, GEN_BUS].astype(int) ## adjust load accordingly,
bus[bi, [PD, QD]] = (bus[bi, [PD, QD]] - gen[i, [PG, QG]])
if len(ref) > 1 and any(bus[gen[mx, GEN_BUS].astype(int),
BUS_TYPE] == REF):
raise ValueError('Sorry, pandapower cannot enforce Q '
'limits for slack buses in systems '
'with multiple slacks.')
changed_gens = gen[mx, GEN_BUS].astype(int)
bus[setdiff1d(changed_gens, ref),
BUS_TYPE] = PQ ## & set bus type to PQ
## update bus index lists of each type of bus
ref, pv, pq = bustypes(bus, gen)
limited = r_[limited, mx].astype(int)
else:
break ## no more generator Q limits violated
if len(limited) > 0:
## restore injections from limited gens [those at Q limits]
gen[limited, QG] = fixedQg[limited] ## restore Qg value,
for i in limited: ## [one at a time, since they may be at same bus]
bi = gen[i, GEN_BUS].astype(int) ## re-adjust load,
bus[bi, [PD, QD]] = bus[bi, [PD, QD]] + gen[i, [PG, QG]]
gen[i, GEN_STATUS] = 1 ## and turn gen back on
return ppci, success, bus, gen, branch, it
def runpp_3ph(net,
calculate_voltage_angles=True,
init="auto",
max_iteration="auto",
tolerance_mva=1e-8,
trafo_model='t',
trafo_loading="current",
enforce_q_lims=False,
numba=True,
recycle=None,
check_connectivity=True,
switch_rx_ratio=2.0,
delta_q=0,
v_debug=False,
**kwargs):
"""
runpp_3ph: Performs Unbalanced/Asymmetric/Three Phase Load flow
INPUT:
**net** - The pandapower format network
OPTIONAL:
**algorithm** (str, "nr") - algorithm that is used to solve the power
flow problem.
The following algorithms are available:
- "nr" Newton-Raphson (pypower implementation with numba accelerations)
Used only for positive sequence network
Zero and Negative sequence networks use Current Injection method
Vnew = Y.inv * Ispecified ( from s_abc/v_abc old)
Icalculated = Y * Vnew
**calculate_voltage_angles** (bool, "auto") - consider voltage angles
in loadflow calculation
If True, voltage angles of ext_grids and transformer shifts are
considered in the loadflow calculation. Considering the voltage
angles is only necessary in meshed networks that are usually
found in higher voltage levels. calculate_voltage_angles
in "auto" mode defaults to:
- True, if the network voltage level is above 70 kV
- False otherwise
The network voltage level is defined as the maximum rated voltage
of any bus in the network that is connected to a line.
**max_iteration** (int, "auto") - maximum number of iterations carried
out in the power flow algorithm.
In "auto" mode, the default value depends on the power flow solver:
- 10 for "nr"
For three phase calculations, its extended to 3 * max_iteration
**tolerance_mva** (float, 1e-8) - loadflow termination condition
referring to P / Q mismatch of node power in MVA
**trafo_model**
- transformer equivalent models
- "t" - transformer is modeled as equivalent with the T-model.
- "pi" - This is not recommended, since it is less exact than the T-model. So, for three phase load flow, its not implemented
**trafo_loading** (str, "current") - mode of calculation for
transformer loading
Transformer loading can be calculated relative to the rated
current or the rated power. In both cases the overall transformer
loading is defined as the maximum loading on the two sides of
the transformer.
- "current"- transformer loading is given as ratio of current
flow and rated current of the transformer. This is the recommended
setting, since thermal as well as magnetic effects in the
transformer depend on the current.
- "power" - transformer loading is given as ratio of apparent
power flow to the rated apparent power of the transformer.
**enforce_q_lims** (bool, False) (Not tested with 3 Phase load flow)
- respect generator reactive power limits
If True, the reactive power limits in net.gen.max_q_mvar/min_q_mvar
are respected in the loadflow. This is done by running a second
loadflow if reactive power limits are violated at any generator,
so that the runtime for the loadflow will increase if reactive
power has to be curtailed.
Note: enforce_q_lims only works if algorithm="nr"!
**check_connectivity** (bool, True) - Perform an extra connectivity
test after the conversion from pandapower to PYPOWER.
If True, an extra connectivity test based on SciPy Compressed
Sparse Graph Routines is perfomed. If check finds unsupplied buses,
they are set out of service in the ppc
**voltage_depend_loads** (bool, True)
(Not tested with 3 Phase load flow) - consideration of voltage-dependent loads.
If False, ``net.load.const_z_percent`` and ``net.load.const_i_percent``
are not considered, i.e. ``net.load.p_mw`` and ``net.load.q_mvar``
are considered as constant-power loads.
**consider_line_temperature** (bool, False) (Not tested with 3 Phase
load flow) - adjustment of line impedance based on provided line temperature.
If True, ``net.line`` must contain a column ``temperature_degree_celsius``.
The temperature dependency coefficient alpha must be provided in
the ``net.line.alpha`` column, otherwise the default value of 0.004 is used.
**KWARGS**:
**numba** (bool, True) - Activation of numba JIT compiler in the
newton solver
If set to True, the numba JIT compiler is used to generate
matrices for the powerflow, which leads to significant speed
improvements.
**switch_rx_ratio** (float, 2)
(Not tested with 3 Phase load flow) - rx_ratio of bus-bus-switches.
If impedance is zero, buses connected by a closed bus-bus switch
are fused to model an ideal bus. Otherwise, they are modelled
as branches with resistance defined as z_ohm column in switch
table and this parameter
**delta_q**
(Not tested with 3 Phase load flow) - Reactive power tolerance for option "enforce_q_lims"
in kvar - helps convergence in some cases.
**trafo3w_losses**
(Not tested with 3 Phase load flow) - defines where open loop losses of three-winding
transformers are considered. Valid options are "hv", "mv", "lv"
for HV/MV/LV side or "star" for the star point.
**v_debug** (bool, False) (Not tested with 3 Phase load flow) - if True,
voltage values in each newton-raphson iteration are logged in the ppc.
**init_vm_pu** (string/float/array/Series, None) (Not tested with 3
Phase load flow) - Allows to define initialization specifically for
voltage magnitudes. Only works with ``init == "auto"``!
- "auto": all buses are initialized with the mean value of all
voltage controlled elements in the grid
- "flat" for flat start from 1.0
- "results": voltage magnitude vector is taken from result table
- a float with which all voltage magnitudes are initialized
- an iterable with a voltage magnitude value for each bus
(length and order has to match with the buses in net.bus)
- a pandas Series with a voltage magnitude value for each bus
(indexes have to match the indexes in net.bus)
**init_va_degree** (string/float/array/Series, None) (Not tested with
3 Phase load flow) - Allows to define initialization specifically for voltage angles.
Only works with ``init == "auto"``!
- "auto": voltage angles are initialized from DC power flow
if angles are calculated or as 0 otherwise
- "dc": voltage angles are initialized from DC power flow
- "flat" for flat start from 0
- "results": voltage angle vector is taken from result table
- a float with which all voltage angles are initialized
- an iterable with a voltage angle value for each bus (length
and order has to match with the buses in net.bus)
- a pandas Series with a voltage angle value for each bus (indexes
have to match the indexes in net.bus)
**recycle** (dict, none) - Reuse of internal powerflow variables for
time series calculation.
Contains a dict with the following parameters:
bus_pq: If True PQ values of buses are updated
gen: If True Sbus and the gen table in the ppc are recalculated
Ybus: If True the admittance matrix (Ybus, Yf, Yt) is taken from
ppc["internal"] and not reconstructed
**neglect_open_switch_branches** (bool, False)
(Not tested with 3 Phase load flow) - If True no auxiliary
buses are created for branches when switches are opened at the branch.
Instead branches are set out of service
SEE ALSO:
pp.add_zero_impedance_parameters(net):
To add zero sequence parameters into network from the standard type
EXAMPLES:
Use this module like this:
.. code-block:: python
from pandapower.pf.runpp_3ph import runpp_3ph
runpp_3ph(net)
NOTES:
- Three phase load flow uses Sequence Frame for power flow solution.
- Three phase system is modelled with earth return.
- PH-E load type is called as wye since Neutral and Earth are considered same
- This solver has proved successful only for Earthed transformers (i.e Dyn,Yyn,YNyn & Yzn vector groups)
"""
# =============================================================================
# pandapower settings
# =============================================================================
overrule_options = {}
if "user_pf_options" in net.keys() and len(net.user_pf_options) > 0:
passed_parameters = _passed_runpp_parameters(locals())
overrule_options = {
key: val
for key, val in net.user_pf_options.items()
if key not in passed_parameters.keys()
}
if numba:
numba = _check_if_numba_is_installed(numba)
ac = True
mode = "pf_3ph" # TODO: Make valid modes (pf, pf_3ph, se, etc.) available in seperate file (similar to idx_bus.py)
# v_debug = kwargs.get("v_debug", False)
copy_constraints_to_ppc = False
if trafo_model == 'pi':
raise Not_implemented("Three phase Power Flow doesnot support pi model\
because of lack of accuracy")
# if calculate_voltage_angles == "auto":
# calculate_voltage_angles = False
# hv_buses = np.where(net.bus.vn_kv.values > 70)[0] # Todo: Where does that number come from?
# if len(hv_buses) > 0:
# line_buses = net.line[["from_bus", "to_bus"]].values.flatten()
# if len(set(net.bus.index[hv_buses]) & set(line_buses)) > 0:
# scipy spsolve options in NR power flow
use_umfpack = kwargs.get("use_umfpack", True)
permc_spec = kwargs.get("permc_spec", None)
calculate_voltage_angles = True
if init == "results" and net.res_bus_3ph.empty:
init = "auto"
if init == "auto":
init = "dc" if calculate_voltage_angles else "flat"
default_max_iteration = {
"nr": 10,
"bfsw": 10,
"gs": 10000,
"fdxb": 30,
"fdbx": 30
}
if max_iteration == "auto":
max_iteration = default_max_iteration["nr"]
neglect_open_switch_branches = kwargs.get("neglect_open_switch_branches",
False)
only_v_results = kwargs.get("only_v_results", False)
net._options = {}
_add_ppc_options(net, calculate_voltage_angles=calculate_voltage_angles,
trafo_model=trafo_model, check_connectivity=check_connectivity,
mode=mode, switch_rx_ratio=switch_rx_ratio,
init_vm_pu=init, init_va_degree=init,
enforce_q_lims=enforce_q_lims, recycle=None,
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, use_umfpack=use_umfpack,
permc_spec=permc_spec)
net._options.update(overrule_options)
_check_bus_index_and_print_warning_if_high(net)
_check_gen_index_and_print_warning_if_high(net)
# =========================================================================
# pd2ppc conversion
# =========================================================================
_, ppci1 = _pd2ppc_recycle(net, 1, recycle=recycle)
_, ppci2 = _pd2ppc_recycle(net, 2, recycle=recycle)
gs_eg, bs_eg = _add_ext_grid_sc_impedance(net, ppci2)
_, ppci0 = _pd2ppc_recycle(net, 0, recycle=recycle)
_, bus0, gen0, branch0, _, _, _ = _get_pf_variables_from_ppci(ppci0)
base_mva, bus1, gen1, branch1, sl_bus, _, pq_bus = _get_pf_variables_from_ppci(
ppci1)
_, bus2, gen2, branch2, _, _, _ = _get_pf_variables_from_ppci(ppci2)
# initialize the results after the conversion to ppc is done, otherwise init=results does not work
init_results(net, "pf_3ph")
# =============================================================================
# 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
# =============================================================================
s_abc_delta, s_abc = _load_mapping(net, ppci1)
# =========================================================================
# Construct Sequence Frame Bus admittance matrices Ybus
# =========================================================================
ppci0, ppci1, ppci2, y_0_pu, y_1_pu, y_2_pu, y_0_f, y_1_f, _,\
y_0_t, y_1_t, _ = _get_y_bus(ppci0, ppci1, ppci2, recycle)
# =========================================================================
# Initial voltage values
# =========================================================================
nb = ppci1["bus"].shape[0]
# make sure flat start is always respected, even with other voltage data in recycled ppc
if init == "flat":
v_012_it = np.zeros((3, nb), dtype=np.complex128)
v_012_it[1, :] = 1.0
else:
v_012_it = np.concatenate([
np.array(ppc["bus"][:, VM] *
np.exp(1j * np.deg2rad(ppc["bus"][:, VA]))).reshape(
(1, nb)) for ppc in (ppci0, ppci1, ppci2)
],
axis=0).astype(np.complex128)
# For Delta transformation:
# Voltage changed from line-earth to line-line using V_T
# s_abc/v_abc will now give line-line currents. This is converted to line-earth
# current using I-T
v_del_xfmn = np.array([[1, -1, 0], [0, 1, -1], [-1, 0, 1]])
i_del_xfmn = np.array([[1, 0, -1], [-1, 1, 0], [0, -1, 1]])
v_abc_it = sequence_to_phase(v_012_it)
# =========================================================================
# Iteration using Power mismatch criterion
# =========================================================================
outer_tolerance_mva = 3e-8
count = 0
s_mismatch = np.array([[True], [True]], dtype=bool)
t0 = perf_counter()
while (s_mismatch >
outer_tolerance_mva).any() and count < 30 * max_iteration:
# =====================================================================
# Voltages and Current transformation for PQ and Slack bus
# =====================================================================
s_abc_pu = -np.divide(s_abc, ppci1["baseMVA"])
s_abc_delta_pu = -np.divide(s_abc_delta, ppci1["baseMVA"])
i_abc_it_wye = (np.divide(s_abc_pu, v_abc_it)).conjugate()
i_abc_it_delta = np.matmul(i_del_xfmn, (np.divide(
s_abc_delta_pu, np.matmul(v_del_xfmn, v_abc_it))).conjugate())
# For buses with both delta and wye loads we need to sum of their currents
# to sum up the currents
i_abc_it = i_abc_it_wye + i_abc_it_delta
i012_it = phase_to_sequence(i_abc_it)
v1_for_s1 = v_012_it[1, :]
i1_for_s1 = -i012_it[1, :]
v0_pu_it = X012_to_X0(v_012_it)
v2_pu_it = X012_to_X2(v_012_it)
i0_pu_it = X012_to_X0(i012_it)
i2_pu_it = X012_to_X2(i012_it)
s1 = np.multiply(v1_for_s1, i1_for_s1.conjugate())
# =============================================================================
# Current used to find S1 Positive sequence power
# =============================================================================
ppci1["bus"][pq_bus, PD] = np.real(s1[pq_bus]) * ppci1["baseMVA"]
ppci1["bus"][pq_bus, QD] = np.imag(s1[pq_bus]) * ppci1["baseMVA"]
# =============================================================================
# Conduct Positive sequence power flow
# =============================================================================
_run_newton_raphson_pf(ppci1, net._options)
# =============================================================================
# Conduct Negative and Zero sequence power flow
# =============================================================================
v0_pu_it = V_from_I(y_0_pu, i0_pu_it)
v2_pu_it = V_from_I(y_2_pu, i2_pu_it)
# =============================================================================
# Evaluate Positive Sequence Power Mismatch
# =============================================================================
i1_from_v_it = I1_from_V012(v_012_it, y_1_pu).flatten()
s_from_voltage = S_from_VI_elementwise(v1_for_s1, i1_from_v_it)
v1_pu_it = V1_from_ppc(ppci1)
v_012_new = combine_X012(v0_pu_it, v1_pu_it, v2_pu_it)
s_mismatch = np.abs(
np.abs(s1[pq_bus]) - np.abs(s_from_voltage[pq_bus]))
v_012_it = v_012_new
v_abc_it = sequence_to_phase(v_012_it)
count += 1
et = perf_counter() - t0
success = (count < 30 * max_iteration)
for ppc in [ppci0, ppci1, ppci2]:
ppc["et"] = et
ppc["success"] = success
# TODO: Add reference to paper to explain the following steps
# This is required since the ext_grid power results are not correct if its
# not done
ref, pv, pq = bustypes(ppci0["bus"], ppci0["gen"])
ref_gens = ppci0["internal"]["ref_gens"]
ppci0["bus"][ref, GS] -= gs_eg
ppci0["bus"][ref, BS] -= bs_eg
y_0_pu, y_0_f, y_0_t = makeYbus(ppci0["baseMVA"], ppci0["bus"],
ppci0["branch"])
# revert the change, otherwise repeated calculation with recycled elements will fail
ppci0["bus"][ref, GS] += gs_eg
ppci0["bus"][ref, BS] += bs_eg
# Bus, Branch, and Gen power values
bus0, gen0, branch0 = pfsoln(base_mva, bus0, gen0, branch0, y_0_pu, y_0_f,
y_0_t, v_012_it[0, :].flatten(), sl_bus,
ref_gens)
bus1, gen1, branch1 = pfsoln(base_mva, bus1, gen1, branch1, y_1_pu, y_1_f,
y_1_t, v_012_it[1, :].flatten(), sl_bus,
ref_gens)
bus2, gen2, branch2 = pfsoln(base_mva, bus2, gen2, branch2, y_1_pu, y_1_f,
y_1_t, v_012_it[2, :].flatten(), sl_bus,
ref_gens)
ppci0 = _store_results_from_pf_in_ppci(ppci0, bus0, gen0, branch0)
ppci1 = _store_results_from_pf_in_ppci(ppci1, bus1, gen1, branch1)
ppci2 = _store_results_from_pf_in_ppci(ppci2, bus2, gen2, branch2)
i_012_res = _current_from_voltage_results(y_0_pu, y_1_pu, v_012_it)
s_012_res = S_from_VI_elementwise(v_012_it, i_012_res) * ppci1["baseMVA"]
eg_is_mask = net["_is_elements"]['ext_grid']
ext_grid_lookup = net["_pd2ppc_lookups"]["ext_grid"]
eg_is_idx = net["ext_grid"].index.values[eg_is_mask]
eg_idx_ppc = ext_grid_lookup[eg_is_idx]
""" # 2 ext_grids Fix: Instead of the generator index, bus indices of the generators are used"""
eg_bus_idx_ppc = np.real(ppci1["gen"][eg_idx_ppc, GEN_BUS]).astype(int)
ppci0["gen"][eg_idx_ppc, PG] = s_012_res[0, eg_bus_idx_ppc].real
ppci1["gen"][eg_idx_ppc, PG] = s_012_res[1, eg_bus_idx_ppc].real
ppci2["gen"][eg_idx_ppc, PG] = s_012_res[2, eg_bus_idx_ppc].real
ppci0["gen"][eg_idx_ppc, QG] = s_012_res[0, eg_bus_idx_ppc].imag
ppci1["gen"][eg_idx_ppc, QG] = s_012_res[1, eg_bus_idx_ppc].imag
ppci2["gen"][eg_idx_ppc, QG] = s_012_res[2, eg_bus_idx_ppc].imag
ppc0 = net["_ppc0"]
ppc1 = net["_ppc1"]
ppc2 = net["_ppc2"]
# ppci doesn't contain out of service elements, but ppc does -> copy results accordingly
ppc0 = _copy_results_ppci_to_ppc(ppci0, ppc0, mode=mode)
ppc1 = _copy_results_ppci_to_ppc(ppci1, ppc1, mode=mode)
ppc2 = _copy_results_ppci_to_ppc(ppci2, ppc2, mode=mode)
_extract_results_3ph(net, ppc0, ppc1, ppc2)
# Raise error if PF was not successful. If DC -> success is always 1
if not ppci0["success"]:
net["converged"] = False
_clean_up(net, res=False)
raise LoadflowNotConverged("Power Flow {0} did not converge after\
{1} iterations!".format("nr", count))
else:
net["converged"] = True
_clean_up(net)
