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

foxes/data/windio/windio_5turbines_timeseries.yaml

@@ -1,79 +0,0 @@
-name: 5 turbines and a wind timeseries
-
-site:
-  name: Site with wind timeseries data
-  boundaries:
-      polygons: [
-          x: [-10, -10, 1610, 1610],
-          y: [-10, 10, 10, -10]
-      ]
-  energy_resource:
-    name: NetCDF timeseries with 5000 states
-    wind_resource: !include ../states/windio_timeseries_5000.nc
-
-wind_farm: 
-  name: One row with 5 turbines
-  layouts:
-    - coordinates:
-        x: [0, 0, 0, 0, 0]
-        y: [0, 600, 1150, 1730, 2400]
-  turbines: !include DTU_10MW_turbine.yaml
-
-attributes:
-  flow_model:
-    name: foxes
-
-  analysis:
-
-    #pywake and foxes
-    wind_deficit_model:
-      name: Bastankhah2014
-      wake_expansion_coefficient: # k = ka*ti + kb
-        k_a: 0.0
-        k_b: 0.04
-        free_stream_ti: false
-      ceps: 0.2
-      use_effective_ws: true
-    axial_induction_model: Madsen
-    deflection_model:
-      name: None
-    turbulence_model:
-      name: CrespoHernandez
-    superposition_model:
-      ws_superposition: Linear
-      ti_superposition: Quadratic
-    rotor_averaging:
-      grid: grid
-      n_x_grid_points: 4
-      n_y_grid_points: 4
-      background_averaging: center
-      wake_averaging: centre
-      wind_speed_exponent_for_power: 3
-      wind_speed_exponent_for_ct: 2
-    blockage_model:
-      name: None
-
-  outputs:
-    output_folder: "results"
-    turbine_outputs:
-        turbine_nc_filename: 'turbine_data.nc' # dimension = states, turbine
-        output_variables: ['power', 'rotor_effective_velocity'] #'frequency'
-    #
-    flow_field:
-      report: False
-      flow_nc_filename: flow_field.nc
-      cases_run:
-        all_occurences: True
-      output_variables: ['wind_speed', 'wind_direction']
-      z_planes:
-        z_sampling: "hub_height"
-        xy_sampling: "default"
-    #
-    statistics:
-      stats_filename: None
-      AEP: False
-      AEP_per_turbine: False
-      power_percentiles:
-        report: False
-        percentiles: None
-

foxes/input/windio/__init__.py

@@ -1,11 +0,0 @@
-"""
-Functions for using windIO yaml files as input.
-"""
-
-from .windio import read_windio
-from .read_fields import wio2foxes, foxes2wio
-from .get_states import get_states
-from .read_farm import read_turbine_types, read_layout
-from .read_attributes import read_attributes
-from .read_outputs import read_outputs
-from .runner import WindioRunner

foxes/input/windio/read_outputs.py

@@ -1,172 +0,0 @@
-import numpy as np
-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, odir, out_dicts, 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="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",
-            }
-        )
-
-        out_dicts.append(
-            Dict(
-                {
-                    "output_type": "StateTurbineTable",
-                    "farm_results": True,
-                    "algo": False,
-                    "run_func": "get_dataset",
-                    "run_kwargs": dict(
-                        variables=[vmap[v] for v in output_variables],
-                        name_map=ivmap,
-                        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",
-            )
-        )
-
-
-def _read_flow_field(wio_outs, odir, out_dicts, 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="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="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)
-
-        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":
-            out_dicts.append(
-                Dict(
-                    {
-                        "output_type": "SliceData",
-                        "farm_results": True,
-                        "algo": True,
-                        "verbosity_delta": 3,
-                        "run_func": "get_states_data_xy",
-                        "run_kwargs": dict(
-                            states_isel=states_isel,
-                            n_img_points=(100, 100),
-                            variables=[vmap[v] for v in output_variables],
-                            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",
-                )
-            )
-        else:
-            raise NotImplementedError(
-                f"xy_sampling '{xy_sampling}' is not supported (yet)"
-            )
-
-
-def read_outputs(wio_outs, algo_dict, output_dir=None, verbosity=1):
-    """
-    Reads the windio outputs
-
-    Parameters
-    ----------
-    wio_outs: dict
-        The windio output data
-    algo_dict: dict
-        The algorithm dictionary
-    output_dir: pathlib.Path, optional
-        Path to the output folder
-    verbosity: int
-        The verbosity level, 0=silent
-
-    Returns
-    -------
-    out_dicts: list of dict
-        The output dictionaries
-    odir: pathlib.Path
-        Path to the output folder
-
-    :group: input.windio
-
-    """
-    out_dicts = []
-    odir = (
-        Path(output_dir)
-        if output_dir is not None
-        else Path(wio_outs.pop("output_folder", "results"))
-    )
-    odir.mkdir(exist_ok=True, parents=True)
-    if verbosity > 2:
-        print("  Reading outputs")
-        print("    Output folder:", odir)
-        print("    Contents:", [k for k in wio_outs.keys()])
-
-    # read turbine_outputs:
-    _read_turbine_outputs(wio_outs, odir, out_dicts, verbosity)
-
-    # read flow field:
-    _read_flow_field(wio_outs, odir, out_dicts, verbosity)
-
-    return out_dicts, odir

foxes/input/windio/runner.py

@@ -1,183 +0,0 @@
-import yaml
-
-from foxes.core import Algorithm
-from foxes.output import Output
-
-
-def _write_yaml(data, fpath):
-    """Write the data to yaml"""
-    rmap = {
-        "include": "!include",
-    }
-    with open(fpath, "w") as file:
-        yaml.dump(data, file)
-    with open(fpath, "r") as f:
-        s = f.read()
-    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
-
-    Attributes
-    ----------
-    algo: foxes.core.Algorithm
-        The algorithm object
-    output_dir: pathlib.Path
-        Path to the output folder
-    output_dicts: list of dict
-        The output dictionaries
-    farm_results: xarray.Dataset
-        The farm results
-    output_results: list
-        The output results
-    wio_input_data: dict
-        The wind_energy_system windio input data
-    file_name_input_yaml: str
-        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
-
-    :group: input.windio
-
-    """
-
-    def __init__(
-        self,
-        algo_dict,
-        output_dir=".",
-        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
-
-        Parameters
-        ----------
-        algo_dict: dict
-            The algorithm dictionary
-        output_dir: pathlib.Path
-            Path to the output folder
-        output_dicts: list of dict
-            The output dictionaries
-        wio_input_data: dict
-            The wind_energy_system windio input data
-        file_name_input_yaml: str
-            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
-
-        """
-        self.algo = algo_dict
-        self.output_dir = output_dir
-        self.output_dicts = output_dicts
-        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 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}"
-
-    def print(self, *args, level=1, **kwargs):
-        """Print based on verbosity"""
-        if self.verbosity >= level:
-            print(*args, **kwargs)
-
-    def initialize(self):
-        """Initializes the runner"""
-        if isinstance(self.algo, dict):
-            self.print(f"Creating algorithm '{self.algo['algo_type']}'", level=2)
-            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()
-        self.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", {})
-
-            _odict = odict.copy()
-            if "output_yaml_update" in _odict:
-                self._output_yaml.update(_odict.pop("output_yaml_update"))
-            if _odict.pop("farm_results", False):
-                _odict["farm_results"] = self.farm_results
-            if _odict.pop("algo", False):
-                _odict["algo"] = self.algo
-            o = Output.new(**_odict)
-            f = getattr(o, run_fname)
-            self.output_results.append(f(*run_args, **run_kwargs))
-
-        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()
-        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,193 +0,0 @@
-from pathlib import Path
-
-from foxes.core import WindFarm
-from foxes.models import ModelBook
-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_types
-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 > 1:
-        print("Reading site")
-        print("  Name:", wio_site.pop("name", None))
-        print("  Contents:", [k for k in wio_site.keys()])
-
-    # ignore boundaries:
-    if verbosity > 2:
-        print("  Ignoring boundaries")
-
-    # read energy_resource:
-    energy_resource = Dict(wio_site["energy_resource"], name="energy_resource")
-    if verbosity > 2:
-        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 > 2:
-        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():
-        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]}")
-
-    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 > 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["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, algo_dict, ws_exp_P, ws_exp_ct, verbosity)
-
-    # read layouts:
-    wfarm = wio_farm["layouts"]
-    if isinstance(wfarm, dict):
-        layouts = Dict(wfarm, name="layouts")
-    else:
-        layouts = Dict({i: l for i, l in enumerate(wfarm)}, 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, algo_dict, ttypes, verbosity)
-
-
-def read_windio(
-    windio_yaml,
-    verbosity=1,
-    algo_pars=None,
-    output_dir=None,
-    **runner_pars,
-):
-    """
-    Reads a complete WindIO case.
-
-    This is the main entry point for windio case
-    calculations.
-
-    Parameters
-    ----------
-    windio_yaml: str
-        Path to the windio yaml file
-    verbosity: int
-        The verbosity level, 0 = silent
-    algo_pars: dict, optional
-        Additional algorithm parameters
-    output_dir: str, optional
-        Path to the output folder
-    runner_pars: dict, optional
-        Additional parameters for the WindioRunner
-
-    Returns
-    -------
-    runner: foxes.input.windio.WindioRunner
-        The windio runner, call its run function
-        for the complete exection
-
-    :group: input.windio
-
-    """
-    wio_file = Path(windio_yaml)
-    if not wio_file.is_file():
-        wio_file = StaticData().get_file_path(WINDIO, wio_file, check_raw=False)
-
-    if verbosity > 0:
-        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 = yml_utils.load_yaml(wio_file)
-
-    if verbosity > 1:
-        print("  Name:", wio.pop("name", None))
-        print("  Contents:", [k for k in wio.keys()])
-
-    algo_dict = Dict(algo_type="Downwind", name="algo_dict")
-    if algo_pars is not None:
-        algo_dict.update(algo_pars)
-    algo_dict.update(
-        dict(
-            mbook=ModelBook(),
-            farm=WindFarm(),
-            wake_models=[],
-            verbosity=verbosity - 3,
-        )
-    )
-
-    _read_site(wio, algo_dict, verbosity)
-    _read_farm(wio, algo_dict, verbosity)
-
-    out_dicts, odir = read_attributes(
-        wio,
-        algo_dict,
-        output_dir=output_dir,
-        verbosity=verbosity,
-    )
-
-    if verbosity > 1:
-        print("Creating windio runner")
-    runner = WindioRunner(
-        algo_dict,
-        output_dir=odir,
-        output_dicts=out_dicts,
-        wio_input_data=wio,
-        verbosity=verbosity,
-        **runner_pars,
-    )
-
-    return runner
-
-
-if __name__ == "__main__":
-    import argparse
-
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "-f",
-        "--file",
-        help="The windio yaml file",
-        default="windio_5turbines_timeseries.yaml",
-    )
-    args = parser.parse_args()
-
-    runner = read_windio(args.file)
-
-    runner.run()