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

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,
+    )

foxes/input/yaml/yaml.py

@@ -0,0 +1,103 @@
+import argparse
+from pathlib import Path
+
+from foxes.utils import Dict
+
+from .dict import run_dict
+
+
+def foxes_yaml():
+    """
+    Command line tool for running foxes from yaml file input.
+
+    Examples
+    --------
+    >>> foxes_yaml input.yaml
+
+    :group: input.yaml
+
+    """
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "yml_file",
+        help="The input yaml file",
+    )
+    parser.add_argument("-o", "--out_dir", help="The output directory", default=".")
+    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
+    fpath = Path(args.yml_file)
+    idata = Dict.from_yaml(fpath, verbosity=v)
+
+    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
+
+    run_dict(
+        idata,
+        rotor_model=args.rotor,
+        partial_wakes=args.pwakes,
+        wake_models=args.wakes,
+        wake_frame=args.frame,
+        engine_pars=epars,
+        iterative=args.iterative,
+        work_dir=fpath.parent,
+        out_dir=args.out_dir,
+        verbosity=args.verbosity,
+    )

foxes/models/partial_wakes/axiwake.py

@@ -2,6 +2,7 @@ import numpy as np
 
 from foxes.models.wake_models.axisymmetric import AxisymmetricWakeModel
 from foxes.utils.two_circles import calc_area
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -130,11 +131,11 @@ class PartialAxiwake(PartialCentre):
         x = wcoos[..., 0, 0]
         n = wcoos[..., 0, 1:3]
         R = np.linalg.norm(n, axis=-1)
-        r = np.zeros((n_states, n_targets, self.n), dtype=FC.DTYPE)
+        r = np.zeros((n_states, n_targets, self.n), dtype=config.dtype_double)
         del wcoos
 
         # prepare circle section area calculation:
-        A = np.zeros((n_states, n_targets, self.n), dtype=FC.DTYPE)
+        A = np.zeros((n_states, n_targets, self.n), dtype=config.dtype_double)
         weights = np.zeros_like(A)
 
         # get normalized 2D vector between rotor and wake centres:
@@ -148,12 +149,12 @@ class PartialAxiwake(PartialCentre):
         sel = (x > 1e-8) & (R > D / 2)
         if np.any(sel):
             n_sel = np.sum(sel)
-            Rsel = np.zeros((n_sel, self.n + 1), dtype=FC.DTYPE)
+            Rsel = np.zeros((n_sel, self.n + 1), dtype=config.dtype_double)
             Rsel[:] = R[sel][:, None]
             Dsel = D[sel][:, None]
 
             # equal delta R2:
-            R1 = np.zeros((n_sel, self.n + 1), dtype=FC.DTYPE)
+            R1 = np.zeros((n_sel, self.n + 1), dtype=config.dtype_double)
             R1[:] = Dsel / 2
             steps = np.linspace(0.0, 1.0, self.n + 1, endpoint=True) - 0.5
             R2 = np.zeros_like(R1)
@@ -170,12 +171,12 @@ class PartialAxiwake(PartialCentre):
         sel = (x > 0) & (R < D / 2)
         if np.any(sel):
             n_sel = np.sum(sel)
-            Rsel = np.zeros((n_sel, self.n + 1), dtype=FC.DTYPE)
+            Rsel = np.zeros((n_sel, self.n + 1), dtype=config.dtype_double)
             Rsel[:] = R[sel][:, None]
             Dsel = D[sel][:, None]
 
             # equal delta R2:
-            R1 = np.zeros((n_sel, self.n + 1), dtype=FC.DTYPE)
+            R1 = np.zeros((n_sel, self.n + 1), dtype=config.dtype_double)
             R1[:, 1:] = Dsel / 2
             R2 = np.zeros_like(R1)
             # R2[:, 1:] = Rsel[:, :-1] + Dsel/2

foxes/models/partial_wakes/centre.py

@@ -1,7 +1,8 @@
 import numpy as np
 
 import foxes.variables as FV
-import foxes.constants as FC
+from foxes.config import config
+
 from .rotor_points import RotorPoints
 
 
@@ -37,4 +38,4 @@ class PartialCentre(RotorPoints):
             The target point weights, shape: (n_tpoints,)
 
         """
-        return fdata[FV.TXYH][:, :, None], np.ones(1, dtype=FC.DTYPE)
+        return fdata[FV.TXYH][:, :, None], np.ones(1, dtype=config.dtype_double)

foxes/models/partial_wakes/segregated.py

@@ -1,6 +1,7 @@
 import numpy as np
 
 from foxes.core import PartialWakesModel
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -143,7 +144,9 @@ class PartialSegregated(PartialWakesModel):
         else:
             ares = {}
             for v, d in amb_res.items():
-                ares[v] = np.zeros((n_states, 1, tdata.n_tpoints), dtype=FC.DTYPE)
+                ares[v] = np.zeros(
+                    (n_states, 1, tdata.n_tpoints), dtype=config.dtype_double
+                )
                 ares[v][:] = np.einsum("sp,p->s", d[:, downwind_index], rpoint_weights)[
                     :, None, None
                 ]
@@ -151,7 +154,7 @@ class PartialSegregated(PartialWakesModel):
         wmodel.finalize_wake_deltas(algo, mdata, fdata, ares, wdel)
 
         for v in wdel.keys():
-            hdel = np.zeros((n_states, n_rotor_points), dtype=FC.DTYPE)
+            hdel = np.zeros((n_states, n_rotor_points), dtype=config.dtype_double)
             hdel[:] = np.einsum("sp,p->s", wdel[v][:, 0], gweights)[:, None]
             wdel[v] = hdel
 

foxes/models/point_models/set_uniform_data.py

@@ -2,8 +2,8 @@ import pandas as pd
 
 from foxes.core.point_data_model import PointDataModel
 from foxes.utils import PandasFileHelper
+from foxes.config import config
 import foxes.constants as FC
-import foxes.variables as FV
 
 
 class SetUniformData(PointDataModel):
@@ -84,7 +84,7 @@ class SetUniformData(PointDataModel):
         if isinstance(self.data_source, pd.DataFrame):
             data = self.data_source[
                 [self.var2col.get(v, v) for v in self.ovars]
-            ].to_numpy(FC.DTYPE)
+            ].to_numpy(config.dtype_double)
         elif isinstance(self.data_source, dict):
             pass
         else:
@@ -93,7 +93,9 @@ class SetUniformData(PointDataModel):
             rpars = dict(index_col=0)
             rpars.update(self._rpars)
             data = PandasFileHelper().read_file(self.data_source, **rpars)
-            data = data[[self.var2col.get(v, v) for v in self.ovars]].to_numpy(FC.DTYPE)
+            data = data[[self.var2col.get(v, v) for v in self.ovars]].to_numpy(
+                config.dtype_double
+            )
 
         idata = super().load_data(algo, verbosity)
         idata["coords"][self.VARS] = self.ovars

foxes/models/rotor_models/centre.py

@@ -3,7 +3,7 @@ import numpy as np
 from foxes.core import RotorModel
 from foxes.utils import wd2uv, uv2wd
 import foxes.variables as FV
-import foxes.constants as FC
+from foxes.config import config
 
 
 class CentreRotor(RotorModel):
@@ -155,7 +155,7 @@ class CentreRotor(RotorModel):
         vdone = []
         for v in self.calc_vars:
             if v not in fdata:
-                fdata[v] = np.zeros((n_states, n_turbines), dtype=FC.DTYPE)
+                fdata[v] = np.zeros((n_states, n_turbines), dtype=config.dtype_double)
 
             if v == FV.WD or v == FV.YAW:
                 if wd is None:

foxes/models/rotor_models/grid.py

@@ -1,7 +1,7 @@
 import numpy as np
 
 from foxes.core import RotorModel
-import foxes.constants as FC
+from foxes.config import config
 
 
 class GridRotor(RotorModel):
@@ -75,12 +75,12 @@ class GridRotor(RotorModel):
         x = [-1.0 + (i + 0.5) * delta for i in range(self.n)]
         x, y = np.meshgrid(x, x, indexing="ij")
 
-        self.__dpoints = np.zeros([N, 3], dtype=FC.DTYPE)
+        self.__dpoints = np.zeros([N, 3], dtype=config.dtype_double)
         self.__dpoints[:, 1] = x.reshape(N)
         self.__dpoints[:, 2] = y.reshape(N)
 
         if self.reduce:
-            self.__weights = np.zeros((self.n, self.n), dtype=FC.DTYPE)
+            self.__weights = np.zeros((self.n, self.n), dtype=config.dtype_double)
             for i in range(0, self.n):
                 for j in range(0, self.n):
                     d = delta / self.nint
@@ -90,7 +90,7 @@ class GridRotor(RotorModel):
                     hy = [
                         y[i, j] - delta / 2.0 + (k + 0.5) * d for k in range(self.nint)
                     ]
-                    pts = np.zeros((self.nint, self.nint, 2), dtype=FC.DTYPE)
+                    pts = np.zeros((self.nint, self.nint, 2), dtype=config.dtype_double)
                     pts[:, :, 0], pts[:, :, 1] = np.meshgrid(hx, hy, indexing="ij")
 
                     d = np.linalg.norm(pts, axis=2)
@@ -105,7 +105,7 @@ class GridRotor(RotorModel):
         else:
             self.__dpoints[:, 1] = x.reshape(N)
             self.__dpoints[:, 2] = y.reshape(N)
-            self.__weights = np.ones(N, dtype=FC.DTYPE) / N
+            self.__weights = np.ones(N, dtype=config.dtype_double) / N
 
     def n_rotor_points(self):
         """

foxes/models/rotor_models/levels.py

@@ -1,7 +1,7 @@
 import numpy as np
 
 from foxes.core import RotorModel
-import foxes.constants as FC
+from foxes.config import config
 
 
 class LevelRotor(RotorModel):
@@ -69,20 +69,20 @@ class LevelRotor(RotorModel):
 
         delta = 2.0 / self.n
         y = [-1.0 + (i + 0.5) * delta for i in range(self.n)]
-        x = np.zeros(self.n, dtype=FC.DTYPE)
+        x = np.zeros(self.n, dtype=config.dtype_double)
 
-        self.dpoints = np.zeros([self.n, 3], dtype=FC.DTYPE)
+        self.dpoints = np.zeros([self.n, 3], dtype=config.dtype_double)
         self.dpoints[:, 1] = x
         self.dpoints[:, 2] = y
 
         if self.reduce:
-            self.weights = np.zeros((self.n), dtype=FC.DTYPE)
+            self.weights = np.zeros((self.n), dtype=config.dtype_double)
             hx = np.linspace(1, -1, self.nint)
 
             for i in range(0, self.n):
                 d = delta / self.nint
                 hy = [y[i] - delta / 2.0 + (k + 0.5) * d for k in range(self.nint)]
-                pts = np.zeros((self.nint, self.nint, 2), dtype=FC.DTYPE)
+                pts = np.zeros((self.nint, self.nint, 2), dtype=config.dtype_double)
                 pts[:, :, 0], pts[:, :, 1] = np.meshgrid(hx, hy, indexing="ij")
 
                 d = np.linalg.norm(pts, axis=2)
@@ -96,7 +96,7 @@ class LevelRotor(RotorModel):
         else:
             self.dpoints[:, 1] = x
             self.dpoints[:, 2] = y
-            self.weights = np.ones(self.n, dtype=FC.DTYPE) / self.n
+            self.weights = np.ones(self.n, dtype=config.dtype_double) / self.n
 
     def n_rotor_points(self):
         """

foxes/models/turbine_models/kTI_model.py

@@ -1,6 +1,7 @@
 import numpy as np
 
 from foxes.core import TurbineModel
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -128,7 +129,8 @@ class kTI(TurbineModel):
         )
 
         k = fdata.get(
-            self.k_var, np.zeros((fdata.n_states, fdata.n_turbines), dtype=FC.DTYPE)
+            self.k_var,
+            np.zeros((fdata.n_states, fdata.n_turbines), dtype=config.dtype_double),
         )
 
         k[st_sel] = kti * ti + kb

foxes/models/turbine_models/lookup_table.py

@@ -4,6 +4,7 @@ import xarray as xr
 
 from foxes.core import TurbineModel
 from foxes.utils import PandasFileHelper
+from foxes.config import config, get_path
 import foxes.constants as FC
 
 
@@ -127,9 +128,10 @@ class LookupTable(TurbineModel):
             if isinstance(self.data_source, pd.DataFrame):
                 data = self.data_source
             else:
+                fpath = get_path(self.data_source)
                 if verbosity > 0:
-                    print(f"{self.name}: Reading file {self.data_source}")
-                data = PandasFileHelper.read_file(self.data_source, **self._rpars)
+                    print(f"{self.name}: Reading file {fpath}")
+                data = PandasFileHelper.read_file(fpath, **self._rpars)
 
             if verbosity > 0:
                 print(f"{self.name}: Preparing interpolation data")
@@ -138,7 +140,8 @@ class LookupTable(TurbineModel):
             data = data[self.input_vars + self.output_vars]
             data.sort_values(by=self.input_vars, inplace=True)
             coords = {
-                v: np.asarray(data[v].unique(), dtype=FC.DTYPE) for v in self.input_vars
+                v: np.asarray(data[v].unique(), dtype=config.dtype_double)
+                for v in self.input_vars
             }
 
             dvars = {}
@@ -146,7 +149,7 @@ class LookupTable(TurbineModel):
                 pivot_matrix = data.pivot_table(index=self.input_vars, values=[oname])
                 dvars[oname] = (
                     self.input_vars,
-                    pivot_matrix.to_numpy(FC.DTYPE).reshape(
+                    pivot_matrix.to_numpy(config.dtype_double).reshape(
                         pivot_matrix.index.levshape
                     ),
                 )