foxes 0.6.1__py3-none-any.whl → 0.7__py3-none-any.whl

foxes/input/states/create/random_abl_states.py

@@ -11,7 +11,7 @@ def create_random_abl_states(
     """
     Create random abl states.
 
-        Parameters
+    Parameters
     ----------
     n_states: int
         The number of states
@@ -32,7 +32,7 @@ def create_random_abl_states(
     data: pandas.DataFrame
         The created states data
 
-    :group: input.states
+    :group: input.states.create
 
     """
 
@@ -70,6 +70,10 @@ def write_random_abl_states(
     **kwargs
 ):
     """
+    Writes random abl states to file
+
+    Parameters
+    ----------
     file_path: str
         Path to the file
     n_states: int

foxes/input/states/create/random_timeseries.py

@@ -0,0 +1,56 @@
+import numpy as np
+import pandas as pd
+
+import foxes.variables as FV
+
+
+def random_timseries_data(
+    n_times,
+    data_ranges=None,
+    start_time="2000-01-01 00:00:00",
+    freq="h",
+    seed=None,
+    iname="Time",
+):
+    """
+    Creates random uniform timeseries data
+
+    Parameters
+    ----------
+    n_times: int
+        The number of time steps
+    data_ranges: dict, optional
+        The data ranges. Key: variable name,
+        value: tuple, [min, max) values
+    start_time: str
+        The first time stamp in the series
+    freq: str
+        The time period range frequency
+    seed: int, optional
+        The random seed
+    iname: str
+        The index name
+
+    Returns
+    -------
+    sdata: pandas.DataFrame
+        The timeseries data
+
+    :group: input.states.create
+
+    """
+    if seed:
+        np.random.seed(seed)
+
+    dranges = {FV.WS: (0.0, 30.0), FV.WD: (0.0, 360.0)}
+    if data_ranges:
+        dranges.update(data_ranges)
+
+    times = pd.period_range(start=start_time, periods=n_times, freq=freq)
+    times = times.astype(str).astype("datetime64[ns]")
+    sdata = pd.DataFrame(
+        index=times,
+        data={v: np.random.uniform(d[0], d[1], n_times) for v, d in dranges.items()},
+    )
+    sdata.index.name = iname
+    return sdata

foxes/input/states/field_data_nc.py

@@ -421,7 +421,7 @@ class FieldDataNC(States):
         """
         return self._weights
 
-    def calculate(self, algo, mdata, fdata, pdata):
+    def calculate(self, algo, mdata, fdata, tdata):
         """ "
         The main model calculation.
 
@@ -432,22 +432,26 @@ class FieldDataNC(States):
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
+        mdata: foxes.core.MData
             The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
-        pdata: foxes.core.Data
-            The point data
+        tdata: foxes.core.TData
+            The target point data
 
         Returns
         -------
         results: dict
             The resulting data, keys: output variable str.
-            Values: numpy.ndarray with shape (n_states, n_points)
+            Values: numpy.ndarray with shape
+            (n_states, n_targets, n_tpoints)
 
         """
         # prepare:
-        points = pdata[FC.POINTS]
+        n_states = tdata.n_states
+        n_targets = tdata.n_targets
+        n_tpoints = tdata.n_tpoints
+        points = tdata[FC.TARGETS].reshape(n_states, n_targets * n_tpoints, 3)
         n_pts = points.shape[1]
         n_states = fdata.n_states
 
@@ -571,4 +575,4 @@ class FieldDataNC(States):
                         (n_states, n_pts), self.fixed_vars[v], dtype=FC.DTYPE
                     )
 
-        return out
+        return {v: d.reshape(n_states, n_targets, n_tpoints) for v, d in out.items()}

foxes/input/states/multi_height.py

@@ -192,13 +192,13 @@ class MultiHeightStates(States):
             isorg = False
         else:
             isorg = True
+            data = self.data_source
 
         if self.states_sel is not None:
             data = data.iloc[self.states_sel]
         elif self.states_loc is not None:
             data = data.loc[self.states_loc]
-        else:
-            data = data
+
         self._N = len(data.index)
         self._inds = data.index.to_numpy()
 
@@ -308,7 +308,7 @@ class MultiHeightStates(States):
         """
         return self._weights
 
-    def calculate(self, algo, mdata, fdata, pdata):
+    def calculate(self, algo, mdata, fdata, tdata):
         """ "
         The main model calculation.
 
@@ -319,24 +319,29 @@ class MultiHeightStates(States):
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
+        mdata: foxes.core.MData
             The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
-        pdata: foxes.core.Data
-            The point data
+        tdata: foxes.core.TData
+            The target point data
 
         Returns
         -------
         results: dict
             The resulting data, keys: output variable str.
-            Values: numpy.ndarray with shape (n_states, n_points)
+            Values: numpy.ndarray with shape
+            (n_states, n_targets, n_tpoints)
 
         """
+        n_states = tdata.n_states
+        n_targets = tdata.n_targets
+        n_tpoints = tdata.n_tpoints
         h = mdata[self.H]
-        z = pdata[FC.POINTS][:, :, 2]
+        z = tdata[FC.TARGETS][..., 2].reshape(n_states, n_targets * n_tpoints)
         n_h = len(h)
         vrs = list(mdata[self.VARS])
+        n_vars = len(vrs)
 
         coeffs = np.zeros((n_h, n_h), dtype=FC.DTYPE)
         np.fill_diagonal(coeffs, 1.0)
@@ -364,24 +369,29 @@ class MultiHeightStates(States):
                 raise KeyError(
                     f"States '{self.name}': Found variable '{FV.WD}', but missing variable '{FV.WS}'"
                 )
-            uv = np.einsum("shd,sph->spd", uvh, ires)
+            uv = np.einsum("shd,sph->spd", uvh, ires).reshape(
+                n_states, n_targets, n_tpoints, 2
+            )
             del uvh
 
-        ires = np.einsum("svh,sph->svp", mdata[self.DATA], ires)
+        ires = np.einsum("svh,sph->vsp", mdata[self.DATA], ires).reshape(
+            n_vars, n_states, n_targets, n_tpoints
+        )
 
         results = {}
         for v in self.ovars:
-            results[v] = pdata[v]
             if has_wd and v == FV.WD:
                 results[v] = uv2wd(uv, axis=-1)
             elif has_wd and v == FV.WS:
                 results[v] = np.linalg.norm(uv, axis=-1)
             elif v in self.fixed_vars:
+                results[v] = np.zeros((n_states, n_targets, n_tpoints), dtype=FC.DTYPE)
                 results[v][:] = self.fixed_vars[v]
             elif v in self._solo.keys():
-                results[v][:] = mdata[self.var(v)][:, None]
+                results[v] = np.zeros((n_states, n_targets, n_tpoints), dtype=FC.DTYPE)
+                results[v][:] = mdata[self.var(v)][:, None, None]
             else:
-                results[v] = ires[:, vrs.index(v)]
+                results[v] = ires[vrs.index(v)]
 
         return results
 

foxes/input/states/scan_ws.py

@@ -129,7 +129,7 @@ class ScanWS(States):
         """
         return np.full((self.N, algo.n_turbines), 1.0 / self.N, dtype=FC.DTYPE)
 
-    def calculate(self, algo, mdata, fdata, pdata):
+    def calculate(self, algo, mdata, fdata, tdata):
         """ "
         The main model calculation.
 
@@ -140,33 +140,29 @@ class ScanWS(States):
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
+        mdata: foxes.core.MData
             The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
-        pdata: foxes.core.Data
-            The point data
+        tdata: foxes.core.TData
+            The target point data
 
         Returns
         -------
         results: dict
             The resulting data, keys: output variable str.
-            Values: numpy.ndarray with shape (n_states, n_points)
+            Values: numpy.ndarray with shape
+            (n_states, n_targets, n_tpoints)
 
         """
-        pdata[FV.WS][:] = mdata[self.WS][:, None]
+        tdata[FV.WS] = np.zeros_like(tdata[FC.TARGETS][..., 0])
+        tdata[FV.WS][:] = mdata[self.WS][:, None, None]
 
         if self.wd is not None:
-            pdata[FV.WD] = np.full(
-                (pdata.n_states, pdata.n_points), self.wd, dtype=FC.DTYPE
-            )
+            tdata[FV.WD] = np.full_like(tdata[FV.WS], self.wd)
         if self.ti is not None:
-            pdata[FV.TI] = np.full(
-                (pdata.n_states, pdata.n_points), self.ti, dtype=FC.DTYPE
-            )
+            tdata[FV.TI] = np.full_like(tdata[FV.WS], self.ti)
         if self.rho is not None:
-            pdata[FV.RHO] = np.full(
-                (pdata.n_states, pdata.n_points), self.rho, dtype=FC.DTYPE
-            )
+            tdata[FV.RHO] = np.full_like(tdata[FV.WS], self.rho)
 
-        return {v: pdata[v] for v in self.output_point_vars(algo)}
+        return {v: tdata[v] for v in self.output_point_vars(algo)}

foxes/input/states/single.py

@@ -165,7 +165,7 @@ class SingleStateStates(States):
         """
         return np.ones((1, algo.n_turbines), dtype=FC.DTYPE)
 
-    def calculate(self, algo, mdata, fdata, pdata):
+    def calculate(self, algo, mdata, fdata, tdata):
         """ "
         The main model calculation.
 
@@ -176,44 +176,52 @@ class SingleStateStates(States):
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
+        mdata: foxes.core.MData
             The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
-        pdata: foxes.core.Data
-            The point data
+        tdata: foxes.core.TData
+            The target point data
 
         Returns
         -------
         results: dict
             The resulting data, keys: output variable str.
-            Values: numpy.ndarray with shape (n_states, n_points)
+            Values: numpy.ndarray with shape
+            (n_states, n_targets, n_tpoints)
 
         """
-
         if self.ws is not None:
-            pdata[FV.WS] = np.full(
-                (pdata.n_states, pdata.n_points), self.ws, dtype=FC.DTYPE
+            tdata[FV.WS] = np.full(
+                (tdata.n_states, tdata.n_targets, tdata.n_tpoints),
+                self.ws,
+                dtype=FC.DTYPE,
             )
         if self.wd is not None:
-            pdata[FV.WD] = np.full(
-                (pdata.n_states, pdata.n_points), self.wd, dtype=FC.DTYPE
+            tdata[FV.WD] = np.full(
+                (tdata.n_states, tdata.n_targets, tdata.n_tpoints),
+                self.wd,
+                dtype=FC.DTYPE,
             )
         if self.ti is not None:
-            pdata[FV.TI] = np.full(
-                (pdata.n_states, pdata.n_points), self.ti, dtype=FC.DTYPE
+            tdata[FV.TI] = np.full(
+                (tdata.n_states, tdata.n_targets, tdata.n_tpoints),
+                self.ti,
+                dtype=FC.DTYPE,
             )
         if self.rho is not None:
-            pdata[FV.RHO] = np.full(
-                (pdata.n_states, pdata.n_points), self.rho, dtype=FC.DTYPE
+            tdata[FV.RHO] = np.full(
+                (tdata.n_states, tdata.n_targets, tdata.n_tpoints),
+                self.rho,
+                dtype=FC.DTYPE,
             )
 
         if len(self._profiles):
-            z = pdata[FC.POINTS][:, :, 2]
+            z = tdata[FC.TARGETS][..., 2]
             for k, v in self.profdata.items():
-                pdata[k] = v
+                tdata[k] = v
             for v, p in self._profiles.items():
-                pres = p.calculate(pdata, z)
-                pdata[v] = pres
+                pres = p.calculate(tdata, z)
+                tdata[v] = pres
 
-        return {v: pdata[v] for v in self.output_point_vars(algo)}
+        return {v: tdata[v] for v in self.output_point_vars(algo)}

foxes/input/states/states_table.py

@@ -309,7 +309,7 @@ class StatesTable(States):
         """
         return self._weights
 
-    def calculate(self, algo, mdata, fdata, pdata):
+    def calculate(self, algo, mdata, fdata, tdata):
         """ "
         The main model calculation.
 
@@ -320,37 +320,41 @@ class StatesTable(States):
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
+        mdata: foxes.core.MData
             The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
-        pdata: foxes.core.Data
-            The point data
+        tdata: foxes.core.TData
+            The target point data
 
         Returns
         -------
         results: dict
             The resulting data, keys: output variable str.
-            Values: numpy.ndarray with shape (n_states, n_points)
+            Values: numpy.ndarray with shape
+            (n_states, n_targets, n_tpoints)
 
         """
-        z = pdata[FC.POINTS][:, :, 2]
-
         for i, v in enumerate(self._tvars):
-            if v in pdata:
-                pdata[v][:] = mdata[self.DATA][:, i, None]
+            if v in tdata:
+                tdata[v][:] = mdata[self.DATA][:, i, None, None]
             else:
-                pdata[v] = mdata[self.DATA][:, i, None]
-                pdata.dims[v] = (FC.STATE, FC.POINT)
+                tdata[v] = np.zeros(
+                    (tdata.n_states, tdata.n_targets, tdata.n_tpoints), dtype=FC.DTYPE
+                )
+                tdata[v][:] = mdata[self.DATA][:, i, None, None]
+                tdata.dims[v] = (FC.STATE, FC.TARGET, FC.TPOINT)
 
         for v, f in self.fixed_vars.items():
-            pdata[v] = np.full((pdata.n_states, pdata.n_points), f, dtype=FC.DTYPE)
+            tdata[v] = np.full(
+                (tdata.n_states, tdata.n_targets, tdata.n_tpoints), f, dtype=FC.DTYPE
+            )
 
+        z = tdata[FC.TARGETS][..., 2]
         for v, p in self._profiles.items():
-            pres = p.calculate(pdata, z)
-            pdata[v] = pres
+            tdata[v] = p.calculate(tdata, z)
 
-        return {v: pdata[v] for v in self.output_point_vars(algo)}
+        return {v: tdata[v] for v in self.output_point_vars(algo)}
 
     def finalize(self, algo, verbosity=0):
         """
@@ -472,8 +476,8 @@ class TabStates(StatesTable):
             )
             ws0 = 0.5 * (ws0[:-1] + ws0[1:])
 
-            n_ws = self._tab_data.dims["ws"]
-            n_wd = self._tab_data.dims["wd"]
+            n_ws = self._tab_data.sizes["ws"]
+            n_wd = self._tab_data.sizes["wd"]
             ws = np.zeros((n_ws, n_wd), dtype=FC.DTYPE)
             wd = np.zeros((n_ws, n_wd), dtype=FC.DTYPE)
             ws[:] = ws0[:, None]

foxes/models/axial_induction_models/betz.py

@@ -17,7 +17,7 @@ class BetzAxialInduction(AxialInductionModel):
 
     """
 
-    def __init__(self, ct_max=1):
+    def __init__(self, ct_max=0.99999):
         """
         Constructor.
 

foxes/models/farm_models/turbine2farm.py

@@ -75,9 +75,9 @@ class Turbine2FarmModel(FarmModel):
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
+        mdata: foxes.core.MData
             The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
         **parameters: dict, optional
             Init parameters forwarded to the turbine model

foxes/models/model_book.py

@@ -14,6 +14,7 @@ from foxes.core import (
     WakeSuperposition,
     WakeModel,
     AxialInductionModel,
+    TurbineInductionModel,
 )
 
 
@@ -93,16 +94,16 @@ class ModelBook:
         self.turbine_types = Dict(name="turbine_types")
         self.turbine_types["null_type"] = fm.turbine_types.NullType()
         self.turbine_types["NREL5MW"] = fm.turbine_types.PCtFile(
-            "NREL-5MW-D126-H90.csv"
+            "NREL-5MW-D126-H90.csv", rho=1.225
         )
         self.turbine_types["DTU10MW"] = fm.turbine_types.PCtFile(
-            "DTU-10MW-D178d3-H119.csv"
+            "DTU-10MW-D178d3-H119.csv", rho=1.225
         )
         self.turbine_types["IEA15MW"] = fm.turbine_types.PCtFile(
-            "IEA-15MW-D240-H150.csv"
+            "IEA-15MW-D240-H150.csv", rho=1.225
         )
         self.turbine_types["IWT7.5MW"] = fm.turbine_types.PCtFile(
-            "IWT-7d5MW-D164-H100.csv"
+            "IWT-7d5MW-D164-H100.csv", rho=1.225
         )
         if Pct_file is not None:
             self.turbine_types["Pct"] = fm.turbine_types.PCtFile(Pct_file)
@@ -148,24 +149,21 @@ class ModelBook:
             name="partial_wakes",
             rotor_points=fm.partial_wakes.RotorPoints(),
             top_hat=fm.partial_wakes.PartialTopHat(),
-            distsliced=fm.partial_wakes.PartialDistSlicedWake(),
-            auto=fm.partial_wakes.Mapped(),
+            centre=fm.partial_wakes.PartialCentre(),
         )
         nlst = list(range(2, 11)) + [20]
         for n in nlst:
             self.partial_wakes[f"axiwake{n}"] = fm.partial_wakes.PartialAxiwake(n)
         for n in nlist:
-            self.partial_wakes[f"distsliced{n**2}"] = (
-                fm.partial_wakes.PartialDistSlicedWake(n)
-            )
-        for n in nlist:
-            self.partial_wakes[f"grid{n**2}"] = fm.partial_wakes.PartialGrid(n)
+            self.partial_wakes[f"grid{n**2}"] = fm.partial_wakes.PartialGrid(n=n)
 
         self.wake_frames = Dict(
             name="wake_frames",
             rotor_wd=fm.wake_frames.RotorWD(var_wd=FV.WD),
             rotor_wd_farmo=fm.wake_frames.FarmOrder(),
             yawed=fm.wake_frames.YawedWakes(),
+            yawed_k002=fm.wake_frames.YawedWakes(k=0.02),
+            yawed_k004=fm.wake_frames.YawedWakes(k=0.04),
         )
         stps = [1.0, 5.0, 10.0, 50.0, 100.0, 500.0]
         for s in stps:
@@ -246,7 +244,7 @@ class ModelBook:
             "linear_amb",
             "linear_amb_lim",
             "quadratic",
-            "wquadratic_lim",
+            "quadratic_lim",
             "quadratic_amb",
             "quadratic_amb_lim",
             "cubic",
@@ -416,13 +414,12 @@ class ModelBook:
             )
 
         self.wake_models[f"RHB"] = fm.wake_models.induction.RankineHalfBody()
+        self.wake_models[f"Rathmann"] = fm.wake_models.induction.Rathmann()
         self.wake_models[f"SelfSimilar"] = fm.wake_models.induction.SelfSimilar()
         self.wake_models[f"SelfSimilar2020"] = (
             fm.wake_models.induction.SelfSimilar2020()
         )
 
-        self.wake_models[f"Rathmann"] = fm.wake_models.induction.Rathmann()
-
         self.sources = Dict(
             name="sources",
             point_models=self.point_models,
@@ -518,6 +515,35 @@ class ModelBook:
             self.sources[model_type][name] = bclass.new(class_name, *args, **kwargs)
         return self.sources[model_type][name]
 
+    def default_partial_wakes(self, wake_model):
+        """
+        Gets a default partial wakes model name
+        for a given wake model
+
+        Parameters
+        ----------
+        wake_model: foxes.core.WakeModel
+            The wake model
+
+        Returns
+        -------
+        pwake: str
+            The partial wake model name
+
+        """
+        if isinstance(wake_model, TurbineInductionModel):
+            return "grid9"
+        elif isinstance(wake_model, fm.wake_models.TopHatWakeModel):
+            return "top_hat"
+        elif isinstance(wake_model, fm.wake_models.AxisymmetricWakeModel):
+            return "axiwake6"
+        elif isinstance(wake_model, fm.wake_models.DistSlicedWakeModel):
+            return "grid9"
+        else:
+            raise TypeError(
+                f"No default partial wakes model defined for wake model type '{type(wake_model).__name__}'"
+            )
+
     def finalize(self, algo, verbosity=0):
         """
         Finalizes the model.

foxes/models/partial_wakes/__init__.py

@@ -2,9 +2,9 @@
 Partial wake models.
 """
 
+from .centre import PartialCentre
 from .rotor_points import RotorPoints
 from .top_hat import PartialTopHat
 from .axiwake import PartialAxiwake
-from .distsliced import PartialDistSlicedWake
+from .segregated import PartialSegregated
 from .grid import PartialGrid
-from .mapped import Mapped