def get_bus_bus_switch_indices_from_csv(switch_table, node_table, error_type=ValueError): """ Returns a list of indices of bus-bus-switches from csv tables. """ for nodeX in ["nodeA", "nodeB"]: missing_nodeX = switch_table[~switch_table[nodeX].isin(node_table.id)] if len(missing_nodeX): message = "At Switches " + str(["%s" % name for name in missing_nodeX.id]) + \ " %s " % nodeX + str(["%s" % name for name in missing_nodeX[nodeX]]) + \ " do not occur in Node table." raise ValueError(message) idx_nodeA = idx_in_2nd_array(switch_table.nodeA.values, node_table.id.values) idx_nodeB = idx_in_2nd_array(switch_table.nodeB.values, node_table.id.values) aux_nodeA = np.array(node_table.type[idx_nodeA] == "auxiliary") aux_nodeB = np.array(node_table.type[idx_nodeB] == "auxiliary") double_aux = switch_table.id[aux_nodeA & aux_nodeB] if len(double_aux): message = "Both side auxiliary nodes at Switches " + str([ "%s" % name for name in double_aux]) if error_type is None or error_type is False: logger.debug(message) else: raise error_type(message) return list(switch_table.index[~(aux_nodeA | aux_nodeB)])
def test_idx_in_2nd_array(): arr1 = np.array([1, 6, 4.6, 3.4, 6, 1, "Hallo", "hallo", "Hallo"]) arr2 = np.array([8, 4, 1, 2, 5, 5.6, 4.6, "Hallo", "hallo", 6, 3.4]) expected_res = np.array([2, 9, 6, 10, 9, 2, 7, 8, 7]) res = sb.idx_in_2nd_array(arr1, arr2) assert all(res == expected_res) arr2[-1] = 4.7 expected_res[3] = 1 res = sb.idx_in_2nd_array(arr1, arr2, match=False) assert all(res == expected_res) try: sb.idx_in_2nd_array(arr1, arr2, match=True) except_ = False except ValueError: except_ = True assert except_
def get_absolute_profiles_from_relative_profiles(net, element, multiplying_column, relative_profiles=None, profile_column="profile", profile_suffix=None, time_as_index=False, **kwargs): """ Returns a DataFrame with profiles for the given element (e.g. loads or sgens). The profiles values are calculated by multiplying the relative profiles given by relative_profiles (or if not given, from net["profiles"]) with the values in net[element][multiplying_column]. INPUT: **net** (pandapowerNet) - pandapower net **element** (str) - element type for which absolute profiles are calculated. Possible are "load", "gen", "sgen" or "storage". **multiplying_column** (str) - column name within net[element].columns which should be multiplied with the relative profiles. Usual multiply_columns are 'p_mw' or 'q_mvar'. Additional Feature: If multiplying_column is not a string, the relative profiles are not multiplied with net[element][multiplying_column] but with 'multiplying_column' itself. OPTIONAL: **relative_profiles** (DataFrame, None) - DataFrame of relative profiles as input. If None, net["profiles"] is considered. **profile_column** (str, "profile") - Name of the column which contains information about which element is assigned to which profile. In SimBench grids, this information is given in the column "profile". For that reason, 'profile' is the default. **profile_suffix** (str, None) - For the case that different profiles are given for p and q, these can be distinguished by a suffix. For loads this can be "_pload" and "_qload", which will be automatically assumed, if profile_suffix is None. **time_as_index** (bool, False) - If True, the returned DataFrame has relative_profiles["time"] as index. If False, relative_profiles.index is used. ****kwargs** - key word arguments for merge_dataframes() OUTPUT: **output_profiles** (DataFrame) - calculated absolute profiles """ # --- use net.profiles if relative_profiles is None if relative_profiles is None: if element in ["load", "storage"]: relative_profiles = net.profiles[element] elif element in ["gen", "sgen"]: # Since RES and Powerplants can be converted to pandapower as both, gen or sgen, both # are considered together relative_profiles = merge_dataframes( [net.profiles["powerplants"], net.profiles["renewables"]], **kwargs) else: raise ValueError("element %s is unknown." % str(element)) # --- set index index = relative_profiles[ "time"] if time_as_index else relative_profiles.index if "time" in relative_profiles: del relative_profiles["time"] # --- do profile_suffix assumptions if profile_suffix is None if profile_suffix is None: if element == "load": if multiplying_column == "p_mw": profile_suffix = "_pload" elif multiplying_column == "q_mvar": profile_suffix = "_qload" profile_suffix = "" if profile_suffix is None else profile_suffix # --- get relative profiles with respect to each element index if profile_column in net[element].columns: applied_profiles = net[element][profile_column] + profile_suffix else: # missing profile column logger.warning( "In %s table, profile column '%s' is missing. Scalings of 1 are assumed." % (element, profile_column)) missing_col_handling = "missing_col_handling" applied_profiles = pd.Series([missing_col_handling] * net[element].shape[0], index=net[element].index) relative_profiles[missing_col_handling] = 1 # nan profile handling if applied_profiles.isnull().any(): logger.debug("There are nan profiles. Scalings of 1 are assumed.") nan_profile_handling = "nan_profile_scaling" assert nan_profile_handling not in relative_profiles.columns applied_profiles.loc[applied_profiles.isnull()] = nan_profile_handling relative_profiles[nan_profile_handling] = 1 relative_output_profiles = relative_profiles.values[:, idx_in_2nd_array( applied_profiles. values, np.array( relative_profiles .columns))] # --- get factor to multiply with (consider additional feature of 'multiplying_column') if isinstance(multiplying_column, str): if multiplying_column in net[element].columns: factor = net[element][multiplying_column].values.reshape(1, -1) else: raise ValueError( "'multiplying_column' %s is not net[%s].columns." % (multiplying_column, element)) else: factor = multiplying_column # --- multiply relative profiles with factor and return results output_profiles = pd.DataFrame(relative_output_profiles * factor, index=index, columns=net[element].index) return output_profiles