foxes 1.2.4__py3-none-any.whl → 1.3__py3-none-any.whl

foxes/input/states/wrg_states.py

@@ -0,0 +1,301 @@
+import numpy as np
+from scipy.interpolate import interpn
+
+from foxes.core.states import States
+from foxes.config import config, get_input_path
+from foxes.utils.wrg_utils import ReaderWRG
+from foxes.data import STATES
+import foxes.variables as FV
+import foxes.constants as FC
+
+
+class WRGStates(States):
+    """
+    Ambient states based on WRG data
+
+    Attributes
+    ----------
+    wrg_fname: str
+        Name of the WRG file
+    ws_bins: numpy.ndarray
+        The wind speed bins, including
+        lower and upper bounds, shape: (n_ws_bins+1,)
+    fixed_vars: dict
+        Fixed uniform variable values, instead of
+        reading from data
+    bounds_extra_space: float or str
+        The extra space, either float in m,
+        or str for units of D, e.g. '2.5D'
+    interpn_pars: dict
+        Additional parameters for scipy.interpolate.interpn
+
+    :group: input.states
+
+    """
+
+    def __init__(
+        self,
+        wrg_fname,
+        ws_bins,
+        fixed_vars={},
+        bounds_extra_space="1D",
+        **interpn_pars,
+    ):
+        """
+        Constructor
+
+        Parameters
+        ----------
+        wrg_fname: str
+            Name of the WRG file
+        ws_bins: list of float
+            The wind speed bins, including
+            lower and upper bounds
+        fixed_vars: dict
+            Fixed uniform variable values, instead of
+            reading from data
+        bounds_extra_space: float or str, optional
+            The extra space, either float in m,
+            or str for units of D, e.g. '2.5D'
+        interpn_pars: dict, optional
+            Additional parameters for scipy.interpolate.interpn
+
+        """
+        super().__init__()
+        self.wrg_fname = wrg_fname
+        self.ws_bins = np.asarray(ws_bins)
+        self.fixed_vars = fixed_vars
+        self.bounds_extra_space = bounds_extra_space
+        self.interpn_pars = interpn_pars
+
+    def load_data(self, algo, verbosity=0):
+        """
+        Load and/or create all model data that is subject to chunking.
+
+        Such data should not be stored under self, for memory reasons. The
+        data returned here will automatically be chunked and then provided
+        as part of the mdata object during calculations.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        verbosity: int
+            The verbosity level, 0 = silent
+
+        Returns
+        -------
+        idata: dict
+            The dict has exactly two entries: `data_vars`,
+            a dict with entries `name_str -> (dim_tuple, data_ndarray)`;
+            and `coords`, a dict with entries `dim_name_str -> dim_array`
+
+        """
+        # read wrg file:
+        fpath = get_input_path(self.wrg_fname)
+        if not fpath.is_file():
+            if verbosity > 0:
+                print(
+                    f"States '{self.name}': Reading static data '{self.wrg_fname}' from context '{STATES}'"
+                )
+            fpath = algo.dbook.get_file_path(STATES, self.wrg_fname, check_raw=False)
+            if verbosity > 0:
+                print(f"Path: {fpath}")
+        elif verbosity:
+            print(f"States '{self.name}': Reading file {fpath}")
+        wrg = ReaderWRG(fpath)
+        p0 = np.array([wrg.x0, wrg.y0], dtype=config.dtype_double)
+        nx = wrg.nx
+        ny = wrg.ny
+        ns = wrg.n_sectors
+        res = wrg.resolution
+        p1 = p0 + np.array([nx * res, ny * res])
+        if verbosity > 0:
+            print(f"States '{self.name}': Data bounds {p0} - {p1}")
+
+        # find bounds:
+        if self.bounds_extra_space is not None:
+            xy_min, xy_max = algo.farm.get_xy_bounds(
+                extra_space=self.bounds_extra_space, algo=algo
+            )
+            if verbosity > 0:
+                print(f"States '{self.name}': Farm bounds {xy_min} - {xy_max}")
+            ij_min = np.asarray((xy_min - p0) / res, dtype=config.dtype_int)
+            ij_max = np.asarray((xy_max - p0) / res, dtype=config.dtype_int) + 1
+            sx = slice(ij_min[0], ij_max[0])
+            sy = slice(ij_min[1], ij_max[1])
+        else:
+            sx = np.s_[:]
+            sy = np.s_[:]
+        self._x = p0[0] + np.arange(nx) * res
+        self._x = self._x[sx]
+        self._y = p0[1] + np.arange(ny) * res
+        self._y = self._y[sy]
+        if len(self._x) < 2 or len(self._y) < 2:
+            raise ValueError(f"No overlap between data bounds and farm bounds")
+        p0[0] = np.min(self._x)
+        p0[1] = np.min(self._y)
+        p1[0] = np.max(self._x)
+        p1[1] = np.max(self._y)
+        if verbosity > 0:
+            print(f"States '{self.name}':  New bounds {p0} - {p1}")
+
+        # store data:
+        A = []
+        k = []
+        f = []
+        for s in range(ns):
+            A.append(wrg.data[f"As_{s}"].to_numpy().reshape(ny, nx)[sy, sx])
+            k.append(wrg.data[f"Ks_{s}"].to_numpy().reshape(ny, nx)[sy, sx])
+            f.append(wrg.data[f"fs_{s}"].to_numpy().reshape(ny, nx)[sy, sx])
+        del wrg
+        A = np.stack(A, axis=0).T
+        k = np.stack(k, axis=0).T
+        f = np.stack(f, axis=0).T
+        self._data = np.stack([A, k, f], axis=-1)  # (x, y, wd, AKfs)
+
+        # store ws and wd:
+        self.VARS = self.var("VARS")
+        self.DATA = self.var("DATA")
+        self._wds = np.arange(0.0, 360.0, 360 / ns)
+        self._wsd = self.ws_bins[1:] - self.ws_bins[:-1]
+        self._wss = 0.5 * (self.ws_bins[:-1] + self.ws_bins[1:])
+        self._N = len(self._wss) * ns
+        data = np.zeros((len(self._wss), ns, 3), dtype=config.dtype_double)
+        data[..., 0] = self._wss[:, None]
+        data[..., 1] = self._wds[None, :]
+        data[..., 2] = self._wsd[:, None]
+        data = data.reshape(self._N, 3)
+        idata = super().load_data(algo, verbosity)
+        idata["coords"][self.VARS] = ["ws", "wd", "dws"]
+        idata["data_vars"][self.DATA] = ((FC.STATE, self.VARS), data)
+
+        return idata
+
+    def size(self):
+        """
+        The total number of states.
+
+        Returns
+        -------
+        int:
+            The total number of states
+
+        """
+        return self._N
+
+    def output_point_vars(self, algo):
+        """
+        The variables which are being modified by the model.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+
+        Returns
+        -------
+        output_vars: list of str
+            The output variable names
+
+        """
+        ovars = set([FV.WS, FV.WD])
+        ovars.update(self.fixed_vars.keys())
+        return list(ovars)
+
+    def calculate(self, algo, mdata, fdata, tdata):
+        """
+        The main model calculation.
+
+        This function is executed on a single chunk of data,
+        all computations should be based on numpy arrays.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        mdata: foxes.core.MData
+            The model data
+        fdata: foxes.core.FData
+            The farm 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_targets, n_tpoints)
+
+        """
+
+        # prepare:
+        n_states = tdata.n_states
+        n_targets = tdata.n_targets
+        n_tpoints = tdata.n_tpoints
+        n_pts = n_states * n_targets * n_tpoints
+        points = tdata[FC.TARGETS]
+        ws = mdata[self.DATA][:, 0]
+        wd = mdata[self.DATA][:, 1]
+        wsd = mdata[self.DATA][:, 2]
+
+        out = {}
+
+        out[FV.WS] = tdata[FV.WS]
+        out[FV.WS][:] = ws[:, None, None]
+
+        out[FV.WD] = tdata[FV.WD]
+        out[FV.WD][:] = wd[:, None, None]
+
+        for v, d in self.fixed_vars.items():
+            out[v] = tdata[v]
+            out[v][:] = d
+
+        # interpolate A, k, f from x, y, wd
+        z = points[..., 2].copy()
+        points[..., 2] = wd[:, None, None]
+        pts = points.reshape(n_pts, 3)
+        gvars = (self._x, self._y, self._wds)
+        try:
+            ipars = dict(bounds_error=True, fill_value=None)
+            ipars.update(self.interpn_pars)
+            data = interpn(gvars, self._data, pts, **ipars).reshape(
+                n_states, n_targets, n_tpoints, 3
+            )
+        except ValueError as e:
+            print(f"\nStates '{self.name}': Interpolation error")
+            print("INPUT VARS: (x, y, wd)")
+            print(
+                "DATA BOUNDS:",
+                [float(np.min(d)) for d in gvars],
+                [float(np.max(d)) for d in gvars],
+            )
+            print(
+                "EVAL BOUNDS:",
+                [float(np.min(p)) for p in pts.T],
+                [float(np.max(p)) for p in pts.T],
+            )
+            print(
+                "\nMaybe you want to try the option 'bounds_error=False'? This will extrapolate the data.\n"
+            )
+            raise e
+
+        A = data[..., 0]
+        k = data[..., 1]
+        f = data[..., 2]
+        points[..., 2] = z
+        del data, gvars, pts, z, wd
+
+        tdata.add(
+            FV.WEIGHT,
+            f,
+            dims=(FC.STATE, FC.TARGET, FC.TPOINT),
+        )
+
+        wsA = out[FV.WS] / A
+        tdata[FV.WEIGHT] *= wsd[:, None, None] * (
+            k / A * wsA ** (k - 1) * np.exp(-(wsA**k))
+        )
+
+        return out

foxes/models/partial_wakes/rotor_points.py

@@ -91,8 +91,14 @@ class RotorPoints(PartialWakesModel):
             of shape (n_states, n_rotor_points)
 
         """
-        ares = {v: d[:, downwind_index, None] for v, d in amb_res.items()}
-        wdel = {v: d[:, downwind_index, None].copy() for v, d in wake_deltas.items()}
+        ares = {
+            v: d[:, downwind_index, None] if d.shape[1] > 1 else d[:, 0, None]
+            for v, d in amb_res.items()
+        }
+        wdel = {
+            v: d[:, downwind_index, None].copy() if d.shape[1] > 1 else d[:, 0, None]
+            for v, d in wake_deltas.items()
+        }
         wmodel.finalize_wake_deltas(algo, mdata, fdata, ares, wdel)
 
         return {v: d[:, 0] for v, d in wdel.items()}

foxes/models/partial_wakes/segregated.py

@@ -140,16 +140,21 @@ class PartialSegregated(PartialWakesModel):
         wdel = {v: d[:, downwind_index, None].copy() for v, d in wake_deltas.items()}
 
         if n_rotor_points == tdata.n_tpoints:
-            ares = {v: d[:, downwind_index, None] for v, d in amb_res.items()}
+            ares = {
+                v: d[:, downwind_index, None] if d.shape[1] > 1 else d[:, 0, None]
+                for v, d in amb_res.items()
+            }
         else:
             ares = {}
             for v, d in amb_res.items():
                 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
-                ]
+                ares[v][:] = np.einsum(
+                    "sp,p->s",
+                    d[:, downwind_index] if d.shape[1] > 1 else d[:, 0],
+                    rpoint_weights,
+                )[:, None, None]
 
         wmodel.finalize_wake_deltas(algo, mdata, fdata, ares, wdel)
 

foxes/models/rotor_models/centre.py

@@ -89,7 +89,7 @@ class CentreRotor(RotorModel):
         mdata,
         fdata,
         rpoint_results,
-        weights,
+        rpoint_weights,
         downwind_index=None,
         copy_to_ambient=False,
     ):
@@ -124,9 +124,9 @@ class CentreRotor(RotorModel):
             variables after calculation
 
         """
-        if len(weights) > 1:
+        if len(rpoint_weights) > 1:
             return super().eval_rpoint_results(
-                algo, mdata, fdata, rpoint_results, weights, downwind_index
+                algo, mdata, fdata, rpoint_results, rpoint_weights, downwind_index
             )
 
         n_states = mdata.n_states
@@ -192,7 +192,9 @@ class CentreRotor(RotorModel):
         del uvp
 
         for v in self.calc_vars:
-            if v not in vdone:
+            if v not in vdone and (
+                fdata[v].shape[1] > 1 or downwind_index is None or downwind_index == 0
+            ):
                 res = rpoint_results[v][:, :, 0]
                 self._set_res(fdata, v, res, downwind_index)
                 del res

foxes/models/wake_frames/seq_dynamic_wakes.py

@@ -186,12 +186,15 @@ class SeqDynamicWakes(FarmOrder):
 
             # compute wind vectors at wake traces:
             # TODO: dz from U_z is missing here
-            hpdata = TData.from_points(points=self._traces_p[None, :N, downwind_index])
+            svrs = algo.states.output_point_vars(algo)
+            hpdata = TData.from_points(
+                points=self._traces_p[None, :N, downwind_index], variables=svrs
+            )
             res = algo.states.calculate(algo, mdata, fdata, hpdata)
             self._traces_v[:N, downwind_index, :2] = wd2uv(
                 res[FV.WD][0, :, 0], res[FV.WS][0, :, 0]
             )
-            del hpdata, res
+            del hpdata, res, svrs
 
         # find nearest wake point:
         dists = cdist(points[0], self._traces_p[:N, downwind_index])

foxes/models/wake_frames/timelines.py

@@ -105,6 +105,7 @@ class Timelines(WakeFrame):
 
         # calculate all heights:
         self.timelines_data = {"dxy": (("height", FC.STATE, "dir"), [])}
+        weight_data = None
         for h in heights:
 
             if verbosity > 0:
@@ -118,6 +119,13 @@ class Timelines(WakeFrame):
             )
 
             res = states.calculate(algo, mdata, fdata, tdata)
+
+            if weight_data is None:
+                weight_data = ((FC.STATE,), tdata[FV.WEIGHT][:, 0, 0])
+            elif not np.all(tdata[FV.WEIGHT] == weight_data[1]):
+                raise AssertionError(
+                    f"States '{self.name}': weight data mismatch between heights"
+                )
             del tdata
 
             uv = wd2uv(res[FV.WD], res[FV.WS])[:, 0, 0, :2]
@@ -163,6 +171,8 @@ class Timelines(WakeFrame):
             },
         )
 
+        return weight_data
+
     def initialize(self, algo, verbosity=0):
         """
         Initializes the model.

foxes/models/wake_models/induction/vortex_sheet.py

@@ -183,12 +183,11 @@ class VortexSheet(TurbineInductionModel):
         sp_sel = (ct > 1e-8) & (x <= 0)
         ct_sel = ct[sp_sel]
         r_sph_sel = r_sph[sp_sel]
-        D_sel = D[sp_sel]
+        R_sel = D[sp_sel] / 2
+        xi = r_sph_sel / R_sel
 
         if np.any(sp_sel):
-            blockage = self.induction.ct2a(ct_sel) * (
-                (1 + 2 * r_sph_sel / D_sel) * (1 + (2 * r_sph_sel / D_sel) ** 2)
-            ) ** (-0.5)
+            blockage = self.induction.ct2a(ct_sel) * (1 + -xi / np.sqrt(1 + xi**2))
 
             self._superp.add_wake(
                 algo,
@@ -208,12 +207,10 @@ class VortexSheet(TurbineInductionModel):
             )  # mirror in rotor plane and inverse blockage, but not directly behind rotor
             ct_sel = ct[sp_sel]
             r_sph_sel = r_sph[sp_sel]
-            D_sel = D[sp_sel]
+            R_sel = D[sp_sel] / 2
+            xi = r_sph_sel / R_sel
             if np.any(sp_sel):
-                blockage = self.induction.ct2a(ct_sel) * (
-                    (1 + 2 * r_sph_sel / D_sel) * (1 + (2 * r_sph_sel / D_sel) ** 2)
-                ) ** (-0.5)
-
+                blockage = self.induction.ct2a(ct_sel) * (1 + -xi / np.sqrt(1 + xi**2))
                 self._superp.add_wake(
                     algo,
                     mdata,

foxes/output/farm_layout.py

@@ -5,8 +5,9 @@ import matplotlib.pyplot as plt
 from mpl_toolkits.axes_grid1 import make_axes_locatable
 
 from foxes.config import config
-import foxes.variables as FV
 from foxes.output.output import Output
+import foxes.variables as FV
+import foxes.constants as FC
 
 
 class FarmLayoutOutput(Output):
@@ -229,9 +230,16 @@ class FarmLayoutOutput(Output):
                 if self.fres is None:
                     raise ValueError(f"Missing farm_results for color_by '{color_by}'")
                 if color_by[:5] == "mean_":
-                    kw["c"] = np.einsum(
-                        "st,st->t", self.fres[color_by[5:]], self.fres[FV.WEIGHT]
-                    )
+                    weights = self.fres[FV.WEIGHT]
+                    if weights.dims == (FC.STATE,):
+                        wx = "s"
+                    elif weights.dims == (FC.STATE, FC.TURBINE):
+                        wx = "st"
+                    else:
+                        raise ValueError(
+                            f"Unsupported dimensions for '{FV.WEIGHT}': Expecting '{(FC.STATE,)}' or '{(FC.STATE, FC.TURBINE)}', got '{weights.dims}'"
+                        )
+                    kw["c"] = np.einsum(f"st,{wx}->t", self.fres[color_by[5:]], weights)
                 elif color_by[:4] == "sum_":
                     kw["c"] = np.sum(self.fres[color_by[4:]], axis=0)
                 elif color_by[:4] == "min_":

foxes/output/farm_results_eval.py

@@ -76,22 +76,46 @@ class FarmResultsEval(Output):
                 nas = np.zeros_like(fields[-1], dtype=bool)
             nas = nas | np.isnan(fields[-1])
 
-        inds = ["st" for v in fields] + ["st"]
-        expr = ",".join(inds) + "->" + rhs
+        inds = ["st" for __ in fields]
+        if self.results[FV.WEIGHT].dims == (FC.STATE,):
+            inds += ["s"]
+
+            if np.any(nas):
+                sel = ~np.any(nas, axis=1)
+                fields = [f[sel] for f in fields]
+
+                weights0 = self.results[FV.WEIGHT].to_numpy()
+                w0 = np.sum(weights0)
+                weights = weights0[sel]
+                w1 = np.sum(weights)
+                weights *= w0 / w1
+                fields.append(weights)
+
+            else:
+                fields.append(self.results[FV.WEIGHT].to_numpy())
+
+        elif self.results[FV.WEIGHT].dims == (FC.STATE, FC.TURBINE):
+            inds += ["st"]
 
-        if np.any(nas):
-            sel = ~np.any(nas, axis=1)
-            fields = [f[sel] for f in fields]
+            if np.any(nas):
+                sel = ~np.any(nas, axis=1)
+                fields = [f[sel] for f in fields]
 
-            weights0 = self.results[FV.WEIGHT].to_numpy()
-            w0 = np.sum(weights0, axis=0)[None, :]
-            weights = weights0[sel]
-            w1 = np.sum(weights, axis=0)[None, :]
-            weights *= w0 / w1
-            fields.append(weights)
+                weights0 = self.results[FV.WEIGHT].to_numpy()
+                w0 = np.sum(weights0, axis=0)[None, :]
+                weights = weights0[sel]
+                w1 = np.sum(weights, axis=0)[None, :]
+                weights *= w0 / w1
+                fields.append(weights)
+
+            else:
+                fields.append(self.results[FV.WEIGHT].to_numpy())
 
         else:
-            fields.append(self.results[FV.WEIGHT].to_numpy())
+            raise ValueError(
+                f"Expecting '{FV.WEIGHT}' variable with dimensions {(FC.STATE,)} or {(FC.STATE, FC.TURBINE)}, got {self.results[FV.WEIGHT].dims}"
+            )
+        expr = ",".join(inds) + "->" + rhs
 
         return np.einsum(expr, *fields)
 

foxes/output/rose_plot.py

@@ -151,9 +151,19 @@ class RosePlotOutput(Output):
             The plot data
 
         """
+        if self.results[FV.WEIGHT].dims == (FC.STATE,):
+            w = self.results[FV.WEIGHT].to_numpy()
+        elif self.results[FV.WEIGHT].dims == (FC.STATE, FC.TURBINE):
+            w = self.results[FV.WEIGHT].to_numpy()[:, turbine]
+        elif self.results[FV.WEIGHT].dims == (FC.STATE, FC.POINT):
+            w = self.results[FV.WEIGHT].to_numpy()[:, point]
+        else:
+            raise ValueError(
+                f"Wrong dimensions for '{FV.WEIGHT}'. Expecting {(FC.STATE,)}, {(FC.STATE, FC.TURBINE)} or {(FC.STATE, FC.POINT)}, got {self.results[FV.WEIGHT].dims}"
+            )
+
         if add_inf:
             ws_bins = list(ws_bins) + [np.inf]
-        w = self.results[FV.WEIGHT].to_numpy()[:, turbine]
         t = turbine if self._rtype == FC.TURBINE else point
         ws = self.results[ws_var].to_numpy()[:, t]
         wd = self.results[wd_var].to_numpy()[:, t].copy()
@@ -449,8 +459,16 @@ class WindRoseBinPlot(Output):
             The plot data
 
         """
+        if self.farm_results[FV.WEIGHT].dims == (FC.STATE,):
+            w = self.farm_results[FV.WEIGHT].to_numpy()
+        elif self.farm_results[FV.WEIGHT].dims == (FC.STATE, FC.TURBINE):
+            w = self.farm_results[FV.WEIGHT].to_numpy()[:, turbine]
+        else:
+            raise ValueError(
+                f"Wrong dimensions for '{FV.WEIGHT}'. Expecting {(FC.STATE,)} or {(FC.STATE, FC.TURBINE)}, got {self.farm_results[FV.WEIGHT].dims}"
+            )
+
         var = self.farm_results[variable].to_numpy()[:, turbine]
-        w = self.farm_results[FV.WEIGHT].to_numpy()[:, turbine]
         ws = self.farm_results[ws_var].to_numpy()[:, turbine]
         wd = self.farm_results[wd_var].to_numpy()[:, turbine].copy()
         wd_delta = 360 / wd_sectors