foxes 1.2.2__py3-none-any.whl → 1.2.4__py3-none-any.whl

foxes/input/yaml/windio/read_outputs.py

@@ -1,4 +1,4 @@
-from pathlib import Path
+import numpy as np
 
 from foxes.utils import Dict
 import foxes.variables as FV
@@ -7,15 +7,15 @@ import foxes.constants as FC
 from .read_fields import foxes2wio
 
 
-def _read_turbine_outputs(wio_outs, odict, verbosity):
+def _read_turbine_outputs(wio_outs, olist, algo, states_isel, verbosity):
     """Reads the turbine outputs request"""
-    if "turbine_outputs" in wio_outs and wio_outs["turbine_outputs"].get(
+    if "turbine_outputs" in wio_outs and wio_outs["turbine_outputs"].get_item(
         "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.pop_item(
             "turbine_nc_filename", "turbine_outputs.nc"
         )
         output_variables = turbine_outputs["output_variables"]
@@ -36,36 +36,44 @@ def _read_turbine_outputs(wio_outs, odict, verbosity):
             }
         )
 
-        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",
+        isel = None
+        if states_isel is not None and len(states_isel):
+            isel = {"time": states_isel}
+
+        olist.append(
+            Dict(
+                output_type="StateTurbineTable",
+                functions=[
+                    dict(
+                        function="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()
+                        },
+                        isel=isel,
+                        verbosity=verbosity,
+                    )
+                ],
+                name=f"outputs.output{len(olist)}.StateTurbineTable",
+            )
         )
 
 
-def _read_flow_field(wio_outs, odict, verbosity):
+def _read_flow_field(wio_outs, olist, algo, states_isel, verbosity):
     """Reads the flow field request"""
-    if "flow_field" in wio_outs and wio_outs["flow_field"].get("report", True):
+    if "flow_field" in wio_outs and wio_outs["flow_field"].get_item("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")
+        flow_nc_filename = flow_field.pop_item("flow_nc_filename", "flow_field.nc")
+        output_variables = flow_field.pop_item("output_variables")
+
+        z_planes = Dict(
+            flow_field.pop_item("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)
@@ -79,39 +87,76 @@ def _read_flow_field(wio_outs, odict, verbosity):
             wind_direction=FV.WD,
         )
 
-        if z_sampling in ["hub_height", "default"]:
-            z = None
+        z_list = []
+        if z_sampling == "plane_list":
+            z_list = z_planes.pop_item("z_list")
+        elif z_sampling == "hub_heights":
+            z_list = np.unique(algo.farm.get_hub_heights(algo))
+        elif z_sampling == "grid":
+            zb = z_planes.pop_item("z_bounds")
+            assert len(zb) == 2, f"Expecting two entries for z_bounds, got {zb}"
+            zn = z_planes.pop_item("z_number")
+            z_list = np.linspace(zb[0], zb[1], zn)
         elif isinstance(z_sampling, (int, float)):
-            z = z_sampling
+            z_list = np.atleast_1d(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."
+                f"z_sampling '{z_sampling}' is not supported. Choices: plane_list, hub_heights, grid."
             )
-
-        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",
+        z_list = np.asarray(z_list)
+        if verbosity > 2:
+            print("          z_list        :", z_list)
+
+        if xy_sampling == "grid":
+            xb = z_planes.pop_item("x_bounds")
+            assert len(xb) == 2, f"Expecting two entries for x_bounds, got {xb}"
+            yb = z_planes.pop_item("y_bounds")
+            assert len(yb) == 2, f"Expecting two entries for y_bounds, got {yb}"
+            dx = z_planes.pop_item("dx")
+            dy = z_planes.pop_item("dy")
+            nx = max(int((xb[1] - xb[0]) / dx), 1) + 1
+            if (xb[1] - xb[0]) / (nx - 1) > dx:
+                nx += 1
+            ny = max(int((yb[1] - yb[0]) / dy), 1) + 1
+            if (yb[1] - yb[0]) / (ny - 1) > dy:
+                ny += 1
+            z_list = np.asarray(z_list)
+            if verbosity > 2:
+                print("          x_bounds      :", xb)
+                print("          y_bounds      :", yb)
+                print("          nx, ny        :", (nx, ny))
+                print("          true dx       :", (xb[1] - xb[0]) / (nx - 1))
+                print("          true dy       :", (yb[1] - yb[0]) / (ny - 1))
+            olist.append(
+                Dict(
+                    output_type="SlicesData",
+                    verbosity_delta=3,
+                    functions=[
+                        dict(
+                            function="get_states_data_xy",
+                            z_list=z_list,
+                            states_isel=states_isel,
+                            xmin=xb[0],
+                            xmax=xb[1],
+                            ymin=yb[0],
+                            ymax=yb[1],
+                            n_img_points=(nx, ny),
+                            variables=[vmap[v] for v in output_variables],
+                            to_file=flow_nc_filename,
+                            label_map=foxes2wio,
+                            verbosity=verbosity,
+                        )
+                    ],
+                    name=f"outputs.output{len(olist)}.SliceData",
+                )
             )
         else:
             raise NotImplementedError(
-                f"xy_sampling '{xy_sampling}' is not supported (yet)"
+                f"xy_sampling '{xy_sampling}' is not supported. Choices: 'grid'."
             )
 
 
-def read_outputs(wio_outs, odict, verbosity=1):
+def read_outputs(wio_outs, idict, algo, verbosity=1):
     """
     Reads the windio outputs
 
@@ -119,8 +164,10 @@ def read_outputs(wio_outs, odict, verbosity=1):
     ----------
     wio_outs: foxes.utils.Dict
         The windio output data dict
-    odict: foxes.utils.Dict
-        The foxes output dictionary
+    idict: foxes.utils.Dict
+        The foxes input data dictionary
+    algo: foxes.core.Algorithm
+        The algorithm
     verbosity: int
         The verbosity level, 0=silent
 
@@ -132,16 +179,29 @@ def read_outputs(wio_outs, odict, verbosity=1):
     :group: input.yaml.windio
 
     """
-    odir = wio_outs.pop("output_folder", ".")
+    odir = wio_outs.pop_item("output_folder", ".")
+    olist = []
     if verbosity > 2:
-        print("  Reading outputs")
+        print("  Reading model_outputs_specification")
         print("    Output dir:", odir)
         print("    Contents  :", [k for k in wio_outs.keys()])
 
+    # read subset:
+    cases_run = Dict(
+        wio_outs.pop_item("cases_run", {}), name=wio_outs.name + ".cases_run"
+    )
+    if cases_run.pop_item("all_occurences"):
+        states_isel = None
+    else:
+        states_isel = cases_run.pop_item("subset")
+
     # read turbine_outputs:
-    _read_turbine_outputs(wio_outs, odict, verbosity)
+    _read_turbine_outputs(wio_outs, olist, algo, states_isel, verbosity)
 
     # read flow field:
-    _read_flow_field(wio_outs, odict, verbosity)
+    _read_flow_field(wio_outs, olist, algo, states_isel, verbosity)
+
+    if len(olist):
+        idict["outputs"] = olist
 
     return odir

foxes/input/yaml/windio/{get_states.py → read_site.py}

@@ -4,9 +4,12 @@ from xarray import Dataset
 from numbers import Number
 
 from foxes.core import States
+from foxes.utils import Dict
 import foxes.variables as FV
 import foxes.constants as FC
 
+from .read_fields import read_wind_resource_field
+
 
 def _get_profiles(coords, fields, dims, ovars, fixval, verbosity):
     """Read ABL profiles information
@@ -203,3 +206,69 @@ def get_states(coords, fields, dims, verbosity=1):
         raise ValueError(
             f"Failed to create states for coords {list(coords.keys())} and fields {list(fields.keys())} with dims {dims}"
         )
+
+
+def read_site(wio_dict, verbosity=1):
+    """
+    Reads the site information
+
+    Parameters
+    ----------
+    wio_dict: foxes.utils.Dict
+        The windio data
+    verbosity: int
+        The verbosity level, 0=silent
+
+    Returns
+    -------
+    states: foxes.core.States
+        The states object
+
+    :group: input.yaml.windio
+
+    """
+
+    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_item("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_item("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_item("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)

foxes/input/yaml/windio/windio.py

@@ -1,103 +1,17 @@
 import argparse
 from pathlib import Path
 
-from foxes.core import WindFarm
+from foxes.core import Algorithm
 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_site import read_site
+from .read_farm import read_farm
 from .read_attributes import read_attributes
+from .read_outputs import read_outputs
 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
@@ -111,14 +25,12 @@ def read_windio(wio_dict, verbosity=1):
 
     Returns
     -------
-    idict: foxes.utils.Dict
+    idict: foxes.utils.Dict or 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
+    algo: foxes.core.Algorithm
+        The algorithm
+    odir: pathlib.Path
+        The output directory
 
     :group: input.yaml.windio
 
@@ -128,8 +40,11 @@ def read_windio(wio_dict, verbosity=1):
         if verbosity >= level:
             print(*args, **kwargs)
 
+    if not isinstance(wio_dict, Dict):
+        wio_dict = Dict(wio_dict, name="windio")
+
     _print(f"Reading windio data")
-    _print("  Name:", wio_dict.pop("name", None))
+    _print("  Name:", wio_dict.pop_item("name", None))
     _print("  Contents:", [k for k in wio_dict.keys()])
 
     idict = Dict(
@@ -141,17 +56,28 @@ def read_windio(wio_dict, verbosity=1):
             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)
+    states = read_site(wio_dict, verbosity)
+    farm = read_farm(wio_dict, mbook, verbosity)
+
+    wio_attrs = Dict(wio_dict["attributes"], name=wio_dict.name + ".attributes")
+    read_attributes(wio_attrs, idict, mbook, verbosity=verbosity)
 
-    odir = read_attributes(wio_dict, idict, mbook, verbosity=verbosity)
+    algo = Algorithm.new(
+        farm=farm, states=states, mbook=mbook, **idict.pop_item("algorithm")
+    )
+
+    odir = None
+    if "model_outputs_specification" in wio_attrs:
+        outputs = Dict(
+            wio_attrs["model_outputs_specification"], name=wio_attrs.name + ".outputs"
+        )
+        odir = read_outputs(outputs, idict, algo, verbosity=verbosity)
 
-    return idict, states, farm, mbook, odir
+    return idict, algo, odir
 
 
 def foxes_windio():
@@ -171,7 +97,7 @@ def foxes_windio():
         "yml_file",
         help="The windio yaml file",
     )
-    parser.add_argument("-o", "--out_dir", help="The output directory", default=None)
+    parser.add_argument("-o", "--output_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="+"
@@ -213,15 +139,13 @@ def foxes_windio():
         "--verbosity",
         help="The verbosity level, 0 = silent",
         type=int,
-        default=None,
+        default=1,
     )
     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)
+    def _print(*ags, level=1, **kwargs):
+        if args.verbosity >= level:
+            print(*ags, **kwargs)
 
     if (
         args.engine is not None
@@ -234,7 +158,7 @@ def foxes_windio():
             n_procs=args.n_procs,
             chunk_size_states=args.chunksize_states,
             chunk_size_points=args.chunksize_points,
-            verbosity=v,
+            verbosity=args.verbosity,
         )
     else:
         epars = None
@@ -243,27 +167,26 @@ def foxes_windio():
     _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",
+        pip_hint="pip install git+https://github.com/EUFLOW/windIO@master#egg=windIO",
+        conda_hint="",
     )
 
     wio = Dict(yml_utils.load_yaml(wio_file), name="windio")
-    idict, states, farm, mbook, odir = read_windio(wio, verbosity=v)
+    idict, algo, odir = read_windio(wio, verbosity=args.verbosity)
 
-    if args.out_dir is not None:
+    if args.output_dir is not None:
         odir = args.odir
 
     run_dict(
         idict,
-        farm=farm,
-        states=states,
-        mbook=mbook,
+        algo=algo,
         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,
+        input_dir=wio_file.parent,
+        output_dir=odir,
         verbosity=args.verbosity,
     )

foxes/input/yaml/yaml.py

@@ -23,7 +23,7 @@ def foxes_yaml():
         "yml_file",
         help="The input yaml file",
     )
-    parser.add_argument("-o", "--out_dir", help="The output directory", default=".")
+    parser.add_argument("-o", "--output_dir", help="The output directory", default=None)
     parser.add_argument("-r", "--rotor", help="The rotor model", default=None)
     parser.add_argument(
         "-p", "--pwakes", help="The partial wakes models", default=None, nargs="+"
@@ -97,7 +97,7 @@ def foxes_yaml():
         wake_frame=args.frame,
         engine_pars=epars,
         iterative=args.iterative,
-        work_dir=fpath.parent,
-        out_dir=args.out_dir,
+        input_dir=fpath.parent,
+        output_dir=args.output_dir,
         verbosity=args.verbosity,
     )

foxes/models/model_book.py

@@ -83,6 +83,7 @@ class ModelBook:
         """
         self.point_models = FDict(name="point_models")
         self.point_models["tke2ti"] = fm.point_models.TKE2TI()
+        self.point_models["ustar2ti"] = fm.point_models.Ustar2TI()
 
         self.rotor_models = FDict(name="rotor_models")
         self.rotor_models["centre"] = fm.rotor_models.CentreRotor()

foxes/models/point_models/__init__.py

@@ -5,3 +5,4 @@ Point models.
 from .wake_deltas import WakeDeltas
 from .set_uniform_data import SetUniformData
 from .tke2ti import TKE2TI
+from .ustar2ti import Ustar2TI