foxes 1.1.1__py3-none-any.whl → 1.2.1__py3-none-any.whl

foxes/input/{windio → yaml/windio}/read_farm.py

@@ -6,7 +6,7 @@ from foxes.core import Turbine, TurbineType
 import foxes.variables as FV
 
 
-def read_turbine_types(wio_farm, algo_dict, ws_exp_P, ws_exp_ct, verbosity):
+def read_turbine_types(wio_farm, mbook, ws_exp_P, ws_exp_ct, verbosity):
     """
     Reads the turbine type from windio
 
@@ -14,8 +14,8 @@ def read_turbine_types(wio_farm, algo_dict, ws_exp_P, ws_exp_ct, verbosity):
     ----------
     wio_farm: dict
         The windio farm data
-    algo_dict: dict
-        The algorithm dictionary
+    mbook: foxes.models.ModelBook
+        The model book
     ws_exp_P: int
         The REWS exponent for power
     ws_exp_ct: int
@@ -29,9 +29,14 @@ def read_turbine_types(wio_farm, algo_dict, ws_exp_P, ws_exp_ct, verbosity):
         Mapping from turbine type key to turbine
         type name in the model book
 
-    :group: input.windio
+    :group: input.yaml.windio
 
     """
+
+    def _print(*args, level=1, **kwargs):
+        if verbosity >= level:
+            print(*args, **kwargs)
+
     if "turbine_types" not in wio_farm:
         wio_farm["turbine_types"] = {0: wio_farm["turbines"]}
 
@@ -39,29 +44,25 @@ def read_turbine_types(wio_farm, algo_dict, ws_exp_P, ws_exp_ct, verbosity):
     for k, wio_trbns in wio_farm["turbine_types"].items():
         tname = wio_trbns.pop("name")
         ttypes[k] = tname
-        if verbosity > 2:
-            print("    Reading turbine type", k)
-            print("      Name:", tname)
-            print("      Contents:", [k for k in wio_trbns.keys()])
+        _print("    Reading turbine type", k, level=3)
+        _print("      Name:", tname, level=3)
+        _print("      Contents:", [k for k in wio_trbns.keys()], level=3)
 
         # read performance:
         performance = Dict(wio_trbns["performance"], name="performance")
-        if verbosity > 2:
-            print("        Reading performance")
-            print("          Contents:", [k for k in performance.keys()])
+        _print("        Reading performance", level=3)
+        _print("          Contents:", [k for k in performance.keys()], level=3)
 
         # 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()])
+            _print("            Reading power_curve", level=3)
+            _print("              Contents:", [k for k in power_curve.keys()], level=3)
             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()])
+            _print("            Reading Ct_curve", level=3)
+            _print("              Contents:", [k for k in ct_curve.keys()], level=3)
             ct = ct_curve["Ct_values"]
             ws_ct = ct_curve["Ct_wind_speeds"]
 
@@ -75,10 +76,9 @@ def read_turbine_types(wio_farm, algo_dict, ws_exp_P, ws_exp_ct, verbosity):
                     )
                 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(
+            _print(f"            Creating model '{tname}'", level=3)
+            _print(f"              Turbine type class: PCtFomTwo", level=3)
+            mbook.turbine_types[tname] = TurbineType.new(
                 ttype_type="PCtFromTwo",
                 data_source_P=data_P,
                 data_source_ct=data_ct,
@@ -92,31 +92,27 @@ def read_turbine_types(wio_farm, algo_dict, ws_exp_P, ws_exp_ct, verbosity):
                 var_ws_P=_get_wse_var(ws_exp_P),
                 rho=1.225,
             )
-            if verbosity > 2:
-                print("               ", algo_dict["mbook"].turbine_types[tname])
+            _print("               ", mbook.turbine_types[tname], level=3)
 
         # 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()])
+            _print("            Reading Cp_curve", level=3)
+            _print("              Contents:", [k for k in cp_curve.keys()], level=3)
             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()])
+            _print("            Reading Ct_curve", level=3)
+            _print("              Contents:", [k for k in ct_curve.keys()], level=3)
             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(
+            _print(f"            Creating model '{tname}'", level=3)
+            _print(f"              Turbine type class: CpCtFromTwo", level=3)
+            mbook.turbine_types[tname] = TurbineType.new(
                 ttype_type="CpCtFromTwo",
                 data_source_cp=data_cp,
                 data_source_ct=data_ct,
@@ -127,6 +123,7 @@ def read_turbine_types(wio_farm, algo_dict, ws_exp_P, ws_exp_ct, verbosity):
                 H=wio_trbns["hub_height"],
                 D=wio_trbns["rotor_diameter"],
             )
+            _print("               ", mbook.turbine_types[tname], level=3)
 
         else:
             raise KeyError(f"Expecting either 'power_curve' or 'Cp_curve'")
@@ -134,7 +131,7 @@ def read_turbine_types(wio_farm, algo_dict, ws_exp_P, ws_exp_ct, verbosity):
     return ttypes
 
 
-def read_layout(lname, ldict, algo_dict, ttypes, verbosity=1):
+def read_layout(lname, ldict, farm, ttypes, verbosity=1):
     """
     Read wind farm layout from windio input
 
@@ -144,26 +141,20 @@ def read_layout(lname, ldict, algo_dict, ttypes, verbosity=1):
         The layout name
     ldict: dict
         The layout data
-    algo_dict: dict
-        The algorithm dictionary
+    farm: foxes.core.WindFarm
+        The wind farm
     ttypes: dict
         Mapping from turbine type key to turbine
         type name in the model book
     verbosity: int
         The verbosity level, 0=silent
 
-    Returns
-    -------
-    states: foxes.core.States
-        The states object
-
-    :group: input.windio
+    :group: input.yaml.windio
 
     """
     if verbosity > 2:
         print(f"        Reading '{lname}'")
     cdict = Dict(ldict["coordinates"], name="coordinates")
-    farm = algo_dict["farm"]
     tmap = ldict.get("turbine_types", None)
     if verbosity > 2:
         print(f"          Turbine type map:", tmap)

foxes/input/{windio → yaml/windio}/read_fields.py

@@ -1,11 +1,12 @@
 import numpy as np
 from numbers import Number
 
-import foxes.constants as FC
 import foxes.variables as FV
+import foxes.constants as FC
+
 
 """ Mapping from windio to foxes variables
-:group: input.windio
+:group: input.yaml.windio
 """
 wio2foxes = {
     "time": FC.TIME,
@@ -24,14 +25,14 @@ wio2foxes = {
 }
 
 """ Mapping from foxes to windio variables
-:group: input.windio
+:group: input.yaml.windio
 """
 foxes2wio = {d: k for k, d in wio2foxes.items()}
 
 
 def _read_nondimensional_coordinate(name, wio_data, coords):
     """read nondimensional coordinate
-    :group: input.windio
+    :group: input.yaml.windio
     """
     if isinstance(wio_data, Number):
         coords[wio2foxes[name]] = wio_data
@@ -41,7 +42,7 @@ def _read_nondimensional_coordinate(name, wio_data, coords):
 
 def _read_dimensional_coordinate(name, wio_data, coords):
     """read dimensional coordinate
-    :group: input.windio
+    :group: input.yaml.windio
     """
     if isinstance(wio_data, list):
         wio_data = np.array(wio_data)
@@ -53,7 +54,7 @@ def _read_dimensional_coordinate(name, wio_data, coords):
 
 def _read_multi_dimensional_coordinate(name, wio_data, coords):
     """Read multi dimensional coordinate
-    :group: input.windio
+    :group: input.yaml.windio
     """
     return _read_nondimensional_coordinate(
         name, wio_data, coords
@@ -62,7 +63,7 @@ def _read_multi_dimensional_coordinate(name, wio_data, coords):
 
 def _read_nondimensional_data(name, wio_data, fields, dims):
     """read nondimensional data
-    :group: input.windio
+    :group: input.yaml.windio
     """
     if isinstance(wio_data, Number):
         v = wio2foxes[name]
@@ -74,7 +75,7 @@ def _read_nondimensional_data(name, wio_data, fields, dims):
 
 def _read_dimensional_data(name, wio_data, fields, dims):
     """read dimensional data
-    :group: input.windio
+    :group: input.yaml.windio
     """
     if isinstance(wio_data, dict) and "data" in wio_data and "dims" in wio_data:
         d = wio_data["data"]
@@ -91,7 +92,7 @@ def _read_dimensional_data(name, wio_data, fields, dims):
 
 def _read_multi_dimensional_data(name, wio_data, fields, dims):
     """Read multi dimensional data
-    :group: input.windio
+    :group: input.yaml.windio
     """
     return _read_nondimensional_data(
         name, wio_data, fields, dims
@@ -129,7 +130,7 @@ def read_wind_resource_field(
     success: bool
         Flag for successful data extraction
 
-    :group: input.windio
+    :group: input.yaml.windio
 
     """
     if name in [

foxes/input/yaml/windio/read_outputs.py

@@ -0,0 +1,147 @@
+from pathlib import Path
+
+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, odict, verbosity):
+    """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=wio_outs.name + ".turbine_outputs"
+        )
+        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",
+            }
+        )
+
+        odict["StateTurbineTable"] = Dict(
+            functions=[
+                dict(
+                    name="get_dataset",
+                    variables=[vmap[v] for v in output_variables],
+                    name_map=ivmap,
+                    to_file=turbine_nc_filename,
+                    round={vw: FV.get_default_digits(vf) for vw, vf in vmap.items()},
+                    verbosity=verbosity,
+                )
+            ],
+            name=odict.name + ".StateTurbineTable",
+        )
+
+
+def _read_flow_field(wio_outs, odict, verbosity):
+    """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=wio_outs.name + ".flow_field")
+        flow_nc_filename = flow_field.pop("flow_nc_filename", "flow_field.nc")
+        output_variables = flow_field.pop("output_variables")
+        z_planes = Dict(flow_field.pop("z_planes"), name=flow_field.name + ".z_planes")
+        z_sampling = z_planes["z_sampling"]
+        xy_sampling = z_planes["xy_sampling"]
+        cases_run = Dict(
+            flow_field.pop("cases_run", {}), name=flow_field.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)
+
+        vmap = Dict(
+            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":
+            odict["SliceData"] = Dict(
+                verbosity_delta=3,
+                functions=[
+                    dict(
+                        name="get_states_data_xy",
+                        states_isel=states_isel,
+                        n_img_points=(100, 100),
+                        variables=[vmap[v] for v in output_variables],
+                        z=z,
+                        to_file=flow_nc_filename,
+                        label_map=foxes2wio,
+                        verbosity=verbosity,
+                    )
+                ],
+                name=odict.name + ".SliceData",
+            )
+        else:
+            raise NotImplementedError(
+                f"xy_sampling '{xy_sampling}' is not supported (yet)"
+            )
+
+
+def read_outputs(wio_outs, odict, verbosity=1):
+    """
+    Reads the windio outputs
+
+    Parameters
+    ----------
+    wio_outs: foxes.utils.Dict
+        The windio output data dict
+    odict: foxes.utils.Dict
+        The foxes output dictionary
+    verbosity: int
+        The verbosity level, 0=silent
+
+    Returns
+    -------
+    odir: pathlib.Path
+        The output directory
+
+    :group: input.yaml.windio
+
+    """
+    odir = wio_outs.pop("output_folder", ".")
+    if verbosity > 2:
+        print("  Reading outputs")
+        print("    Output dir:", odir)
+        print("    Contents  :", [k for k in wio_outs.keys()])
+
+    # read turbine_outputs:
+    _read_turbine_outputs(wio_outs, odict, verbosity)
+
+    # read flow field:
+    _read_flow_field(wio_outs, odict, verbosity)
+
+    return odir

foxes/input/yaml/windio/windio.py

@@ -0,0 +1,269 @@
+import argparse
+from pathlib import Path
+
+from foxes.core import WindFarm
+from foxes.models import ModelBook
+from foxes.utils import import_module, Dict
+
+from .read_fields import read_wind_resource_field
+from .get_states import get_states
+from .read_farm import read_layout, read_turbine_types
+from .read_attributes import read_attributes
+from ..dict import run_dict
+
+
+def _read_site(wio_dict, verbosity):
+    """Reads the site information"""
+
+    def _print(*args, level=1, **kwargs):
+        if verbosity >= level:
+            print(*args, **kwargs)
+
+    wio_site = Dict(wio_dict["site"], name=wio_dict.name + ".site")
+    _print("Reading site")
+    _print("  Name:", wio_site.pop("name", None))
+    _print("  Contents:", [k for k in wio_site.keys()])
+    _print("  Ignoring boundaries", level=2)
+
+    # read energy_resource:
+    energy_resource = Dict(
+        wio_site["energy_resource"], name=wio_site.name + ".energy_resource"
+    )
+    _print("  Reading energy_resource", level=2)
+    _print("    Name:", energy_resource.pop("name", None), level=2)
+    _print("    Contents:", [k for k in energy_resource.keys()], level=2)
+
+    # read wind_resource:
+    wind_resource = Dict(
+        energy_resource["wind_resource"], name=energy_resource.name + ".wind_resource"
+    )
+    _print("    Reading wind_resource", level=3)
+    _print("      Name:", wind_resource.pop("name", None), level=3)
+    _print("      Contents:", [k for k in wind_resource.keys()], level=3)
+
+    # read fields
+    coords = Dict(name="coords")
+    fields = Dict(name="fields")
+    dims = Dict(name="dims")
+    for n, d in wind_resource.items():
+        read_wind_resource_field(n, d, coords, fields, dims, verbosity)
+    if verbosity > 2:
+        print("      Coords:")
+        for c, d in coords.items():
+            print(f"        {c}: Shape {d.shape}")
+        print("      Fields:")
+        for f, d in dims.items():
+            if len(d):
+                print(f"        {f}: Dims {d}, shape {fields[f].shape}")
+            else:
+                print(f"        {f} = {fields[f]}")
+
+    return get_states(coords, fields, dims, verbosity)
+
+
+def _read_farm(wio_dict, mbook, verbosity):
+    """Reads the wind farm information"""
+    wio_farm = Dict(wio_dict["wind_farm"], name=wio_dict.name + ".wind_farm")
+    if verbosity > 1:
+        print("Reading wind farm")
+        print("  Name:", wio_farm.pop("name", None))
+        print("  Contents:", [k for k in wio_farm.keys()])
+
+    # find REWS exponents:
+    try:
+        rotor_averaging = wio_dict["attributes"]["analysis"]["rotor_averaging"]
+        ws_exp_P = rotor_averaging["wind_speed_exponent_for_power"]
+        ws_exp_ct = rotor_averaging["wind_speed_exponent_for_ct"]
+    except KeyError:
+        ws_exp_P = 1
+        ws_exp_ct = 1
+
+    # read turbine type:
+    ttypes = read_turbine_types(wio_farm, mbook, ws_exp_P, ws_exp_ct, verbosity)
+
+    # read layouts and create wind farm:
+    farm = WindFarm()
+    wfarm = wio_farm["layouts"]
+    if isinstance(wfarm, dict):
+        layouts = Dict(wfarm, name=wio_farm.name + ".layouts")
+    else:
+        layouts = {str(i): l for i, l in enumerate(wfarm)}
+        layouts = Dict(layouts, name=wio_farm.name + ".layouts")
+    if verbosity > 2:
+        print("    Reading layouts")
+        print("      Contents:", [k for k in layouts.keys()])
+    for lname, ldict in layouts.items():
+        read_layout(lname, ldict, farm, ttypes, verbosity)
+
+    return farm
+
+
+def read_windio(wio_dict, verbosity=1):
+    """
+    Translate windio data to foxes input data
+
+    Parameters
+    ----------
+    wio_dict: foxes.utils.Dict
+        The windio data
+    verbosity: int
+        The verbosity level, 0 = silent
+
+    Returns
+    -------
+    idict: foxes.utils.Dict
+        The foxes input data dictionary
+    states: foxes.core.States
+        The states object
+    farm: foxes.core.WindFarm
+        The wind farm
+    mbook: foxes.models.ModelBook
+        The model book
+
+    :group: input.yaml.windio
+
+    """
+
+    def _print(*args, level=1, **kwargs):
+        if verbosity >= level:
+            print(*args, **kwargs)
+
+    _print(f"Reading windio data")
+    _print("  Name:", wio_dict.pop("name", None))
+    _print("  Contents:", [k for k in wio_dict.keys()])
+
+    idict = Dict(
+        wind_farm=Dict(name="wio2fxs.farm"),
+        algorithm=Dict(
+            algo_type="Downwind",
+            wake_models=[],
+            name="wio2fxs.algorithm",
+            verbosity=verbosity - 3,
+        ),
+        calc_farm=Dict(run=True, name="wio2fxs.calc_farm"),
+        outputs=Dict(name="wio2fxs.outputs"),
+        name="wio2fxs",
+    )
+
+    mbook = ModelBook()
+    states = _read_site(wio_dict, verbosity)
+    farm = _read_farm(wio_dict, mbook, verbosity)
+
+    odir = read_attributes(wio_dict, idict, mbook, verbosity=verbosity)
+
+    return idict, states, farm, mbook, odir
+
+
+def foxes_windio():
+    """
+    Command line tool for running foxes from windio yaml file input.
+
+    Examples
+    --------
+    >>> foxes_windio input.yaml
+
+    :group: input.yaml.windio
+
+    """
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "yml_file",
+        help="The windio yaml file",
+    )
+    parser.add_argument("-o", "--out_dir", help="The output directory", default=None)
+    parser.add_argument("-r", "--rotor", help="The rotor model", default="centre")
+    parser.add_argument(
+        "-p", "--pwakes", help="The partial wakes models", default="centre", nargs="+"
+    )
+    parser.add_argument(
+        "-w",
+        "--wakes",
+        help="The wake models",
+        default=["Jensen_linear_k007"],
+        nargs="+",
+    )
+    parser.add_argument("-f", "--frame", help="The wake frame", default="rotor_wd")
+    parser.add_argument("-e", "--engine", help="The engine", default=None)
+    parser.add_argument(
+        "-n", "--n_procs", help="The number of processes", default=None, type=int
+    )
+    parser.add_argument(
+        "-c",
+        "--chunksize_states",
+        help="The chunk size for states",
+        default=None,
+        type=int,
+    )
+    parser.add_argument(
+        "-C",
+        "--chunksize_points",
+        help="The chunk size for points",
+        default=5000,
+        type=int,
+    )
+    parser.add_argument(
+        "-it", "--iterative", help="Use iterative algorithm", action="store_true"
+    )
+    parser.add_argument(
+        "-nf", "--nofig", help="Do not show figures", action="store_true"
+    )
+    parser.add_argument(
+        "-v",
+        "--verbosity",
+        help="The verbosity level, 0 = silent",
+        type=int,
+        default=None,
+    )
+    args = parser.parse_args()
+
+    v = 1 if args.verbosity is None else args.verbosity
+
+    def _print(*args, level=1, **kwargs):
+        if v >= level:
+            print(*args, **kwargs)
+
+    if (
+        args.engine is not None
+        or args.n_procs is not None
+        or args.chunksize_states is not None
+        or args.chunksize_points is not None
+    ):
+        epars = dict(
+            engine_type=args.engine,
+            n_procs=args.n_procs,
+            chunk_size_states=args.chunksize_states,
+            chunk_size_points=args.chunksize_points,
+            verbosity=v,
+        )
+    else:
+        epars = None
+
+    wio_file = Path(args.yml_file)
+    _print(f"Reading windio file {wio_file}")
+    yml_utils = import_module(
+        "windIO.utils.yml_utils",
+        hint="pip install git+https://github.com/kilojoules/windIO@master#egg=windIO",
+    )
+
+    wio = Dict(yml_utils.load_yaml(wio_file), name="windio")
+    idict, states, farm, mbook, odir = read_windio(wio, verbosity=v)
+
+    if args.out_dir is not None:
+        odir = args.odir
+
+    run_dict(
+        idict,
+        farm=farm,
+        states=states,
+        mbook=mbook,
+        rotor_model=args.rotor,
+        partial_wakes=args.pwakes,
+        wake_models=args.wakes,
+        wake_frame=args.frame,
+        engine_pars=epars,
+        iterative=args.iterative,
+        work_dir=wio_file.parent,
+        out_dir=odir,
+        verbosity=args.verbosity,
+    )