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
def _calc_sc(net): _add_auxiliary_elements(net) 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) _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") if net["_options"]["return_all_currents"]: _extract_results(net, ppc, ppc_0=None) else: _extract_results(net, ppc, ppc_0=None) _clean_up(net)
def _calc_sc(net, bus): _add_auxiliary_elements(net) ppc, ppci = _pd2ppc(net) _calc_ybus(ppci) if net["_options"]["inverse_y"]: _calc_zbus(net, ppci) else: # Factorization Ybus once ppci["internal"]["ybus_fact"] = factorized(ppci["internal"]["Ybus"]) _calc_rx(net, ppci, bus) # kappa required inverse of Zbus, which is optimized if net["_options"]["kappa"]: _add_kappa_to_ppc(net, ppci) _calc_ikss(net, ppci, bus) 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, bus) ppc = _copy_results_ppci_to_ppc(ppci, ppc, "sc") _extract_results(net, ppc, ppc_0=None, bus=bus) _clean_up(net) if "ybus_fact" in ppci["internal"]: # Delete factorization object ppci["internal"].pop("ybus_fact")
def _calc_sc_1ph(net, bus): """ 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) # zero seq bus impedance ppc_0, ppci_0 = _pd2ppc_zero(net) _calc_ybus(ppci_0) if net["_options"]["inverse_y"]: _calc_zbus(net, ppci) _calc_zbus(net, ppci_0) else: # Factorization Ybus once ppci["internal"]["ybus_fact"] = factorized(ppci["internal"]["Ybus"]) ppci_0["internal"]["ybus_fact"] = factorized( ppci_0["internal"]["Ybus"]) _calc_rx(net, ppci, bus=bus) _add_kappa_to_ppc(net, ppci) _calc_rx(net, ppci_0, bus=bus) _calc_ikss_1ph(net, ppci, ppci_0, bus=bus) if net._options["branch_results"]: _calc_branch_currents(net, ppci, bus=bus) 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, bus=bus) _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) if net._options["branch_results"]: _calc_branch_currents(net, ppci) 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 _powerflow(net, **kwargs): """ Gets called by runpp or rundcpp with different arguments. """ # get infos from options init_results = net["_options"]["init_results"] ac = net["_options"]["ac"] recycle = net["_options"]["recycle"] mode = net["_options"]["mode"] algorithm = net["_options"]["algorithm"] max_iteration = net["_options"]["max_iteration"] net["converged"] = False net["OPF_converged"] = False _add_auxiliary_elements(net) if not ac or init_results: verify_results(net) else: reset_results(net) # TODO remove this when zip loads are integrated for all PF algorithms if algorithm not in ['nr', 'bfsw']: net["_options"]["voltage_depend_loads"] = False if recycle["ppc"] and "_ppc" in net and net[ "_ppc"] is not None and "_pd2ppc_lookups" in net: # update the ppc from last cycle ppc, ppci = _update_ppc(net) else: # convert pandapower net to ppc ppc, ppci = _pd2ppc(net) # store variables net["_ppc"] = ppc if not "VERBOSE" in kwargs: kwargs["VERBOSE"] = 0 # ----- run the powerflow ----- result = _run_pf_algorithm(ppci, net["_options"], **kwargs) # ppci doesn't contain out of service elements, but ppc does -> copy results accordingly result = _copy_results_ppci_to_ppc(result, ppc, mode) # raise if PF was not successful. If DC -> success is always 1 if result["success"] != 1: _clean_up(net, res=False) raise LoadflowNotConverged("Power Flow {0} did not converge after " "{1} iterations!".format( algorithm, max_iteration)) else: net["_ppc"] = result net["converged"] = True _extract_results(net, result) _clean_up(net)
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_single(net, bus): _add_auxiliary_elements(net) 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) _calc_ikss(net, ppci) _calc_single_bus_sc(net, ppci, bus) ppc = _copy_results_ppci_to_ppc(ppci, ppc, "sc") _extract_single_results(net, ppc) _clean_up(net)
def _powerflow(net, **kwargs): """ Gets called by runpp or rundcpp with different arguments. """ # get infos from options ac = net["_options"]["ac"] algorithm = net["_options"]["algorithm"] net["converged"] = False net["OPF_converged"] = False _add_auxiliary_elements(net) if not ac or net["_options"]["init_results"]: verify_results(net) else: init_results(net) if net["_options"]["voltage_depend_loads"] and algorithm not in [ 'nr', 'bfsw' ] and not (allclose(net.load.const_z_percent.values, 0) and allclose(net.load.const_i_percent.values, 0)): logger.error(( "pandapower powerflow does not support voltage depend loads for algorithm " "'%s'!") % algorithm) # clear lookups net._pd2ppc_lookups = { "bus": array([], dtype=int), "ext_grid": array([], dtype=int), "gen": array([], dtype=int), "branch": array([], dtype=int) } # convert pandapower net to ppc ppc, ppci = _pd2ppc(net) # store variables net["_ppc"] = ppc if "VERBOSE" not in kwargs: kwargs["VERBOSE"] = 0 # ----- run the powerflow ----- result = _run_pf_algorithm(ppci, net["_options"], **kwargs) # read the results (=ppci with results) to net _ppci_to_net(result, net)
def _init_ppc(net): _check_sc_data_integrity(net) _add_auxiliary_elements(net) ppc, _ = _pd2ppc(net) # Init the required columns to nan ppc["bus"][:, [K_G, K_SG, V_G, PS_TRAFO_IX, GS_P, BS_P,]] = np.nan ppc["branch"][:, [K_T, K_ST]] = np.nan # Add parameter K into ppc _add_kt(net, ppc) _add_gen_sc_z_kg_ks(net, ppc) _add_xward_sc_z(net, ppc) ppci = _ppc2ppci(ppc, net) return ppc, ppci
def convert_to_pm_structure(net, opf_flow_lim="S"): if net["_options"]["voltage_depend_loads"] and not ( np.allclose(net.load.const_z_percent.values, 0) and np.allclose(net.load.const_i_percent.values, 0)): logger.error( "pandapower optimal_powerflow does not support voltage depend loads." ) net["OPF_converged"] = False net["converged"] = False _add_auxiliary_elements(net) init_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) pm = add_params_to_pm(net, pm) net._pm = pm return net, pm, ppc, ppci
def _powerflow(net, **kwargs): """ Gets called by runpp or rundcpp with different arguments. """ # get infos from options ac = net["_options"]["ac"] algorithm = net["_options"]["algorithm"] net["converged"] = False net["OPF_converged"] = False _add_auxiliary_elements(net) if not ac or net["_options"]["init_results"]: verify_results(net) else: init_results(net) # TODO remove this when zip loads are integrated for all PF algorithms if algorithm not in ['nr', 'bfsw']: net["_options"]["voltage_depend_loads"] = False # clear lookups net._pd2ppc_lookups = { "bus": array([], dtype=int), "ext_grid": array([], dtype=int), "gen": array([], dtype=int), "branch": array([], dtype=int) } # convert pandapower net to ppc ppc, ppci = _pd2ppc(net) # store variables net["_ppc"] = ppc if not "VERBOSE" in kwargs: kwargs["VERBOSE"] = 0 # ----- run the powerflow ----- result = _run_pf_algorithm(ppci, net["_options"], **kwargs) # read the results (=ppci with results) to net _ppci_to_net(result, net)
def _runpm(net): #pragma: no cover net["OPF_converged"] = False net["converged"] = False _add_auxiliary_elements(net) reset_results(net) ppc, ppci = _pd2ppc(net) net["_ppc_opf"] = ppci pm = ppc_to_pm(net, ppci) net._pm = pm if net._options["pp_to_pm_callback"] is not None: net._options["pp_to_pm_callback"](net, ppci, pm) result_pm = _call_powermodels(pm, net._options["julia_file"]) net._pm_res = result_pm result = pm_results_to_ppc_results(net, ppc, ppci, result_pm) net._pm_result = result_pm success = ppc["success"] if success: _extract_results(net, result) _clean_up(net) net["OPF_converged"] = True else: _clean_up(net, res=False) logger.warning("OPF did not converge!")
def _calc_sc_single(net, bus): _add_auxiliary_elements(net) ppc, ppci = _pd2ppc(net) _calc_ybus(ppci) if net["_options"]["inverse_y"]: _calc_zbus(net, ppci) _calc_rx(net, ppci, bus=None) _calc_ikss(net, ppci, bus=None) _calc_single_bus_sc(net, ppci, bus) else: # Factorization Ybus once ppci["internal"]["ybus_fact"] = factorized(ppci["internal"]["Ybus"]) _calc_rx(net, ppci, bus) _calc_ikss(net, ppci, bus) _calc_single_bus_sc_no_y_inv(net, ppci, bus) # Delete factorization object ppci["internal"].pop("ybus_fact") ppc = _copy_results_ppci_to_ppc(ppci, ppc, "sc") _extract_single_results(net, ppc) _clean_up(net)
def _optimal_powerflow(net, verbose, suppress_warnings, **kwargs): ac = net["_options"]["ac"] init = net["_options"]["init"] if "OPF_FLOW_LIM" not in kwargs: kwargs["OPF_FLOW_LIM"] = 2 if net["_options"]["voltage_depend_loads"] and not ( allclose(net.load.const_z_percent.values, 0) and allclose(net.load.const_i_percent.values, 0)): logger.error( "pandapower optimal_powerflow does not support voltage depend loads." ) ppopt = ppoption(VERBOSE=verbose, PF_DC=not ac, INIT=init, **kwargs) net["OPF_converged"] = False net["converged"] = False _add_auxiliary_elements(net) if not ac or net["_options"]["init_results"]: verify_results(net) else: init_results(net, "opf") ppc, ppci = _pd2ppc(net) if not ac: ppci["bus"][:, VM] = 1.0 net["_ppc_opf"] = ppci if len(net.dcline) > 0: ppci = add_userfcn(ppci, 'formulation', _add_dcline_constraints, args=net) if init == "pf": ppci = _run_pf_before_opf(net, ppci) if suppress_warnings: with warnings.catch_warnings(): warnings.simplefilter("ignore") result = opf(ppci, ppopt) else: result = opf(ppci, ppopt) # net["_ppc_opf"] = result if verbose: ppopt['OUT_ALL'] = 1 printpf(baseMVA=result["baseMVA"], bus=result["bus"], gen=result["gen"], branch=result["branch"], f=result["f"], success=result["success"], et=result["et"], fd=stdout, ppopt=ppopt) 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(net, result) _clean_up(net)
def runpp(self, net, max_iteration=10, need_reset=True, **kwargs): net_orig = copy.deepcopy(net) pp.runpp(net_orig) V_orig = net_orig._ppc["internal"]["V"] # ---------- pp.run.runpp() ----------------- t0_start = time() t0_options = time() passed_parameters = _passed_runpp_parameters(locals()) _init_runpp_options(net, algorithm="nr", calculate_voltage_angles="auto", init="auto", max_iteration=max_iteration, tolerance_mva=1e-8, trafo_model="t", trafo_loading="current", enforce_q_lims=False, check_connectivity=False, voltage_depend_loads=True, consider_line_temperature=False, passed_parameters=passed_parameters, numba=True, **kwargs) _check_bus_index_and_print_warning_if_high(net) _check_gen_index_and_print_warning_if_high(net) et_options = time() - t0_options # ---------- pp.powerflow._powerflow() ----------------- """ Gets called by runpp or rundcpp with different arguments. """ # get infos from options t0_early_init = time() init_results = net["_options"]["init_results"] ac = net["_options"]["ac"] algorithm = net["_options"]["algorithm"] net["converged"] = False net["OPF_converged"] = False _add_auxiliary_elements(net) if not ac or init_results: verify_results(net) else: reset_results(net, all_empty=False) # TODO remove this when zip loads are integrated for all PF algorithms if algorithm not in ['nr', 'bfsw']: net["_options"]["voltage_depend_loads"] = False _add_auxiliary_elements(net) # convert pandapower net to ppc ppc, self.ppci = _pd2ppc(net) # pdb.set_trace() # store variables net["_ppc"] = ppc if not "VERBOSE" in kwargs: kwargs["VERBOSE"] = 0 # ----- run the powerflow ----- options = net["_options"] et_early_init = time() - t0_early_init # ---------- pp.powerflow._run_pf_algorithm() ---------------- # ---------- pp.pf.run_newton_raphson_pf.run_newton_raphson_pf() ---------------- t0 = time() t0_init = t0 et_init_dc = 0. if need_reset: if isinstance(options["init_va_degree"], str) and options["init_va_degree"] == "dc": self.ppci = _run_dc_pf(self.ppci) et_init_dc = time() - t0 if options["enforce_q_lims"]: raise NotImplementedError("enforce_q_lims not yet implemented") t0_init = time() # ---------- pp.pf.run_newton_raphson_pf._run_ac_pf_without_qlims_enforced ---------- # ppci, success, iterations = _run_ac_pf_without_qlims_enforced(ppci, options) makeYbus, pfsoln = _get_numba_functions(self.ppci, options) self.baseMVA, self.bus, self.gen, self.branch, self.ref, self.pv, self.pq, _, _, V0, self.ref_gens = _get_pf_variables_from_ppci( self.ppci) self.ppci, self.Ybus, self.Yf, self.Yt = _get_Y_bus( self.ppci, options, makeYbus, self.baseMVA, self.bus, self.branch) # TODO i have a problem here for the order of the bus / id of bus tmp_bus_ind = np.argsort(net.bus.index) model = DataModel() # model.set_sn_mva(net.sn_mva) # model.set_f_hz(net.f_hz) # TODO set that elsewhere self.converter.set_sn_mva(net.sn_mva) self.converter.set_f_hz(net.f_hz) # init_but should be called first among all the rest model.init_bus(net.bus.iloc[tmp_bus_ind]["vn_kv"].values, net.line.shape[0], net.trafo.shape[0]) # init the shunts line_r, line_x, line_h = self.converter.get_line_param( net.line["r_ohm_per_km"].values * net.line["length_km"].values, net.line["x_ohm_per_km"].values * net.line["length_km"].values, net.line["c_nf_per_km"].values * net.line["length_km"].values, net.line["g_us_per_km"].values * net.line["length_km"].values, net.bus.loc[net.line["from_bus"]]["vn_kv"], net.bus.loc[net.line["to_bus"]]["vn_kv"]) model.init_powerlines(line_r, line_x, line_h, net.line["from_bus"].values, net.line["to_bus"].values) # init the shunts model.init_shunt(net.shunt["p_mw"].values, net.shunt["q_mvar"].values, net.shunt["bus"].values) # init trafo if net.trafo.shape[0]: trafo_r, trafo_x, trafo_b = self.converter.get_trafo_param( net.trafo["vn_hv_kv"].values, net.trafo["vn_lv_kv"].values, net.trafo["vk_percent"].values, net.trafo["vkr_percent"].values, net.trafo["sn_mva"].values, net.trafo["pfe_kw"].values, net.trafo["i0_percent"].values, net.bus.loc[net.trafo["lv_bus"]]["vn_kv"]) # trafo_branch = ppc["branch"][net.line.shape[0]:, :] tap_step_pct = net.trafo["tap_step_percent"].values tap_step_pct[~np.isfinite(tap_step_pct)] = 0. tap_pos = net.trafo["tap_pos"].values tap_pos[~np.isfinite(tap_pos)] = 0. is_tap_hv_side = net.trafo["tap_side"].values == "hv" is_tap_hv_side[~np.isfinite(tap_pos)] = True model.init_trafo(trafo_r, trafo_x, trafo_b, tap_step_pct, tap_pos, is_tap_hv_side, net.trafo["hv_bus"].values, net.trafo["lv_bus"].values) model.init_loads(net.load["p_mw"].values, net.load["q_mvar"].values, net.load["bus"].values) model.init_generators(net.gen["p_mw"].values, net.gen["vm_pu"].values, net.gen["bus"].values) # TODO better way here! model.add_slackbus(net.ext_grid["bus"].values) # model.init_Ybus() # Ybus = model.get_Ybus() # be careful, the order is not the same between this and pandapower, you need to change it # Ybus_proper_oder = Ybus[np.array([net.bus.index]).T, np.array([net.bus.index])] # self.Ybus_proper_oder = self.Ybus else: pass # TODO update self.ppci with new values of generation - load such that Sbus is properly udpated # compute complex bus power injections [generation - load] Sbus = _get_Sbus(self.ppci, False) # Sbus_me = model.get_Sbus() # pdb.set_trace() # Sbus_me_r = np.real(Sbus_me) # Va0 = np.full(net.bus.shape[0], fill_value=net["_options"]["init_vm_pu"], dtype=np.complex_) # Va0[net.ext_grid["bus"].values] = net.ext_grid["vm_pu"].values * np.exp(1j * net.ext_grid["va_degree"].values / 360. * 2 * np.pi) #dctheta = model.dc_pf(Sbus_me_r, Va0) # self.dctheta = V0[tmp_bus_ind] # self.dcYbus = self.ppci["internal"]['Bbus'][np.array([tmp_bus_ind]).T, np.array([tmp_bus_ind])] # tmpdc = np.abs(dcYbus - self.dcYbus) # pv_me = model.get_pv() # pq_me = model.get_pq() # pdb.set_trace() # run the newton power flow # ------------------- pp.pypower.newtonpf --------------------- max_it = options["max_iteration"] tol = options['tolerance_mva'] self.Ybus = sparse.csc_matrix(self.Ybus) et_init = time() - t0_init t0__ = time() if need_reset: # reset the solver self.solver.reset() self.V = 1.0 * copy.deepcopy(V0) else: # reuse previous voltages pass self.solver.solve(self.Ybus, self.V, Sbus, self.pv, self.pq, max_it, tol) et__ = time() - t0__ t0_ = time() Va = self.solver.get_Va() Vm = self.solver.get_Vm() self.V = Vm * np.exp(1j * Va) J = self.solver.get_J() success = self.solver.converged() iterations = self.solver.get_nb_iter() # timer_Fx_, timer_solve_, timer_initialize_, timer_check_, timer_dSbus_, timer_fillJ_, timer_total_nr_ timers = self.solver.get_timers() et_ = time() - t0_ # ---------------------- pp.pypower.newtonpf --------------------- self.ppci = _store_internal( self.ppci, { "J": J, "Vm_it": None, "Va_it": None, "bus": self.bus, "gen": self.gen, "branch": self.branch, "baseMVA": self.baseMVA, "V": self.V, "pv": self.pv, "pq": self.pq, "ref": self.ref, "Sbus": Sbus, "ref_gens": self.ref_gens, "Ybus": self.Ybus, "Yf": self.Yf, "Yt": self.Yt, "timers": timers, "time_get_res": et_, "time_solve": et__, "time_init": et_init, "time_init_dc": et_init_dc, "time_early_init": et_early_init, "time_options": et_options }) t0_ppci_to_pfsoln = time() # update data matrices with solution store in ppci # ---------- pp.pf.run_newton_raphson_pf._run_ac_pf_without_qlims_enforced ---------- self.bus, self.gen, self.branch = ppci_to_pfsoln(self.ppci, options) te_ppci_to_pfsoln = time() - t0_ppci_to_pfsoln # these are the values from pypower / matlab t0_store_res = time() et = t0_store_res - t0 result = _store_results_from_pf_in_ppci(self.ppci, self.bus, self.gen, self.branch, success, iterations, et) t0_to_net = time() et_store_res = t0_to_net - t0_store_res # ---------- pp.pf.run_newton_raphson_pf.run_newton_raphson_pf() ---------------- # ---------- pp.powerflow._run_pf_algorithm() ---------------- # read the results (=ppci with results) to net _ppci_to_net(result, net) et_to_net = time() - t0_to_net # ---------- pp.powerflow._powerflow() ---------------- # ---------- pp.run.runpp() ----------------- # added et_start = time() - t0_start self.ppci = _store_internal( self.ppci, { "time_store_res": et_store_res, "time_to_net": et_to_net, "time_all": et_start, "time_ppci_to_pfsoln": te_ppci_to_pfsoln }) has_conv = model.compute_newton(V0[tmp_bus_ind], max_it, tol) # check the results results_solver = np.max(np.abs(V_orig - self.V)) Ybus = model.get_Ybus() Ybus_proper_oder = Ybus self.Ybus_proper_oder = self.Ybus[np.array([tmp_bus_ind]).T, np.array([tmp_bus_ind])] tmp = np.abs(Ybus_proper_oder - self.Ybus_proper_oder) # > 1e-7 por, qor, vor, aor = model.get_lineor_res() pex, qex, vex, aex = model.get_lineex_res() load_p, load_q, load_v = model.get_loads_res() np.max(np.abs(por - net_orig.res_line["p_from_mw"])) np.max(np.abs(qor - net_orig.res_line["q_from_mvar"])) a_or_pp = np.sqrt(net.res_line["p_from_mw"].values**2 + net.res_line["q_from_mvar"].values**2) a_or_pp /= np.sqrt(3) * net.bus.loc[net.line["from_bus"].values][ "vn_kv"].values * net.res_line["vm_from_pu"].values np.max(np.abs(a_or_pp - aor)) np.max(np.abs(a_or_pp - net.res_line["i_from_ka"])) np.max(np.abs(a_or_pp - net.res_line["i_from_ka"])) Va_me2 = model.get_Va() Vm_me2 = model.get_Vm() res_vm = np.abs(Vm_me2 - Vm[tmp_bus_ind]) res_va = np.abs(Va_me2 - Va[tmp_bus_ind]) # check that if i start the solver on the data Sbus_me = model.get_Sbus() pv_me = model.get_pv() pq_me = model.get_pq() np.all(sorted(pv_me) == sorted(net.gen["bus"])) np.all(sorted(pq_me) == sorted(tmp_bus_ind[self.pq])) plv, qlv, vlv, alv = model.get_trafolv_res() phv, qhv, vhv, ahv = model.get_trafohv_res() res_trafo = np.abs(plv - net_orig.res_trafo["p_lv_mw"].values) res_trafo_q = np.abs(qlv - net_orig.res_trafo["q_lv_mvar"].values) # self.solver.reset() # self.solver.solve(Ybus, V0, Sbus, pv_me, pq_me, max_it, tol) # Va2 = self.solver.get_Va() # Vm2 = self.solver.get_Vm() pdb.set_trace()
def _optimal_powerflow(net, verbose, suppress_warnings, **kwargs): ac = net["_options"]["ac"] init = net["_options"]["init"] ppopt = ppoption(VERBOSE=verbose, OPF_FLOW_LIM=2, PF_DC=not ac, INIT=init, **kwargs) net["OPF_converged"] = False net["converged"] = False _add_auxiliary_elements(net) reset_results(net, all_empty=False) ppc, ppci = _pd2ppc(net) if not ac: ppci["bus"][:, VM] = 1.0 net["_ppc_opf"] = ppci if len(net.dcline) > 0: ppci = add_userfcn(ppci, 'formulation', _add_dcline_constraints, args=net) if init == "pf": ppci = _run_pf_before_opf(net, ppci) if suppress_warnings: with warnings.catch_warnings(): warnings.simplefilter("ignore") result = opf(ppci, ppopt) else: result = opf(ppci, ppopt) # net["_ppc_opf"] = result if verbose: ppopt['OUT_ALL'] = 1 printpf(baseMVA=result["baseMVA"], bus=result["bus"], gen=result["gen"], fd=stdout, branch=result["branch"], success=result["success"], et=result["et"], ppopt=ppopt) if verbose: ppopt['OUT_ALL'] = 1 printpf(baseMVA=result["baseMVA"], bus=result["bus"], gen=result["gen"], fd=stdout, branch=result["branch"], success=result["success"], et=result["et"], ppopt=ppopt) 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(net, result) _clean_up(net)