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

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
 

foxes/input/windio/read_outputs.py

@@ -5,28 +5,39 @@ from foxes.utils import Dict
 import foxes.variables as FV
 import foxes.constants as FC
 
+from .read_fields import foxes2wio
+
+
 def _read_turbine_outputs(wio_outs, odir, out_dicts, verbosity):
-    """ Reads the turbine outputs request """
-    if "turbine_outputs" in wio_outs and wio_outs["turbine_outputs"].get("report", True):
+    """Reads the turbine outputs request"""
+    if "turbine_outputs" in wio_outs and wio_outs["turbine_outputs"].get(
+        "report", True
+    ):
         turbine_outputs = Dict(wio_outs["turbine_outputs"], name="turbine_outputs")
-        turbine_nc_filename = turbine_outputs.pop("turbine_nc_filename", "turbine_outputs.nc")
+        turbine_nc_filename = turbine_outputs.pop(
+            "turbine_nc_filename", "turbine_outputs.nc"
+        )
         output_variables = turbine_outputs["output_variables"]
         if verbosity > 2:
             print("      Reading turbine_outputs")
             print("        File name:", turbine_nc_filename)
             print("        output_variables:", output_variables)
-        
+
         vmap = Dict(
             power=FV.P,
             rotor_effective_velocity=FV.REWS,
         )
         ivmap = {d: k for k, d in vmap.items()}
-        ivmap.update({
-            FC.STATE: "time", 
-            FC.TURBINE: "turbine",
-        })
-        
-        out_dicts.append(Dict({
+        ivmap.update(
+            {
+                FC.STATE: "time",
+                FC.TURBINE: "turbine",
+            }
+        )
+
+        out_dicts.append(
+            Dict(
+                {
                     "output_type": "StateTurbineTable",
                     "farm_results": True,
                     "algo": False,
@@ -34,16 +45,23 @@ def _read_turbine_outputs(wio_outs, odir, out_dicts, verbosity):
                     "run_kwargs": dict(
                         variables=[vmap[v] for v in output_variables],
                         name_map=ivmap,
-                        to_file=odir/turbine_nc_filename,
+                        to_file=odir / turbine_nc_filename,
+                        round={
+                            vw: FV.get_default_digits(vf) for vw, vf in vmap.items()
+                        },
                         verbosity=verbosity,
                     ),
                     "output_yaml_update": {
                         "power_table": f"include {turbine_nc_filename}",
                     },
-                }, name = "turbine_outputs"))
+                },
+                name="turbine_outputs",
+            )
+        )
+
 
 def _read_flow_field(wio_outs, odir, out_dicts, verbosity):
-    """ Reads the flow field request """
+    """Reads the flow field request"""
     if "flow_field" in wio_outs and wio_outs["flow_field"].get("report", True):
         flow_field = Dict(wio_outs["flow_field"], name="flow_field")
         flow_nc_filename = flow_field.pop("flow_nc_filename", "flow_field.nc")
@@ -51,10 +69,15 @@ def _read_flow_field(wio_outs, odir, out_dicts, verbosity):
         z_planes = Dict(flow_field.pop("z_planes"), name="z_planes")
         z_sampling = z_planes["z_sampling"]
         xy_sampling = z_planes["xy_sampling"]
+        cases_run = Dict(flow_field.pop("cases_run", {}), name="cases_run")
+        states_isel = cases_run.get("subset", None)
+        if "all_occurences" in cases_run and cases_run.pop("all_occurences"):
+            states_isel = None
         if verbosity > 2:
             print("      Reading flow_field")
             print("        File name       :", flow_nc_filename)
             print("        output_variables:", output_variables)
+            print("        states subset   :", states_isel)
             print("        z_sampling      :", z_sampling)
             print("        xy_sampling     :", xy_sampling)
 
@@ -62,29 +85,47 @@ def _read_flow_field(wio_outs, odir, out_dicts, verbosity):
             wind_speed=FV.WS,
             wind_direction=FV.WD,
         )
-        
+
+        if z_sampling in ["hub_height", "default"]:
+            z = None
+        elif isinstance(z_sampling, (int, float)):
+            z = z_sampling
+        else:
+            raise NotImplementedError(
+                f"z_sampling '{z_sampling}' of type '{type(z_sampling).__name__}' is not supported (yet). Please give 'hub_height', 'default' or a float."
+            )
+
         if xy_sampling == "default":
-            out_dicts.append(Dict({
+            out_dicts.append(
+                Dict(
+                    {
                         "output_type": "SliceData",
                         "farm_results": True,
                         "algo": True,
                         "verbosity_delta": 3,
                         "run_func": "get_states_data_xy",
                         "run_kwargs": dict(
-                            resolution=30.,
+                            states_isel=states_isel,
+                            n_img_points=(100, 100),
                             variables=[vmap[v] for v in output_variables],
-                            z=None if z_sampling == "hub_height" else z_sampling,
-                            to_file=odir/flow_nc_filename,
+                            z=z,
+                            to_file=odir / flow_nc_filename,
+                            label_map=foxes2wio,
                             verbosity=verbosity,
                         ),
                         "output_yaml_update": {
                             "flow_field": f"include {flow_nc_filename}",
                         },
-                    }, name = "flow_field"))
+                    },
+                    name="flow_field",
+                )
+            )
         else:
-            raise NotImplementedError(f"xy_sampling '{xy_sampling}' is not supported (yet)")
-            
-        
+            raise NotImplementedError(
+                f"xy_sampling '{xy_sampling}' is not supported (yet)"
+            )
+
+
 def read_outputs(wio_outs, algo_dict, verbosity):
     """
     Reads the windio outputs

foxes/input/windio/runner.py

@@ -5,7 +5,7 @@ from foxes.output import Output
 
 
 def _write_yaml(data, fpath):
-    """ Write the data to yaml """
+    """Write the data to yaml"""
     rmap = {
         "include": "!include",
     }
@@ -13,11 +13,12 @@ def _write_yaml(data, fpath):
         yaml.dump(data, file)
     with open(fpath, "r") as f:
         s = f.read()
-    with open(fpath, 'w') as f:
+    with open(fpath, "w") as f:
         for k1, k2 in rmap.items():
             s = s.replace(k1, k2)
         f.write(s)
-        
+
+
 class WindioRunner:
     """
     Runner for windio input
@@ -40,6 +41,10 @@ class WindioRunner:
         Name of the written input data file
     file_name_output_yaml: str
         Name of the written output data file
+    write_input_yaml: bool
+        Flag for writing file_name_input_yaml
+    write_output_yaml: bool
+        Flag for writing file_name_output_yaml
     verbosity: int
         The verbosity level, 0 = silent
 
@@ -48,15 +53,17 @@ class WindioRunner:
     """
 
     def __init__(
-        self, 
-        algo_dict, 
+        self,
+        algo_dict,
         output_dir=".",
-        output_dicts=[], 
-        wio_input_data=None, 
+        output_dicts=[],
+        wio_input_data=None,
         file_name_input_yaml="recorded_input.yaml",
         file_name_output_yaml="recorded_output.yaml",
+        write_input_yaml=False,
+        write_output_yaml=False,
         verbosity=1,
-        ):
+    ):
         """
         Conbstructor
 
@@ -74,6 +81,10 @@ class WindioRunner:
             Name of the written input data file
         file_name_output_yaml: str
             Name of the written output data file
+        write_input_yaml: bool
+            Flag for writing file_name_input_yaml
+        write_output_yaml: bool
+            Flag for writing file_name_output_yaml
         verbosity: int
             The verbosity level, 0 = silent
 
@@ -84,15 +95,17 @@ class WindioRunner:
         self.wio_input_data = wio_input_data
         self.file_name_input_yaml = file_name_input_yaml
         self.file_name_output_yaml = file_name_output_yaml
+        self.write_input_yaml = write_input_yaml
+        self.write_output_yaml = write_output_yaml
         self.verbosity = verbosity
         self.farm_results = None
         self.output_results = None
 
         self.__initialized = False
-        
+
         self._output_yaml = {}
-        if wio_input_data is not None and len(wio_input_data):
-            fpath = output_dir/file_name_input_yaml
+        if self.write_input_yaml and len(wio_input_data):
+            fpath = output_dir / file_name_input_yaml
             self.print(f"Writing file", fpath)
             _write_yaml(wio_input_data, fpath)
             self._output_yaml["wind_energy_system"] = f"include {file_name_input_yaml}"
@@ -131,7 +144,7 @@ class WindioRunner:
             run_fname = odict.pop("run_func")
             run_args = odict.pop("run_args", ())
             run_kwargs = odict.pop("run_kwargs", {})
-                    
+
             _odict = odict.copy()
             if "output_yaml_update" in _odict:
                 self._output_yaml.update(_odict.pop("output_yaml_update"))
@@ -142,11 +155,12 @@ class WindioRunner:
             o = Output.new(**_odict)
             f = getattr(o, run_fname)
             self.output_results.append(f(*run_args, **run_kwargs))
-            
-        fpath = self.output_dir/self.file_name_output_yaml
-        self.print(f"Writing file", fpath)
-        _write_yaml(self._output_yaml, fpath)
-            
+
+        if self.write_output_yaml:
+            fpath = self.output_dir / self.file_name_output_yaml
+            self.print(f"Writing file", fpath)
+            _write_yaml(self._output_yaml, fpath)
+
     def run(self):
         """Runs all calculations"""
         self.run_farm_calc()