foxes 0.8.2__py3-none-any.whl → 1.1.0.2__py3-none-any.whl

foxes/input/windio/read_attributes.py

@@ -5,7 +5,9 @@ import foxes.variables as FV
 from .read_outputs import read_outputs
 
 
-def _read_wind_deficit(wind_deficit, superposition, induction, algo_dict, verbosity):
+def _read_wind_deficit(
+    wake_model_key, wind_deficit, superposition, induction, algo_dict, verbosity
+):
     """Reads the wind deficit wake model"""
 
     wind_def_map = Dict(
@@ -22,6 +24,7 @@ def _read_wind_deficit(wind_deficit, superposition, induction, algo_dict, verbos
         {
             "Linear": "ws_linear",
             "Quadratic": "ws_quadratic",
+            "Product": "ws_product",
         },
         name="ws_sup_dict",
     )
@@ -29,14 +32,15 @@ def _read_wind_deficit(wind_deficit, superposition, induction, algo_dict, verbos
         {
             "Linear": "ws_linear_amb",
             "Quadratic": "ws_quadratic_amb",
+            "Product": "ws_product",
         },
         name="ws_sup_dict",
     )
-    
+
     wname = wind_deficit.pop("name")
     eff_ws = wind_deficit.pop("use_effective_ws", True)
     if verbosity > 2:
-        print("    Reading wind_deficit_model")
+        print("    Reading", wake_model_key)
         print("      Name    :", wname)
         print("      Eff ws  :", eff_ws)
         print("      Contents:", [k for k in wind_deficit.keys()])
@@ -73,6 +77,7 @@ def _read_wind_deficit(wind_deficit, superposition, induction, algo_dict, verbos
 
     return ka, kb, amb_ti
 
+
 def _read_turbulence(
     turbulence_model, superposition, induction, algo_dict, ka, kb, amb_ti, verbosity
 ):
@@ -99,7 +104,7 @@ def _read_turbulence(
         print("    Reading turbulence_model")
         print("      Name:", wname)
         print("      Contents:", [k for k in turbulence_model.keys()])
-    if wname != "None":
+    if wname not in ["None", "none"]:
         tiwake_dict = dict(wmodel_type=twake_def_map[wname], induction=induction)
         if wname == "IEC-TI-2019":
             tiwake_dict["opening_angle"] = None
@@ -129,6 +134,7 @@ def _read_turbulence(
             print("       ", algo_dict["mbook"].wake_models[wname])
         algo_dict["wake_models"].append(wname)
 
+
 def _read_blockage(blockage_model, induction, algo_dict, verbosity):
     """Reads the blockage model"""
     indc_def_map = Dict(
@@ -146,7 +152,7 @@ def _read_blockage(blockage_model, induction, algo_dict, verbosity):
         print("    Reading blockage_model")
         print("      Name:", wname)
         print("      Contents:", [k for k in blockage_model.keys()])
-    if wname != "None":
+    if wname not in ["None", "none"]:
         indc_dict = Dict(wmodel_type=indc_def_map[wname], induction=induction)
         algo_dict["mbook"].wake_models[wname] = WakeModel.new(**indc_dict)
         if verbosity > 2:
@@ -155,6 +161,7 @@ def _read_blockage(blockage_model, induction, algo_dict, verbosity):
         algo_dict["wake_models"].append(wname)
         algo_dict["algo_type"] = "Iterative"
 
+
 def _read_rotor_averaging(rotor_averaging, algo_dict, verbosity):
     """Reads the rotor averaging"""
     if verbosity > 2:
@@ -177,16 +184,20 @@ def _read_rotor_averaging(rotor_averaging, algo_dict, verbosity):
         print("        wake_averaging      :", wake_averaging)
         print("        ws exponent power   :", wse_P)
         print("        ws exponent ct      :", wse_ct)
+
     if background_averaging in ["center", "centre"]:
         algo_dict["rotor_model"] = "centre"
+    elif background_averaging in ["none", "None", None]:
+        algo_dict["rotor_model"] = None
     elif background_averaging == "grid":
         algo_dict["rotor_model"] = f"grid{nx*ny}"
     else:
-        raise KeyError(
-            f"Expecting background_averaging 'center' or 'grid', got '{background_averaging}'"
-        )
+        algo_dict["rotor_model"] = background_averaging
+
     if wake_averaging in ["centre", "center"]:
         algo_dict["partial_wakes"] = "centre"
+    elif wake_averaging in ["none", "None", "auto", None]:
+        algo_dict["partial_wakes"] = None
     elif wake_averaging == "grid":
         if background_averaging == "grid":
             algo_dict["partial_wakes"] = "rotor_points"
@@ -197,10 +208,12 @@ def _read_rotor_averaging(rotor_averaging, algo_dict, verbosity):
                 algo_dict["partial_wakes"] = grid
     else:
         algo_dict["partial_wakes"] = wake_averaging
+
     if verbosity > 2:
         print("        --> rotor_model     :", algo_dict["rotor_model"])
         print("        --> partial_wakes   :", algo_dict["partial_wakes"])
 
+
 def _read_deflection(deflection, induction, algo_dict, verbosity):
     """Reads deflection model"""
     defl_def_map = Dict(
@@ -228,6 +241,7 @@ def _read_deflection(deflection, induction, algo_dict, verbosity):
         print("       ", algo_dict["mbook"].wake_frames[wname])
     algo_dict["wake_frame"] = wname
 
+
 def _read_analysis(wio_ana, algo_dict, verbosity):
     """Reads the windio analyses"""
     if verbosity > 2:
@@ -253,16 +267,26 @@ def _read_analysis(wio_ana, algo_dict, verbosity):
         print("    axial induction model:", induction)
 
     # wind deficit model:
-    wind_deficit = Dict(wio_ana["wind_deficit_model"], name="wind_deficit_model")
+    wake_model_key = (
+        "wind_deficit_model" if "wind_deficit_model" in wio_ana else "wake_model"
+    )
+    wind_deficit = Dict(wio_ana[wake_model_key], name=wake_model_key)
     ka, kb, amb_ti = _read_wind_deficit(
-        wind_deficit, superposition, induction, algo_dict, verbosity
+        wake_model_key, wind_deficit, superposition, induction, algo_dict, verbosity
     )
 
     # turbulence model:
     if "turbulence_model" in wio_ana:
         turbulence_model = Dict(wio_ana["turbulence_model"], name="turbulence_model")
         _read_turbulence(
-            turbulence_model, superposition, induction, algo_dict, ka, kb, amb_ti, verbosity
+            turbulence_model,
+            superposition,
+            induction,
+            algo_dict,
+            ka,
+            kb,
+            amb_ti,
+            verbosity,
         )
     elif verbosity > 0:
         print("turbulence_model not found, not using a TI wake model")
@@ -273,22 +297,23 @@ def _read_analysis(wio_ana, algo_dict, verbosity):
         _read_blockage(blockage_model, induction, algo_dict, verbosity)
     elif verbosity > 0:
         print("blockage_model not found, not using a turbine induction model")
-        
+
     # rotor_averaging:
     if "rotor_averaging" in wio_ana:
         rotor_averaging = Dict(wio_ana["rotor_averaging"], name="rotor_averaging")
         _read_rotor_averaging(rotor_averaging, algo_dict, verbosity)
     elif verbosity > 0:
         print("rotor_averaging not found, using default settings")
-        
+
     # deflection:
     if "deflection_model" in wio_ana:
         deflection = Dict(wio_ana["deflection_model"], name="deflection_model")
         _read_deflection(deflection, induction, algo_dict, verbosity)
     elif verbosity > 0:
         print("deflection_model not found, using default settings")
-        
-def read_attributes(wio, algo_dict, verbosity):
+
+
+def read_attributes(wio, algo_dict, verbosity=1, **output_pars):
     """
     Reads the attributes part of windio
 
@@ -300,11 +325,15 @@ def read_attributes(wio, algo_dict, verbosity):
         The algorithm dictionary
     verbosity: int
         The verbosity level, 0=silent
+    **output_pars: dict, optional
+        Additional parameters for output reading
 
     Returns
     -------
     out_dicts: list of dict
         The output dictionaries
+    odir: pathlib.Path
+        Path to the output folder
 
     :group: input.windio
 
@@ -333,6 +362,8 @@ def read_attributes(wio, algo_dict, verbosity):
     out_dicts = []
     if "outputs" in wio_attrs:
         outputs = Dict(wio_attrs["outputs"], name="outputs")
-        out_dicts = read_outputs(outputs, algo_dict, verbosity)
+        out_dicts, odir = read_outputs(
+            outputs, algo_dict, verbosity=verbosity, **output_pars
+        )
 
-    return out_dicts
+    return out_dicts, odir

foxes/input/windio/read_farm.py

@@ -6,14 +6,14 @@ from foxes.core import Turbine, TurbineType
 import foxes.variables as FV
 
 
-def read_turbine_type(wio_trbns, algo_dict, ws_exp_P, ws_exp_ct, verbosity):
+def read_turbine_types(wio_farm, algo_dict, ws_exp_P, ws_exp_ct, verbosity):
     """
     Reads the turbine type from windio
 
     Parameters
     ----------
-    wio_trbns: dict
-        The windio turbines data
+    wio_farm: dict
+        The windio farm data
     algo_dict: dict
         The algorithm dictionary
     ws_exp_P: int
@@ -25,107 +25,116 @@ def read_turbine_type(wio_trbns, algo_dict, ws_exp_P, ws_exp_ct, verbosity):
 
     Returns
     -------
-    ttype: str
-        The turbine type model name
+    ttypes: dict
+        Mapping from turbine type key to turbine
+        type name in the model book
 
     :group: input.windio
 
     """
-    tname = wio_trbns.pop("name")
-    if verbosity > 2:
-        print("    Reading wio_trbns")
-        print("      Name:", tname)
-        print("      Contents:", [k for k in wio_trbns.keys()])
-
-    # read performance:
-    performance = Dict(wio_trbns["performance"], name="performance")
-    if verbosity > 2:
-        print("        Reading performance")
-        print("          Contents:", [k for k in performance.keys()])
-
-    # P, ct data:
-    if "power_curve" in performance:
-        power_curve = Dict(performance["power_curve"], name="power_curve")
-        if verbosity > 2:
-            print("            Reading power_curve")
-            print("              Contents:", [k for k in power_curve.keys()])
-        P = power_curve["power_values"]
-        ws_P = power_curve["power_wind_speeds"]
-        ct_curve = Dict(performance["Ct_curve"], name="Ct_values")
-        if verbosity > 2:
-            print("            Reading Ct_curve")
-            print("              Contents:", [k for k in ct_curve.keys()])
-        ct = ct_curve["Ct_values"]
-        ws_ct = ct_curve["Ct_wind_speeds"]
-
-        data_P = pd.DataFrame(data={"ws": ws_P, "P": P})
-        data_ct = pd.DataFrame(data={"ws": ws_ct, "ct": ct})
-
-        def _get_wse_var(wse):
-            if wse not in [1, 2, 3]:
-                raise ValueError(f"Expecting wind speed exponent 1, 2 or 3, got {wse}")
-            return FV.REWS if wse == 1 else (FV.REWS2 if wse == 2 else FV.REWS3)
-
-        if verbosity > 2:
-            print(f"            Creating model '{tname}'")
-            print(f"              Turbine type class: PCtFromTwo")
-        algo_dict["mbook"].turbine_types[tname] = TurbineType.new(
-            ttype_type="PCtFromTwo",
-            data_source_P=data_P,
-            data_source_ct=data_ct,
-            col_ws_P_file="ws",
-            col_ws_ct_file="ws",
-            col_P="P",
-            col_ct="ct",
-            H=wio_trbns["hub_height"],
-            D=wio_trbns["rotor_diameter"],
-            var_ws_ct=_get_wse_var(ws_exp_ct),
-            var_ws_P=_get_wse_var(ws_exp_P),
-            rho=1.225,
-        )
-        if verbosity > 2:
-            print("               ", algo_dict["mbook"].turbine_types[tname])
+    if "turbine_types" not in wio_farm:
+        wio_farm["turbine_types"] = {0: wio_farm["turbines"]}
 
-    # P, ct data:
-    elif "Cp_curve" in performance:
-        cp_curve = Dict(performance["Cp_curve"], name="Cp_curve")
-        if verbosity > 2:
-            print("            Reading Cp_curve")
-            print("              Contents:", [k for k in cp_curve.keys()])
-        cp = cp_curve["Cp_values"]
-        ws_cp = cp_curve["Cp_wind_speeds"]
-        ct_curve = Dict(performance["Ct_curve"], name="Ct_values")
+    ttypes = {}
+    for k, wio_trbns in wio_farm["turbine_types"].items():
+        tname = wio_trbns.pop("name")
+        ttypes[k] = tname
         if verbosity > 2:
-            print("            Reading Ct_curve")
-            print("              Contents:", [k for k in ct_curve.keys()])
-        ct = ct_curve["Ct_values"]
-        ws_ct = ct_curve["Ct_wind_speeds"]
-
-        data_cp = pd.DataFrame(data={"ws": ws_cp, "cp": cp})
-        data_ct = pd.DataFrame(data={"ws": ws_ct, "ct": ct})
+            print("    Reading turbine type", k)
+            print("      Name:", tname)
+            print("      Contents:", [k for k in wio_trbns.keys()])
 
+        # read performance:
+        performance = Dict(wio_trbns["performance"], name="performance")
         if verbosity > 2:
-            print(f"            Creating model '{tname}'")
-            print(f"              Turbine type class: CpCtFromTwo")
-        algo_dict["mbook"].turbine_types[tname] = TurbineType.new(
-            ttype_type="CpCtFromTwo",
-            data_source_cp=data_cp,
-            data_source_ct=data_ct,
-            col_ws_cp_file="ws",
-            col_ws_ct_file="ws",
-            col_cp="cp",
-            col_ct="ct",
-            H=wio_trbns["hub_height"],
-            D=wio_trbns["rotor_diameter"],
-        )
-
-    else:
-        raise KeyError(f"Expecting either 'power_curve' or 'Cp_curve'")
-
-    return tname
-
-
-def read_layout(lname, ldict, algo_dict, ttype, verbosity=1):
+            print("        Reading performance")
+            print("          Contents:", [k for k in performance.keys()])
+
+        # P, ct data:
+        if "power_curve" in performance:
+            power_curve = Dict(performance["power_curve"], name="power_curve")
+            if verbosity > 2:
+                print("            Reading power_curve")
+                print("              Contents:", [k for k in power_curve.keys()])
+            P = power_curve["power_values"]
+            ws_P = power_curve["power_wind_speeds"]
+            ct_curve = Dict(performance["Ct_curve"], name="Ct_values")
+            if verbosity > 2:
+                print("            Reading Ct_curve")
+                print("              Contents:", [k for k in ct_curve.keys()])
+            ct = ct_curve["Ct_values"]
+            ws_ct = ct_curve["Ct_wind_speeds"]
+
+            data_P = pd.DataFrame(data={"ws": ws_P, "P": P})
+            data_ct = pd.DataFrame(data={"ws": ws_ct, "ct": ct})
+
+            def _get_wse_var(wse):
+                if wse not in [1, 2, 3]:
+                    raise ValueError(
+                        f"Expecting wind speed exponent 1, 2 or 3, got {wse}"
+                    )
+                return FV.REWS if wse == 1 else (FV.REWS2 if wse == 2 else FV.REWS3)
+
+            if verbosity > 2:
+                print(f"            Creating model '{tname}'")
+                print(f"              Turbine type class: PCtFromTwo")
+            algo_dict["mbook"].turbine_types[tname] = TurbineType.new(
+                ttype_type="PCtFromTwo",
+                data_source_P=data_P,
+                data_source_ct=data_ct,
+                col_ws_P_file="ws",
+                col_ws_ct_file="ws",
+                col_P="P",
+                col_ct="ct",
+                H=wio_trbns["hub_height"],
+                D=wio_trbns["rotor_diameter"],
+                var_ws_ct=_get_wse_var(ws_exp_ct),
+                var_ws_P=_get_wse_var(ws_exp_P),
+                rho=1.225,
+            )
+            if verbosity > 2:
+                print("               ", algo_dict["mbook"].turbine_types[tname])
+
+        # P, ct data:
+        elif "Cp_curve" in performance:
+            cp_curve = Dict(performance["Cp_curve"], name="Cp_curve")
+            if verbosity > 2:
+                print("            Reading Cp_curve")
+                print("              Contents:", [k for k in cp_curve.keys()])
+            cp = cp_curve["Cp_values"]
+            ws_cp = cp_curve["Cp_wind_speeds"]
+            ct_curve = Dict(performance["Ct_curve"], name="Ct_values")
+            if verbosity > 2:
+                print("            Reading Ct_curve")
+                print("              Contents:", [k for k in ct_curve.keys()])
+            ct = ct_curve["Ct_values"]
+            ws_ct = ct_curve["Ct_wind_speeds"]
+
+            data_cp = pd.DataFrame(data={"ws": ws_cp, "cp": cp})
+            data_ct = pd.DataFrame(data={"ws": ws_ct, "ct": ct})
+
+            if verbosity > 2:
+                print(f"            Creating model '{tname}'")
+                print(f"              Turbine type class: CpCtFromTwo")
+            algo_dict["mbook"].turbine_types[tname] = TurbineType.new(
+                ttype_type="CpCtFromTwo",
+                data_source_cp=data_cp,
+                data_source_ct=data_ct,
+                col_ws_cp_file="ws",
+                col_ws_ct_file="ws",
+                col_cp="cp",
+                col_ct="ct",
+                H=wio_trbns["hub_height"],
+                D=wio_trbns["rotor_diameter"],
+            )
+
+        else:
+            raise KeyError(f"Expecting either 'power_curve' or 'Cp_curve'")
+
+    return ttypes
+
+
+def read_layout(lname, ldict, algo_dict, ttypes, verbosity=1):
     """
     Read wind farm layout from windio input
 
@@ -137,8 +146,9 @@ def read_layout(lname, ldict, algo_dict, ttype, verbosity=1):
         The layout data
     algo_dict: dict
         The algorithm dictionary
-    ttype: str
-        Name of the turbine type model
+    ttypes: dict
+        Mapping from turbine type key to turbine
+        type name in the model book
     verbosity: int
         The verbosity level, 0=silent
 
@@ -154,10 +164,14 @@ def read_layout(lname, ldict, algo_dict, ttype, verbosity=1):
         print(f"        Reading '{lname}'")
     cdict = Dict(ldict["coordinates"], name="coordinates")
     farm = algo_dict["farm"]
-    for xy in zip(cdict["x"], cdict["y"]):
+    tmap = ldict.get("turbine_types", None)
+    if verbosity > 2:
+        print(f"          Turbine type map:", tmap)
+    for i, xy in enumerate(zip(cdict["x"], cdict["y"])):
+        tt = ttypes[tmap[i] if tmap is not None else 0]
         farm.add_turbine(
-            Turbine(xy=np.array(xy), turbine_models=[ttype]),
-            verbosity=verbosity-3,
+            Turbine(xy=np.array(xy), turbine_models=[tt]),
+            verbosity=verbosity - 3,
         )
     if verbosity > 2:
-        print(f"          Added {farm.n_turbines} wio_trbns of type '{ttype}'")
+        print(f"          Added {farm.n_turbines} turbines")

foxes/input/windio/read_fields.py

@@ -28,6 +28,7 @@ wio2foxes = {
 """
 foxes2wio = {d: k for k, d in wio2foxes.items()}
 
+
 def _read_nondimensional_coordinate(name, wio_data, coords):
     """read nondimensional coordinate
     :group: input.windio
@@ -37,6 +38,7 @@ def _read_nondimensional_coordinate(name, wio_data, coords):
         return True
     return False
 
+
 def _read_dimensional_coordinate(name, wio_data, coords):
     """read dimensional coordinate
     :group: input.windio
@@ -48,6 +50,7 @@ def _read_dimensional_coordinate(name, wio_data, coords):
         return True
     return False
 
+
 def _read_multi_dimensional_coordinate(name, wio_data, coords):
     """Read multi dimensional coordinate
     :group: input.windio
@@ -56,6 +59,7 @@ def _read_multi_dimensional_coordinate(name, wio_data, coords):
         name, wio_data, coords
     ) or _read_dimensional_coordinate(name, wio_data, coords)
 
+
 def _read_nondimensional_data(name, wio_data, fields, dims):
     """read nondimensional data
     :group: input.windio
@@ -67,6 +71,7 @@ def _read_nondimensional_data(name, wio_data, fields, dims):
         return True
     return False
 
+
 def _read_dimensional_data(name, wio_data, fields, dims):
     """read dimensional data
     :group: input.windio
@@ -83,6 +88,7 @@ def _read_dimensional_data(name, wio_data, fields, dims):
         return True
     return False
 
+
 def _read_multi_dimensional_data(name, wio_data, fields, dims):
     """Read multi dimensional data
     :group: input.windio
@@ -91,14 +97,15 @@ def _read_multi_dimensional_data(name, wio_data, fields, dims):
         name, wio_data, fields, dims
     ) or _read_dimensional_data(name, wio_data, fields, dims)
 
+
 def read_wind_resource_field(
-    name, 
-    wio_data, 
-    coords, 
-    fields, 
-    dims, 
+    name,
+    wio_data,
+    coords,
+    fields,
+    dims,
     verbosity,
-    ):
+):
     """
     Reads wind resource data into fields and dims
 
@@ -136,6 +143,9 @@ def read_wind_resource_field(
         "lapse_rate",
         "capping_inversion_thickness",
         "capping_inversion_strength",
+        "tau_x",
+        "tau_y",
+        "fc",
     ]:
         if verbosity > 2:
             print(f"        Ignoring variable '{name}'")