foxes 0.8.2__py3-none-any.whl → 1.0__py3-none-any.whl

foxes/input/windio/windio.py

@@ -1,5 +1,3 @@
-import numpy as np
-import pandas as pd
 from pathlib import Path
 
 from foxes.core import WindFarm
@@ -9,7 +7,7 @@ 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_farm import read_layout, read_turbine_types
 from .read_attributes import read_attributes
 from .runner import WindioRunner
 
@@ -78,19 +76,27 @@ def _read_farm(wio, algo_dict, verbosity):
         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)
+    ttypes = read_turbine_types(wio_farm, algo_dict, ws_exp_P, ws_exp_ct, verbosity)
 
     # read layouts:
-    layouts = Dict(wio_farm["layouts"], name="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, ttype, verbosity)
+        read_layout(lname, ldict, algo_dict, ttypes, verbosity)
 
 
-def read_windio(windio_yaml, verbosity=1):
+def read_windio(
+    windio_yaml,
+    verbosity=1,
+    algo_pars=None,
+    **runner_pars,
+):
     """
     Reads a complete WindIO case.
 
@@ -103,6 +109,10 @@ def read_windio(windio_yaml, verbosity=1):
         Path to the windio yaml file
     verbosity: int
         The verbosity level, 0 = silent
+    algo_pars: dict, optional
+        Additional algorithm parameters
+    runner_pars: dict, optional
+        Additional parameters for the WindioRunner
 
     Returns
     -------
@@ -113,7 +123,6 @@ def read_windio(windio_yaml, verbosity=1):
     :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)
@@ -128,17 +137,21 @@ def read_windio(windio_yaml, verbosity=1):
         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-3,
+    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,
@@ -148,12 +161,13 @@ def read_windio(windio_yaml, verbosity=1):
     if verbosity > 1:
         print("Creating windio runner")
     runner = WindioRunner(
-                algo_dict, 
-                output_dir=odir,
-                output_dicts=out_dicts, 
-                wio_input_data=wio, 
-                verbosity=verbosity
-            )
+        algo_dict,
+        output_dir=odir,
+        output_dicts=out_dicts,
+        wio_input_data=wio,
+        verbosity=verbosity,
+        **runner_pars,
+    )
 
     return runner
 

foxes/models/ground_models/wake_mirror.py

@@ -70,6 +70,10 @@ class WakeMirror(GroundModel):
         # prepare:
         hh = fdata[FV.H][:, downwind_index].copy()
 
+        # DEBUG CHECK:
+        # import numpy as np
+        # assert(np.all(fdata[FV.H]==fdata[FV.TXYH[..., 2]]))
+
         # contribution from main wake:
         wcoos = algo.wake_frame.get_wake_coos(algo, mdata, fdata, tdata, downwind_index)
         wmodel.contribute(algo, mdata, fdata, tdata, downwind_index, wcoos, wake_deltas)
@@ -78,14 +82,14 @@ class WakeMirror(GroundModel):
         tdata[FC.TARGETS] = tdata[FC.TARGETS].copy()  # making sure this is no ref
         for h in self.heights:
 
-            fdata[FV.H][:, downwind_index] = hh + 2 * (h - hh)
+            fdata[FV.TXYH][:, downwind_index, 2] = hh + 2 * (h - hh)
 
             pwake.contribute(
                 algo, mdata, fdata, tdata, downwind_index, wake_deltas, wmodel
             )
 
         # reset heights:
-        fdata[FV.H][:, downwind_index] = hh
+        fdata[FV.TXYH][:, downwind_index, 2] = hh
 
     def contribute_to_point_wakes(
         self,
@@ -133,7 +137,7 @@ class WakeMirror(GroundModel):
         tdata[FC.TARGETS] = tdata[FC.TARGETS].copy()  # making sure this is no ref
         for h in self.heights:
 
-            fdata[FV.H][:, downwind_index] = hh + 2 * (h - hh)
+            fdata[FV.TXYH][:, downwind_index, 2] = hh + 2 * (h - hh)
 
             wcoos = algo.wake_frame.get_wake_coos(
                 algo, mdata, fdata, tdata, downwind_index
@@ -143,7 +147,7 @@ class WakeMirror(GroundModel):
             )
 
         # reset heights:
-        fdata[FV.H][:, downwind_index] = hh
+        fdata[FV.TXYH][:, downwind_index, 2] = hh
 
 
 class GroundMirror(WakeMirror):

foxes/models/model_book.py

@@ -85,8 +85,7 @@ class ModelBook:
         self.point_models["tke2ti"] = fm.point_models.TKE2TI()
 
         self.rotor_models = FDict(name="rotor_models")
-        rvars = [FV.REWS, FV.REWS2, FV.REWS3, FV.TI, FV.RHO]
-        self.rotor_models["centre"] = fm.rotor_models.CentreRotor(calc_vars=rvars)
+        self.rotor_models["centre"] = fm.rotor_models.CentreRotor()
 
         def _n2n(n2):
             n2 = float(n2)
@@ -100,7 +99,7 @@ class ModelBook:
         self.rotor_models.add_factory(
             fm.rotor_models.GridRotor,
             "grid<n2>",
-            kwargs=dict(calc_vars=rvars, reduce=True),
+            kwargs=dict(reduce=True),
             var2arg={"n2": "n"},
             n2=_n2n,
             hints={"n2": "(Number of points in square grid)"},
@@ -108,7 +107,7 @@ class ModelBook:
         self.rotor_models.add_factory(
             fm.rotor_models.GridRotor,
             "grid<n2>_raw",
-            kwargs=dict(calc_vars=rvars, reduce=False),
+            kwargs=dict(reduce=False),
             var2arg={"n2": "n"},
             n2=_n2n,
             hints={"n2": "(Number of points in square grid)"},
@@ -116,14 +115,14 @@ class ModelBook:
         self.rotor_models.add_factory(
             fm.rotor_models.LevelRotor,
             "level<n>",
-            kwargs=dict(calc_vars=rvars, reduce=True),
+            kwargs=dict(reduce=True),
             n=lambda x: int(x),
             hints={"n": "(Number of vertical levels)"},
         )
         self.rotor_models.add_factory(
             fm.rotor_models.LevelRotor,
             "level<n>_raw",
-            kwargs=dict(calc_vars=rvars, reduce=False),
+            kwargs=dict(reduce=False),
             n=lambda x: int(x),
             hints={"n": "(Number of vertical levels)"},
         )
@@ -158,14 +157,14 @@ class ModelBook:
             fm.turbine_models.kTI,
             "kTI_<kTI>",
             kTI=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
-            hints={"kTI": "(Value, e.g. 004 for 0.04)"},
+            hints={"kTI": "(Value, e.g. 02 for 0.2)"},
         )
         self.turbine_models.add_factory(
             fm.turbine_models.kTI,
             "kTI_amb_<kTI>",
             kwargs=dict(ti_var=FV.AMB_TI),
             kTI=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
-            hints={"kTI": "(Value, e.g. 004 for 0.04)"},
+            hints={"kTI": "(Value, e.g. 04 for 0.4)"},
         )
         self.turbine_models.add_factory(
             fm.turbine_models.kTI,
@@ -173,7 +172,7 @@ class ModelBook:
             kTI=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
             kb=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
             hints={
-                "kTI": "(Value, e.g. 004 for 0.04)",
+                "kTI": "(Value, e.g. 04 for 0.4)",
                 "kb": "(Value, e.g. 004 for 0.04)",
             },
         )
@@ -184,7 +183,7 @@ class ModelBook:
             kTI=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
             kb=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
             hints={
-                "kTI": "(Value, e.g. 004 for 0.04)",
+                "kTI": "(Value, e.g. 04 for 0.4)",
                 "kb": "(Value, e.g. 004 for 0.04)",
             },
         )
@@ -254,12 +253,24 @@ class ModelBook:
         )
 
         self.wake_frames["timelines"] = fm.wake_frames.Timelines()
+        self.wake_frames["dyn_wakes"] = fm.wake_frames.DynamicWakes()
+        self.wake_frames["seq_dyn_wakes"] = fm.wake_frames.SeqDynamicWakes()
 
         def _todt(x):
             if x[-1] == "s":
                 return float(x[:-1]) / 60
             elif x[-3:] == "min":
                 return float(x[:-3])
+            else:
+                raise NotImplementedError(f"Cannot translate '{x}' into minutes")
+
+        def _tokm(x):
+            if x[-2:] == "km":
+                return float(x[:-2])
+            elif x[-1] == "m":
+                return float(x[:-1]) / 1e3
+            else:
+                raise NotImplementedError(f"Cannot translate '{x}' into km")
 
         self.wake_frames.add_factory(
             fm.wake_frames.Timelines,
@@ -268,6 +279,13 @@ class ModelBook:
             var2arg={"dt": "dt_min"},
             hints={"dt": "(Time step, e.g '10s', '1min' etc.)"},
         )
+        self.wake_frames.add_factory(
+            fm.wake_frames.DynamicWakes,
+            "dyn_wakes_<length>",
+            length=_tokm,
+            var2arg={"length": "max_length_km"},
+            hints={"length": "(Maximal wake length, e.g. '5km' or '5000m')"},
+        )
         self.wake_frames.add_factory(
             fm.wake_frames.SeqDynamicWakes,
             "seq_dyn_wakes_<dt>",
@@ -411,14 +429,6 @@ class ModelBook:
             hints={"superposition": "(Superposition, e.g. linear for ti_linear)"},
         )
 
-        self.wake_models.add_factory(
-            fm.wake_models.ti.IECTIWake,
-            "IECTI2005_<superposition>",
-            kwargs=dict(iec_type="2005"),
-            superposition=lambda s: f"ti_{s}",
-            hints={"superposition": "(Superposition, e.g. linear for ti_linear)"},
-        )
-
         self.wake_models.add_factory(
             fm.wake_models.ti.IECTIWake,
             "IECTI2019_<superposition>",
@@ -466,6 +476,7 @@ class ModelBook:
             var2arg={"height": "heights"},
             height=lambda h: [0.0, float(h)],
             hints={"height": "(Boundary layer wake reflection height)"},
+            example_vars={"height": 500},
         )
 
         self.sources = FDict(

foxes/models/partial_wakes/rotor_points.py

@@ -1,4 +1,5 @@
 from foxes.core import PartialWakesModel
+import foxes.constants as FC
 
 
 class RotorPoints(PartialWakesModel):
@@ -33,10 +34,9 @@ class RotorPoints(PartialWakesModel):
             The target point weights, shape: (n_tpoints,)
 
         """
-        rotor = algo.rotor_model
         return (
-            rotor.from_data_or_store(rotor.RPOINTS, algo, mdata),
-            rotor.from_data_or_store(rotor.RWEIGHTS, algo, mdata),
+            algo.get_from_chunk_store(FC.ROTOR_POINTS, mdata=mdata),
+            algo.get_from_chunk_store(FC.ROTOR_WEIGHTS, mdata=mdata),
         )
 
     def finalize_wakes(

foxes/models/rotor_models/centre.py

@@ -132,6 +132,10 @@ class CentreRotor(RotorModel):
         n_states = mdata.n_states
         n_turbines = algo.n_turbines
 
+        for v in [FV.REWS2, FV.REWS3]:
+            if v in fdata and v not in self.calc_vars:
+                self.calc_vars.append(v)
+
         uvp = None
         uv = None
         if (

foxes/models/rotor_models/grid.py

@@ -17,7 +17,7 @@ class GridRotor(RotorModel):
     reduce: bool
         Flag for reduction to points actually representing
         an area with overlap with the circe, recalculating
-        the self.weights accordingly
+        the self.__weights accordingly
     nint: int
         Integration steps per element
 
@@ -25,7 +25,7 @@ class GridRotor(RotorModel):
 
     """
 
-    def __init__(self, n, calc_vars, reduce=True, nint=200):
+    def __init__(self, n, reduce=True, nint=200, **kwargs):
         """
         Constructor.
 
@@ -34,20 +34,19 @@ class GridRotor(RotorModel):
         n: int
             The number of points along one direction,
             maximal number of points is N = n * n
-        calc_vars: list of str
-            The variables that are calculated by the model
-            (Their ambients are added automatically)
         reduce: bool
             Flag for reduction to points actually representing
             an area with overlap with the circe, recalculating
-            the self.weights accordingly
+            the self.__weights accordingly
         nint: int
             Integration steps per element
         name: str, optional
             The model name
+        kwargs: dict, optional
+            Addition parameters for the base model
 
         """
-        super().__init__(calc_vars)
+        super().__init__(**kwargs)
 
         self.n = n
         self.reduce = reduce
@@ -76,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[:, 1] = x.reshape(N)
-        self.dpoints[:, 2] = y.reshape(N)
+        self.__dpoints = np.zeros([N, 3], dtype=FC.DTYPE)
+        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=FC.DTYPE)
             for i in range(0, self.n):
                 for j in range(0, self.n):
                     d = delta / self.nint
@@ -95,18 +94,18 @@ class GridRotor(RotorModel):
                     pts[:, :, 0], pts[:, :, 1] = np.meshgrid(hx, hy, indexing="ij")
 
                     d = np.linalg.norm(pts, axis=2)
-                    self.weights[i, j] = np.sum(d <= 1.0) / self.nint**2
+                    self.__weights[i, j] = np.sum(d <= 1.0) / self.nint**2
 
-            self.weights = self.weights.reshape(N)
-            sel = self.weights > 0.0
-            self.dpoints = self.dpoints[sel]
-            self.weights = self.weights[sel]
-            self.weights /= np.sum(self.weights)
+            self.__weights = self.__weights.reshape(N)
+            sel = self.__weights > 0.0
+            self.__dpoints = self.__dpoints[sel]
+            self.__weights = self.__weights[sel]
+            self.__weights /= np.sum(self.__weights)
 
         else:
-            self.dpoints[:, 1] = x.reshape(N)
-            self.dpoints[:, 2] = y.reshape(N)
-            self.weights = np.ones(N, dtype=FC.DTYPE) / N
+            self.__dpoints[:, 1] = x.reshape(N)
+            self.__dpoints[:, 2] = y.reshape(N)
+            self.__weights = np.ones(N, dtype=FC.DTYPE) / N
 
     def n_rotor_points(self):
         """
@@ -118,7 +117,7 @@ class GridRotor(RotorModel):
             The number of rotor points
 
         """
-        return len(self.weights)
+        return len(self.__weights)
 
     def design_points(self):
         """
@@ -137,7 +136,7 @@ class GridRotor(RotorModel):
             The design points, shape: (n_points, 3)
 
         """
-        return self.dpoints
+        return self.__dpoints
 
     def rotor_point_weights(self):
         """
@@ -150,4 +149,4 @@ class GridRotor(RotorModel):
             add to one, shape: (n_rpoints,)
 
         """
-        return self.weights
+        return self.__weights

foxes/models/rotor_models/levels.py

@@ -24,7 +24,7 @@ class LevelRotor(RotorModel):
 
     """
 
-    def __init__(self, n, calc_vars, reduce=True, nint=200):
+    def __init__(self, n, reduce=True, nint=200, **kwargs):
         """
         Constructor.
 
@@ -32,9 +32,6 @@ class LevelRotor(RotorModel):
         ----------
         n: int
             The number of points along the vertical direction
-        calc_vars: list of str
-            The variables that are calculated by the model
-            (Their ambients are added automatically)
         reduce: bool
             Flag for calculating the weight of every element according
             to the rotor diameter at the respective height level
@@ -42,9 +39,11 @@ class LevelRotor(RotorModel):
             Integration steps per element
         name: str, optional
             The model name
+        kwargs: dict, optional
+            Addition parameters for the base model
 
         """
-        super().__init__(calc_vars)
+        super().__init__(**kwargs)
 
         self.n = n
         self.reduce = reduce

foxes/models/turbine_models/calculator.py

@@ -1,5 +1,3 @@
-import numpy as np
-
 from foxes.core import TurbineModel
 
 

foxes/models/turbine_models/lookup_table.py

@@ -36,6 +36,7 @@ class LookupTable(TurbineModel):
         varmap={},
         pd_file_read_pars={},
         xr_interp_args={},
+        interpn_args={},
         **kwargs,
     ):
         """
@@ -56,6 +57,8 @@ class LookupTable(TurbineModel):
             Parameters for pandas file reading
         xr_interp_args: dict
             Parameters for xarray interpolation method
+        interpn_args: dict
+            Parameters for scipy intern or interp1d
         kwargs: dict, optional
             Additional parameters, added as default
             values if not in data
@@ -70,6 +73,7 @@ class LookupTable(TurbineModel):
 
         self._rpars = pd_file_read_pars
         self._xargs = xr_interp_args
+        self._iargs = interpn_args
         self._data = None
 
         for v, d in kwargs.items():
@@ -184,7 +188,7 @@ class LookupTable(TurbineModel):
         """
         data = {
             v: self.get_data(
-                self.input_vars[0],
+                v,
                 FC.STATE_TURBINE,
                 lookup="fs",
                 fdata=fdata,
@@ -192,6 +196,7 @@ class LookupTable(TurbineModel):
             )[st_sel]
             for v in self.input_vars
         }
+
         dims = {
             v: ("_z") if len(data[v].shape) == 1 else ("_z", "_u")
             for v in self.input_vars
@@ -205,7 +210,27 @@ class LookupTable(TurbineModel):
         }
         del data, dims
 
-        odata = self._data.interp(**indata, **self._xargs)
+        iargs = dict(bounds_error=True)
+        iargs.update(self._iargs)
+        try:
+            odata = self._data.interp(**indata, kwargs=iargs, **self._xargs)
+        except ValueError as e:
+            print("\nBOUNDS ERROR", self.name)
+            print("Variables:", list(indata.keys()))
+            print(
+                "DATA min/max:",
+                [float(np.min(self._data[v].to_numpy())) for v in indata.keys()],
+                [float(np.max(self._data[v].to_numpy())) for v in indata.keys()],
+            )
+            print(
+                "EVAL min/max:",
+                [float(np.min(d.to_numpy())) for d in indata.values()],
+                [float(np.max(d.to_numpy())) for d in indata.values()],
+            )
+            print(
+                "\nMaybe you want to try the options 'bounds_error=False, fill_value=None'? This will extrapolate the data.\n"
+            )
+            raise e
 
         out = {}
         for v in self.output_vars:

foxes/models/turbine_models/rotor_centre_calc.py

@@ -1,6 +1,6 @@
 import numpy as np
 
-from foxes.core import TurbineModel, Data
+from foxes.core import TurbineModel, TData
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -108,7 +108,7 @@ class RotorCentreCalc(TurbineModel):
 
         """
         # prepare target point data:
-        tdata = Data.from_points(
+        tdata = TData.from_points(
             fdata[FV.TXYH],
             data={
                 v: np.zeros_like(fdata[FV.X][:, :, None])
@@ -131,6 +131,7 @@ class RotorCentreCalc(TurbineModel):
         # extract results:
         out = {v: fdata[v] for v in self.calc_vars.keys()}
         for v in out.keys():
-            out[v][st_sel] = res[self.calc_vars[v]][st_sel]
+            w = self.calc_vars[v]
+            out[v][st_sel] = res[w][st_sel][..., 0]
 
         return out