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