foxes 0.7.2__py3-none-any.whl → 0.7.3__py3-none-any.whl

foxes/input/windio/read_fields.py

@@ -0,0 +1,164 @@
+import numpy as np
+from numbers import Number
+
+import foxes.constants as FC
+import foxes.variables as FV
+
+""" Mapping from windio to foxes variables
+:group: input.windio
+"""
+wio2foxes = {
+    "time": FC.TIME,
+    "x": FV.X,
+    "y": FV.Y,
+    "height": FV.H,
+    "wind_turbine": FC.TURBINE,
+    "wind_direction": FV.WD,
+    "wind_speed": FV.WS,
+    "probability": FV.WEIGHT,
+    "sector_probability": "sector_probability",
+    "turbulence_intensity": FV.TI,
+    "LMO": FV.MOL,
+    "z0": FV.Z0,
+}
+
+""" Mapping from foxes to windio variables
+:group: input.windio
+"""
+foxes2wio = {d: k for k, d in wio2foxes.items()}
+
+
+def _read_nondimensional_coordinate(name, wio_data, coords, fields, dims):
+    """read nondimensional coordinate
+    :group: input.windio
+    """
+    if isinstance(wio_data, Number):
+        coords[wio2foxes[name]] = wio_data
+        return True
+    return False
+
+
+def _read_dimensional_coordinate(name, wio_data, coords, fields, dims):
+    """read dimensional coordinate
+    :group: input.windio
+    """
+    if isinstance(wio_data, list):
+        wio_data = np.array(wio_data)
+    if isinstance(wio_data, np.ndarray) and len(wio_data.shape) == 1:
+        coords[wio2foxes[name]] = wio_data
+        return True
+    return False
+
+
+def _read_multi_dimensional_coordinate(*args, **kwargs):
+    """Read multi dimensional coordinate
+    :group: input.windio
+    """
+    return _read_nondimensional_coordinate(
+        *args, **kwargs
+    ) or _read_dimensional_coordinate(*args, **kwargs)
+
+
+def _read_nondimensional_data(name, wio_data, coords, fields, dims):
+    """read nondimensional data
+    :group: input.windio
+    """
+    if isinstance(wio_data, Number):
+        v = wio2foxes[name]
+        fields[v] = wio_data
+        dims[v] = []
+        return True
+    return False
+
+
+def _read_dimensional_data(name, wio_data, coords, fields, dims):
+    """read dimensional data
+    :group: input.windio
+    """
+    if isinstance(wio_data, dict) and "data" in wio_data and "dims" in wio_data:
+        d = wio_data["data"]
+        v = wio2foxes[name]
+        fields[v] = d if isinstance(d, np.ndarray) else np.array(d)
+        dims[v] = tuple([wio2foxes[c] for c in wio_data["dims"]])
+        if len(dims[v]) != len(fields[v].shape):
+            raise ValueError(
+                f"Field '{name}': Dimensions {dims[v]} do not match shape {fields[v].shape}"
+            )
+        return True
+    return False
+
+
+def _read_multi_dimensional_data(*args, **kwargs):
+    """Read multi dimensional data
+    :group: input.windio
+    """
+    return _read_nondimensional_data(*args, **kwargs) or _read_dimensional_data(
+        *args, **kwargs
+    )
+
+
+def read_wind_resource_field(name, wio_data, coords, fields, dims):
+    """
+    Reads wind resource data into fields and dims
+
+    Parameters
+    ----------
+    name: str
+        The windio variable name
+    wio_data: object
+        The windio data
+    coords: dict
+        The coordinates dict, filled on the fly
+    fields: dict
+        The fields dict, filled on the fly
+    dims: dict
+        The dimensions dict, filled on the fly
+
+    Returns
+    -------
+    success: bool
+        Flag for successful data extraction
+
+    :group: input.windio
+
+    """
+    if name in [
+        "weibull_a",
+        "weibull_k",
+        "potential_temperature",
+        "friction_velocity",
+        "k",
+        "epsilon",
+    ]:
+        print(f"Ignoring variable '{name}'")
+        return False
+
+    elif name in ["time", "wind_turbine"] and _read_multi_dimensional_coordinate(
+        name, wio_data, coords, fields, dims
+    ):
+        return True
+
+    elif name in [
+        "wind_direction",
+        "wind_speed",
+        "x",
+        "y",
+        "height",
+    ] and (
+        _read_multi_dimensional_coordinate(name, wio_data, coords, fields, dims)
+        or _read_multi_dimensional_data(name, wio_data, coords, fields, dims)
+    ):
+        return True
+
+    elif name in [
+        "probability",
+        "sector_probability",
+        "turbulence_intensity",
+        "LMO",
+        "z0",
+        "k",
+    ] and _read_multi_dimensional_data(name, wio_data, coords, fields, dims):
+        return True
+
+    else:
+        raise NotImplementedError(f"No reading method implemented for field '{name}'")

foxes/input/windio/runner.py

@@ -0,0 +1,105 @@
+from foxes.core import Algorithm
+from foxes.output import Output
+
+
+class WindioRunner:
+    """
+    Runner for windio input
+
+    Attributes
+    ----------
+    algo: foxes.core.Algorithm
+        The algorithm object
+    output_dicts: list of dict
+        The output dictionaries
+    farm_results: xarray.Dataset
+        The farm results
+    output_results: list
+        The output results
+    verbosity: int
+        The verbosity level, 0 = silent
+
+    :group: input.windio
+
+    """
+
+    def __init__(self, algo_dict, output_dicts=[], verbosity=1):
+        """
+        Conbstructor
+
+        Parameters
+        ----------
+        algo_dict: dict
+            The algorithm dictionary
+        output_dicts: list of dict
+            The output dictionaries
+        verbosity: int
+            The verbosity level, 0 = silent
+
+        """
+        self.algo = algo_dict
+        self.output_dicts = output_dicts
+        self.verbosity = verbosity
+        self.farm_results = None
+        self.output_results = None
+
+        self.__initialized = False
+
+    def print(self, *args, **kwargs):
+        """Print based on verbosity"""
+        if self.verbosity > 0:
+            print(*args, **kwargs)
+
+    def initialize(self):
+        """Initializes the runner"""
+        if isinstance(self.algo, dict):
+            self.print(f"Creating algorithm '{self.algo['algo_type']}'")
+            self.algo = Algorithm.new(**self.algo)
+        if not self.algo.initialized:
+            self.algo.initialize()
+        self.__initialized = True
+
+    @property
+    def initialized(self):
+        """Flag for initialization"""
+        return self.__initialized
+
+    def run_farm_calc(self):
+        """Runs the farm calculation"""
+        if not self.__initialized:
+            self.initialize()
+        print("Running farm_calc")
+        self.farm_results = self.algo.calc_farm()
+
+    def run_outputs(self):
+        """Runs the output calculation"""
+        self.output_results = []
+        for odict in self.output_dicts:
+            self.print("Running output:", odict["output_type"])
+            run_fname = odict.pop("run_func")
+            run_args = odict.pop("run_args", ())
+            run_kwargs = odict.pop("run_kwargs", {})
+            o = Output.new(**odict)
+            f = getattr(o, run_fname)
+            self.output_results.append(f(*run_args, **run_kwargs))
+
+    def run(self):
+        """Runs all calculations"""
+        self.run_farm_calc()
+        self.run_outputs()
+
+    def finalize(self):
+        """Initializes the runner"""
+        if self.algo.initialized:
+            self.algo.finalize(clear_mem=True)
+        self.algo = None
+        self.farm_results = None
+        self.output_results = None
+        self.__initialized = False
+
+    def __enter__(self):
+        self.initialize()
+        return self
+
+    def __exit__(self, *args):
+        self.finalize()

foxes/input/windio/windio.py

@@ -1,285 +1,167 @@
 import numpy as np
 import pandas as pd
+from pathlib import Path
 
-from foxes.core import WindFarm, Algorithm
+from foxes.core import WindFarm
 from foxes.models import ModelBook
-from foxes.input.states import StatesTable
-from foxes.input.farm_layout import add_from_df
-from foxes.models.turbine_types import CpCtFromTwo
-from foxes.utils import import_module
-import foxes.constants as FC
-import foxes.variables as FV
-
-
-def read_resource(res, fixed_vars={}, **kwargs):
+from foxes.utils import import_module, Dict
+from foxes.data import StaticData, WINDIO
+
+from .read_fields import read_wind_resource_field
+from .get_states import get_states
+from .read_farm import read_layout, read_turbine_type
+from .read_attributes import read_attributes
+from .runner import WindioRunner
+
+
+def _read_site(wio, algo_dict, verbosity):
+    """Reads the site information"""
+    wio_site = Dict(wio["site"], name="site")
+    if verbosity > 0:
+        print("Reading site")
+        print("  Name:", wio_site.pop("name", None))
+        print("  Contents:", [k for k in wio_site.keys()])
+
+    # ignore boundaries:
+    if verbosity > 1:
+        print("  Ignoring boundaries")
+
+    # read energy_resource:
+    energy_resource = Dict(wio_site["energy_resource"], name="energy_resource")
+    if verbosity > 1:
+        print("  Reading energy_resource")
+        print("    Name:", energy_resource.pop("name", None))
+        print("    Contents:", [k for k in energy_resource.keys()])
+
+    # read wind_resource:
+    wind_resource = Dict(energy_resource["wind_resource"], name="wind_resource")
+    if verbosity > 1:
+        print("    Reading wind_resource")
+        print("      Name:", wind_resource.pop("name", None))
+        print("      Contents:", [k for k in wind_resource.keys()])
+
+    # read fields
+    coords = Dict(name="coords")
+    fields = Dict(name="fields")
+    dims = Dict(name="dims")
+    for n, d in wind_resource.items():
+        if verbosity > 1:
+            print("        Reading", n)
+        read_wind_resource_field(n, d, coords, fields, dims)
+    if verbosity > 1:
+        print("      Coords:")
+        for c, d in coords.items():
+            print(f"        {c}: Shape {d.shape}")
+        print("      Fields:")
+        for f, d in dims.items():
+            print(f"        {f}: Dims {d}, shape {fields[f].shape}")
+
+    algo_dict["states"] = get_states(coords, fields, dims, verbosity)
+
+
+def _read_farm(wio, algo_dict, verbosity):
+    """Reads the wind farm information"""
+    wio_farm = Dict(wio["wind_farm"], name="wind_farm")
+    if verbosity > 0:
+        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["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:
+    turbines = Dict(wio_farm["turbines"], name="turbines")
+    ttype = read_turbine_type(turbines, algo_dict, ws_exp_P, ws_exp_ct, verbosity)
+
+    # read layouts:
+    layouts = Dict(wio_farm["layouts"], name="layouts")
+    if verbosity > 1:
+        print("    Reading layouts")
+        print("      Contents:", [k for k in layouts.keys()])
+    for lname, ldict in layouts.items():
+        read_layout(lname, ldict, algo_dict, ttype, verbosity)
+
+
+def read_windio(windio_yaml, verbosity=1):
     """
-    Reads a WindIO energy resource
+    Reads a complete WindIO case.
 
-    Parameters
-    ----------
-    res_yaml: str
-        Path to the yaml file
-    fixed_vars: dict
-        Additional fixes variables that do
-        not occur in the yaml
-    kwargs: dict, optional
-        Additional arguments for StatesTable
-
-    Returns
-    -------
-    states: foxes.states.StatesTable
-        The uniform states
-
-    """
-    wres = res["wind_resource"]
-
-    wd = np.array(wres["wind_direction"], dtype=FC.DTYPE)
-    ws = np.array(wres["wind_speed"], dtype=FC.DTYPE)
-    n_wd = len(wd)
-    n_ws = len(ws)
-    n = n_wd * n_ws
-
-    data = np.zeros((n_wd, n_ws, 2), dtype=FC.DTYPE)
-    data[:, :, 0] = wd[:, None]
-    data[:, :, 1] = ws[None, :]
-    names = ["wind_direction", "wind_speed"]
-    sec_prob = None
-
-    def _to_data(v, d, dims):
-        nonlocal data, names, sec_prob
-        hdata = np.zeros((n_wd, n_ws, 1), dtype=FC.DTYPE)
-        if len(dims) == 0:
-            hdata[:, :, 0] = FC.DTYPE(d)
-        elif len(dims) == 1:
-            if dims[0] == "wind_direction":
-                hdata[:, :, 0] = np.array(d, dtype=FC.DTYPE)[:, None]
-            elif dims[0] == "wind_speed":
-                hdata[:, :, 0] = np.array(d, dtype=FC.DTYPE)[None, :]
-            else:
-                raise ValueError(f"Unknown dimension '{dims[0]}' for data '{v}'")
-        elif len(dims) == 2:
-            if dims[0] == "wind_direction" and dims[1] == "wind_speed":
-                hdata[:, :, 0] = np.array(d, dtype=FC.DTYPE)
-            elif dims[1] == "wind_direction" and dims[0] == "wind_speed":
-                hdata[:, :, 0] = np.swapaxes(np.array(d, dtype=FC.DTYPE), 0, 1)
-            else:
-                raise ValueError(f"Cannot handle dims = {dims} for data '{v}'")
-        else:
-            raise ValueError(
-                f"Can not accept more than two dimensions, got {dims} for data '{v}'"
-            )
-        if v == "sector_probability":
-            sec_prob = hdata[:, :, 0].copy()
-        else:
-            data = np.append(data, hdata, axis=2)
-            names.append(v)
-
-    vmap = {
-        "wind_direction": FV.WD,
-        "wind_speed": FV.WS,
-        "turbulence_intensity": FV.TI,
-        "air_density": FV.RHO,
-        "probability": FV.WEIGHT,
-    }
-
-    for v, d in wres.items():
-        if (v == "sector_probability" or v in vmap) and isinstance(d, dict):
-            _to_data(v, d["data"], d["dims"])
-    if sec_prob is not None and "probability" in names:
-        data[:, :, names.index("probability")] *= sec_prob
-
-    n_vars = len(names)
-    data = data.reshape(n, n_vars)
-
-    data = pd.DataFrame(index=range(n), data=data, columns=names)
-    data.index.name = "state"
-    data.rename(columns=vmap, inplace=True)
-
-    ovars = {v: v for v in data.columns if v != FV.WEIGHT}
-    ovars.update({k: v for k, v in fixed_vars.items() if k not in data.columns})
-
-    return StatesTable(data, output_vars=ovars, fixed_vars=fixed_vars, **kwargs)
-
-
-def read_site(site, **kwargs):
-    """
-    Reads a WindIO site
+    This is the main entry point for windio case
+    calculations.
 
     Parameters
     ----------
-    site_yaml: str
-        Path to the yaml file
-    kwargs: dict, optional
-        Additional arguments for read_resource
+    windio_yaml: str
+        Path to the windio yaml file
+    verbosity: int
+        The verbosity level, 0 = silent
 
     Returns
     -------
-    states: foxes.states.States
-        The states object
-
-    """
-    res_yaml = site["energy_resource"]
-    states = read_resource(res_yaml, **kwargs)
-
-    return states
+    runner: foxes.input.windio.WindioRunner
+        The windio runner, call its run function
+        for the complete exection
 
+    :group: input.windio
 
-def read_farm(fdict, mbook=None, layout=-1, turbine_models=[], **kwargs):
     """
-    Reads a WindIO wind farm
 
-    Parameters
-    ----------
-    farm_yaml: str
-        Path to the yaml file
-    mbook: foxes.ModelBook, optional
-        The model book to start from
-    layout: str or int
-        The layout choice
-    turbine_models: list of str
-        Additional turbine models
-    kwargs: dict, optional
-        Additional parameters for add_from_df()
+    wio_file = Path(windio_yaml)
+    if not wio_file.is_file():
+        wio_file = StaticData().get_file_path(WINDIO, wio_file, check_raw=False)
 
-    Returns
-    -------
-    mbook: foxes.ModelBook
-        The model book
-    farm: foxes.WindFarm
-        The wind farm
+    if verbosity > 0:
+        print(f"Reading windio file {wio_file}")
 
-    """
-    mbook = ModelBook() if mbook is None else mbook
-
-    if isinstance(layout, str):
-        layout = fdict["layouts"][layout]
-    else:
-        lname = list(fdict["layouts"].keys())[layout]
-        layout = fdict["layouts"][lname]
-
-    x = np.array(layout["coordinates"]["x"], dtype=FC.DTYPE)
-    y = np.array(layout["coordinates"]["y"], dtype=FC.DTYPE)
-    N = len(x)
-    ldata = pd.DataFrame(index=range(N))
-    ldata.index.name = "index"
-    ldata["x"] = x
-    ldata["y"] = y
-
-    tdict = fdict["turbines"]
-    pdict = tdict["performance"]
-
-    ct_ws = np.array(pdict["Ct_curve"]["Ct_wind_speeds"], dtype=FC.DTYPE)
-    ct_data = pd.DataFrame(index=range(len(ct_ws)))
-    ct_data["ws"] = ct_ws
-    ct_data["ct"] = np.array(pdict["Ct_curve"]["Ct_values"], dtype=FC.DTYPE)
-
-    cp_ws = np.array(pdict["Cp_curve"]["Cp_wind_speeds"], dtype=FC.DTYPE)
-    cp_data = pd.DataFrame(index=range(len(cp_ws)))
-    cp_data["ws"] = cp_ws
-    cp_data["cp"] = np.array(pdict["Cp_curve"]["Cp_values"], dtype=FC.DTYPE)
-
-    D = float(tdict["rotor_diameter"])
-    H = float(tdict["hub_height"])
-
-    mbook.turbine_types["windio_turbine"] = CpCtFromTwo(
-        cp_data, ct_data, col_ws_cp_file="ws", col_cp="cp", D=D, H=H
+    yml_utils = import_module("windIO.utils.yml_utils", hint="pip install windio")
+    wio = yml_utils.load_yaml(wio_file)
+
+    if verbosity > 0:
+        print("  Name:", wio.pop("name", None))
+        print("  Contents:", [k for k in wio.keys()])
+
+    algo_dict = Dict(
+        algo_type="Downwind",
+        mbook=ModelBook(),
+        farm=WindFarm(),
+        wake_models=[],
+        verbosity=verbosity - 1,
     )
 
-    models = ["windio_turbine"] + turbine_models
-    farm = WindFarm(name=fdict["name"])
-
-    add_from_df(farm, ldata, col_x="x", col_y="y", turbine_models=models, **kwargs)
-
-    return mbook, farm
-
-
-def read_anlyses(
-    analyses, mbook, farm, states, keymap={}, algo_type="Downwind", **algo_pars
-):
-    """
-    Reads a WindIO wind farm
-
-    Parameters
-    ----------
-    analyses: dict
-        The analyses sub-dict of the case
-    mbook: foxes.ModelBook
-        The model book
-    farm: foxes.WindFarm
-        The wind farm
-    states: foxes.states.States
-        The states object
-    keymap: dict
-        Translation from windio to foxes keywords
-    algo_type: str
-        The default algorithm class name
-    algo_pars: dict, optional
-        Additional parameters for the algorithm
-        constructor
-
-    Returns
-    -------
-    algo: foxes.core.Algorithm
-        The algorithm
-
-    """
-    wmodel = analyses["wake_model"]["name"]
-    wmodels = [keymap.get(wmodel, wmodel)]
-
-    return Algorithm.new(
-        algo_type, mbook, farm, states, wake_models=wmodels, **algo_pars
+    _read_site(wio, algo_dict, verbosity)
+    _read_farm(wio, algo_dict, verbosity)
+    out_dicts = read_attributes(
+        wio,
+        algo_dict,
+        verbosity,
     )
 
+    if verbosity > 0:
+        print("Creating windio runner")
+    runner = WindioRunner(algo_dict, output_dicts=out_dicts, verbosity=verbosity)
 
-def read_case(case_yaml, site_pars={}, farm_pars={}, ana_pars={}):
-    """
-    Reads a WindIO case
-
-    Parameters
-    ----------
-    case_yaml: str
-        Path to the yaml file
-    site_pars: dict
-        Additional arguments for read_site
-    farm_pars: dict
-        Additional arguments for read_farm
-    ana_pars: dict
-        Additional arguments for read_analyses
-
-    Returns
-    -------
-    mbook: foxes.ModelBook
-        The model book
-    farm: foxes.WindFarm
-        The wind farm
-    states: foxes.states.States
-        The states object
-    algo: foxes.core.Algorithm
-        The algorithm
-
-    :group: input.windio
-
-    """
-    yml_utils = import_module("windIO.utils.yml_utils", hint="pip install windio")
-    case = yml_utils.load_yaml(case_yaml)
-
-    site_yaml = case["site"]
-    states = read_site(site_yaml, **site_pars)
-
-    farm_yaml = case["wind_farm"]
-    mbook, farm = read_farm(farm_yaml, **farm_pars)
-
-    attr_dict = case["attributes"]
-    algo = read_anlyses(attr_dict["analyses"], mbook, farm, states, **ana_pars)
-
-    return mbook, farm, states, algo
+    return runner
 
 
 if __name__ == "__main__":
     import argparse
 
     parser = argparse.ArgumentParser()
-    parser.add_argument("case_yaml", help="The case yaml file")
+    parser.add_argument(
+        "-f",
+        "--file",
+        help="The windio yaml file",
+        default="windio_5turbines_timeseries.yaml",
+    )
     args = parser.parse_args()
 
-    read_case(args.case_yaml)
+    runner = read_windio(args.file)
+
+    runner.run()

foxes/models/__init__.py

@@ -14,5 +14,6 @@ from . import farm_controllers
 from . import vertical_profiles
 from . import point_models
 from . import axial_induction
+from . import ground_models
 
 from .model_book import ModelBook

foxes/models/ground_models/__init__.py

@@ -0,0 +1,2 @@
+from .no_ground import NoGround
+from .wake_mirror import WakeMirror, GroundMirror