Stanet converter 2.0

src/pandapipes/converter/stanet/preparing_steps.py

@@ -176,19 +176,19 @@ def get_net_params(net, stored_data):
     net_params = dict()
     net_data = stored_data["net_parameters"]
     net_params['medium'] = net_data.at[0, "MEDI"]
-    net_params["rho"] = net_data.at[0, "RHON"]
-    net_params["cp"] = net_data.at[0, "CG"]
-    net_params["eta"] = net_data.at[0, "ETA"] * 1e-6
-    net_params["t_sutherland"] = net_data.at[0, "TS"]
-    net_params["t0_sutherland"] = net_data.at[0, "T0"]
+    net_params["rho"] = float(net_data.at[0, "RHON"])
+    net_params["cp"] = float(net_data.at[0, "CG"])
+    net_params["eta"] = float(net_data.at[0, "ETA"]) * 1e-6
+    net_params["t_sutherland"] = float(net_data.at[0, "TS"])
+    net_params["t0_sutherland"] = float(net_data.at[0, "T0"])
     net_params["calculate_temp"] = str(net_data.at[0, "TEMPCALC"]) == "J"
     pp_calc_mode = "all" if net_params["calculate_temp"] else "hydraulics"
     pandapipes.set_user_pf_options(net, mode=pp_calc_mode)
-    net_params["medium_temp_C"] = net_data.at[0, "TEMP"]
-    net_params["medium_temp_K"] = net_data.at[0, "TEMP"] + 273.15
+    net_params["medium_temp_C"] = float(net_data.at[0, "TEMP"])
+    net_params["medium_temp_K"] = float(net_data.at[0, "TEMP"]) + 273.15
     net_params["calculation_results_valid"] = not bool(net_data.at[0, "CALCDIRTY"])
     net_params["household_results_valid"] = not bool(net_data.at[0, "HCALCDIRTY"])
-    net_params["comp_factor"] = net_data.at[0, "KPAR"]
+    net_params["comp_factor"] = float(net_data.at[0, "KPAR"])
     net_params["friction_model"] = int(net_data.at[0, "LAM"])
     net_params["max_iterations"] = int(net_data.at[0, "IMAX"])
     net_params["compress_model"] = compressibility_models[int(net_data.at[0, "KFAKT"])]
@@ -207,7 +207,7 @@ def get_net_params(net, stored_data):
         logger.warning("The compressibility model %s is not implemented in pandapipes, which might "
                        "lead to wrong results." % net_params["compress_model"])
 
-    pandapipes.set_user_pf_options(net, ambient_temperature=net_data.at[0, "AIRTEMP"] + 273.15)
+    pandapipes.set_user_pf_options(net, ambient_temperature=float(net_data.at[0, "AIRTEMP"]) + 273.15)
     state = 'liquid' if net_params['medium'] == 'W' else 'gas'
     fluid = pandapipes.create_constant_fluid(
         'STANET_fluid', state, density=net_params["rho"], viscosity=net_params["eta"],
@@ -272,9 +272,9 @@ def adapt_pipe_data(stored_data, pipe_data, coord_names, use_clients):
     for client_num, indices in client_types_ind.items():
         node_name = CLIENT_TYPES_OF_NODES[client_num]
         node_data = stored_data[node_name]
-        node_geo = node_data.loc[:, ["XRECHTS", "YHOCH"]]
-        node_geo.index = node_data.RECNO.values
-        node_cols = ["CLIENTNO", "CLIENT2NO"] if use_clients else ["ANFNR", "ENDNR"]
+        node_geo = node_data.loc[:, ["XRECHTS", "YHOCH"]].astype(float)
+        node_geo.index = node_data.STANETID.values if use_clients else node_data.RECNO.values
+        node_cols = ["CLIENTID", "CLIENT2ID"] if use_clients else ["ANFNR", "ENDNR"]
 
         # the following code is just a check whether pipe and node geodata fit together
         # in case of deviations, the pipe geodata is adapted on the basis of the node geodata
@@ -312,13 +312,15 @@ def get_pipe_geo(stored_data, modus):
     coord_names = ["XRA", "XRB", "YHA", "YHB"] if modus == "main" \
         else ["XRECHTS", "XRECHTS2", "YHOCH", "YHOCH2"]
     inflexion_points = "inflexion_points" if modus == "main" else "house_inflexion_points"
-
     pipe_data = stored_data[pipe_table_name]
+    pipe_data[coord_names] = pipe_data[coord_names].astype(float)
 
     adapt_pipe_data(stored_data, pipe_data, coord_names, modus != "main")
 
     pipe_geo_data = pipe_data.loc[:, coord_names + ["RECNO"]]
     if inflexion_points in stored_data:
+        columns = ['XRECHTS', 'YHOCH']
+        stored_data[inflexion_points][columns] = stored_data[inflexion_points][columns].astype(float)
         used_cols, sort_cols = ["XRECHTS", "YHOCH", "SNUM", "KNICKNO"], ["SNUM", "KNICKNO"]
         ipt = stored_data["{}".format(inflexion_points)].loc[:, used_cols].sort_values(sort_cols)
         # make lists of all x- and y-values of the inflexion points grouped by the pipe index

src/pandapipes/converter/stanet/table_creation.py

@@ -8,6 +8,8 @@
 import pandas as pd
 
 import pandapipes
+from pandapipes.properties import get_fluid
+from pandapipes.constants import NORMAL_TEMPERATURE
 from pandapipes.component_models.component_toolbox import vrange
 from pandapipes.converter.stanet.valve_pipe_component import create_valve_pipe_from_parameters
 
@@ -74,7 +76,7 @@ def create_junctions_from_nodes(net, stored_data, net_params, index_mapping, add
         add_info["stanet_layer"] = node_table.LAYER.values.astype(str)
     temperatures = pd.Series(net_params["medium_temp_K"], index=node_table.index, dtype=np.float64)
     eg_ind = ((node_table.FSTATUS == '?') & (node_table.DSTATUS == '!')).values
-    eg_temps = node_table.loc[eg_ind, "TMESS"].values + 273.15
+    eg_temps = node_table.loc[eg_ind, "TMESS"].values.astype(float) + 273.15
     if net_params["calculate_temp"]:
         temperatures.loc[eg_ind] = eg_temps
     else:
@@ -91,7 +93,7 @@ def create_junctions_from_nodes(net, stored_data, net_params, index_mapping, add
         stanet_active=node_table.ISACTIVE.values.astype(np.bool_),
         stanet_system=CLIENT_TYPES_OF_PIPES[MAIN_PIPE_TYPE], **add_info)
     for eg_junc, p_bar, t_k in zip(junction_indices[eg_ind], eg_press, eg_temps):
-        pandapipes.create_ext_grid(net, eg_junc, p_bar, t_k, type="pt",
+        pandapipes.create_ext_grid(net, eg_junc, float(p_bar), float(t_k), type="pt",
                                    stanet_system=CLIENT_TYPES_OF_PIPES[MAIN_PIPE_TYPE])
     index_mapping["nodes"] = dict(zip(stanet_nrs, junction_indices))
 
@@ -246,9 +248,9 @@ def create_slider_valves(net, stored_data, index_mapping, add_layers,
         if any(slider_valves.DM == 0):
             logger.warning(f"{sum(slider_valves.DM == 0)} sliders have an inner diameter of 0 m! "
                            f"The diameter will be set to 1 m.")
-            slider_valves.DM[slider_valves.DM == 0] = 1e3
+            slider_valves.loc[slider_valves.DM == 0, 'DM'] = 1e3
         pandapipes.create_valves(
-            net, from_junctions, to_junctions, slider_valves.DM.values / 1000,
+            net, from_junctions, to_junctions, slider_valves.DM.values.astype(float) / 1000,
             opened=slider_valves.TYP.astype(np.int32).replace(opened_types).values,
             loss_coefficient=slider_valves.ZETA.values, name=slider_valves.STANETID.values,
             type="slider_valve_" + valve_system,
@@ -321,6 +323,7 @@ def create_control_components(net, stored_data, index_mapping, net_params, add_l
     """
     if "controllers" not in stored_data:
         return
+    fluid = get_fluid(net)
     logger.info("Creating control components.")
     control_table = stored_data["controllers"]
     node_mapping = index_mapping["nodes"]
@@ -342,15 +345,24 @@ def create_control_components(net, stored_data, index_mapping, net_params, add_l
         logger.warning("There is an error in the control table! Please check the columns 'OFFEN',"
                        " 'ZU' and 'AKTIV', which should only contain 'J' or 'N'.")
 
-    control_active = (control_table.AKTIV.values == "J").astype(np.bool_)
-    if consider_controlled:
-        control_active &= ~fully_open
-    in_service = control_table.ISACTIVE.values.astype(np.bool_)
+    in_service = (control_table.AKTIV.values != "N").astype(np.bool_)
+    in_service &= control_table.ISACTIVE.values.astype(np.bool_)
     if consider_controlled:
         in_service &= ~(control_table.ZU.values == "J")
 
+    control_active = np.ones(len(control_table), dtype=bool)
+    if consider_controlled:
+        control_active &= ~fully_open
+
+    #todo: after implementing a new pressure controller RTYP should replace RSTATUS
+    is_nan = pd.isnull(control_table.RTYP.values)
+    is_pc_stat = control_table.RSTATUS.values[is_nan] == "P"
+    is_fc_stat = control_table.RSTATUS.values[is_nan] == "Q"
     is_pc = control_table.RTYP.values == "P"
     is_fc = control_table.RTYP.values == "Q"
+    is_pc[is_nan] |= is_pc_stat
+    is_fc[is_nan] |= is_fc_stat
+
     if not np.all(is_pc | is_fc):
         raise UserWarning("There are controllers of types %s that cannot be converted!" \
                                   % set(control_table.RTYP.values[~is_pc & ~is_fc]))
@@ -377,8 +389,8 @@ def create_control_components(net, stored_data, index_mapping, net_params, add_l
             stanet_is_closed=fully_closed[is_pc],
             stanet_flow_kgps=flow[is_pc],
             stanet_active=control_table.ISACTIVE.values[is_pc].astype(np.bool_),
-            **add_info
-        )
+            max_mdot_kg_per_s=control_table.QSOLL.values[is_pc].astype(float) / 3600 * fluid.get_density(NORMAL_TEMPERATURE),
+            **add_info)
 
         drop_eg = net.ext_grid.loc[net.ext_grid.junction.isin(to_junctions[is_pc])].index
         net.ext_grid.drop(drop_eg, inplace=True)
@@ -563,15 +575,15 @@ def create_pipes_from_connections(net, stored_data, connection_table, index_mapp
                          pipe_data.loc[pipe_nums, "ANFNR"].values[previous_different])
     con_to = np.insert(cons.RECNO.values, next_different_num + 1,
                        pipe_data.loc[pipe_nums, "ENDNR"].values[next_different])
-    vm_from = np.insert(cons.VMB.values, next_different_num, cons.VMA.values[next_different_num])
-    vm_to = np.insert(cons.VMA.values, next_different_num, cons.VMB.values[next_different_num])
+    vm_from = np.insert(cons.VMB.values.astype(float), next_different_num, cons.VMA.values[next_different_num].astype(float),)
+    vm_to = np.insert(cons.VMA.values.astype(float), next_different_num, cons.VMB.values[next_different_num].astype(float),)
     vm = (vm_from + vm_to) / 2
 
     pipe_sections = pd.DataFrame({
         "SNUM": pipe_numbers, "rel_length": rel_lengths, "start_pos": start_pos, "end_pos": end_pos,
         "from_type": type_from, "to_type": type_to, "from_node": con_from, "to_node": con_to,
         "full_geo": pipe_geodata.loc[pipe_numbers], "vm": vm,
-        "length": rel_lengths * pipe_data.RORL.loc[pipe_numbers].values,
+        "length": rel_lengths * pipe_data.RORL.loc[pipe_numbers].values.astype(float),
         "aux": np.ones(len(pipe_numbers), dtype=np.int32)
     })
     pipe_sections["section_no"] = pipe_sections.groupby("SNUM").aux.cumsum()
@@ -600,7 +612,7 @@ def create_geodata_sections(row):
         alpha = pipes.WDZAHL.values.astype(np.float64)
     pandapipes.create_pipes_from_parameters(
         net, pipe_sections.fj.values, pipe_sections.tj.values, pipe_sections.length.values / 1000,
-        pipes.DM.values / 1000, pipes.RAU.values, pipes.ZETA.values, type="main_pipe",
+        pipes.DM.values.astype(float) / 1000, pipes.RAU.values.astype(float), pipes.ZETA.values.astype(float), type="main_pipe",
         stanet_std_type=pipes.ROHRTYP.values, in_service=pipes.ISACTIVE.values, text_k=text_k,
         alpha_w_per_m2k=alpha,
         name=["pipe_%s_%s_%s" % (nf, nt, sec) for nf, nt, sec in zip(
@@ -729,6 +741,7 @@ def create_pipes_from_remaining_pipe_table(net, stored_data, connection_table, i
     alpha = 0
     if "WDZAHL" in p_tbl.columns:
         alpha = p_tbl.WDZAHL.values.astype(np.float64)
+    baujahr = stored_data['BAUJAHR'].values if 'BAUJAHR' in stored_data else np.nan
     pandapipes.create_pipes_from_parameters(
         net, from_junctions, to_junctions, length_km=p_tbl.RORL.values.astype(np.float64) / 1000,
         type="main_pipe", diameter_m=p_tbl.DM.values.astype(np.float64) / 1000,
@@ -740,6 +753,7 @@ def create_pipes_from_remaining_pipe_table(net, stored_data, connection_table, i
         stanet_system=CLIENT_TYPES_OF_PIPES[MAIN_PIPE_TYPE],
         stanet_active=p_tbl.ISACTIVE.values.astype(np.bool_),
         stanet_valid=~p_tbl.CALCBAD.values.astype(np.bool_),
+        construction_year=baujahr,
         **add_info
     )
 
@@ -1051,6 +1065,7 @@ def create_geodata_sections(row):
     alpha = 0
     if "WDZAHL" in hp_data.columns:
         alpha = hp_data.WDZAHL.values.astype(np.float64)
+    baujahr = stored_data['BAUJAHR'].values if 'BAUJAHR' in stored_data else np.nan
     pandapipes.create_pipes_from_parameters(
         net, hp_data.fj.values, hp_data.tj.values, hp_data.length.values / 1000,
         hp_data.DM.values / 1000, hp_data.RAU.values, hp_data.ZETA.values, type="house_pipe",
@@ -1061,7 +1076,7 @@ def create_geodata_sections(row):
         stanet_std_type=hp_data.ROHRTYP.values, stanet_nr=hp_data.RECNO.values,
         stanet_id=hp_data.STANETID.values, v_stanet=hp_data.VM.values,
         stanet_active=hp_data.ISACTIVE.values.astype(np.bool_),
-        stanet_valid=houses_in_calculation, **add_info
+        stanet_valid=houses_in_calculation, construction_year=baujahr, **add_info
     )