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

foxes/models/wake_frames/streamlines.py

@@ -16,8 +16,6 @@ class Streamlines2D(WakeFrame):
     ----------
     step: float
         The streamline step size in m
-    max_length: float
-        The maximal streamline length
     cl_ipars: dict
         Interpolation parameters for centre line
         point interpolation
@@ -26,7 +24,7 @@ class Streamlines2D(WakeFrame):
 
     """
 
-    def __init__(self, step, max_length=1e4, cl_ipars={}):
+    def __init__(self, step, max_length_km=20, cl_ipars={}, **kwargs):
         """
         Constructor.
 
@@ -34,16 +32,17 @@ class Streamlines2D(WakeFrame):
         ----------
         step: float
             The streamline step size in m
-        max_length: float
-            The maximal streamline length
+        max_length_km: float
+            The maximal streamline length in km
         cl_ipars: dict
             Interpolation parameters for centre line
             point interpolation
+        kwargs: dict, optional
+            Additional parameters for the base class
 
         """
-        super().__init__()
+        super().__init__(max_length_km=max_length_km, **kwargs)
         self.step = step
-        self.max_length = max_length
         self.cl_ipars = cl_ipars
 
         self.DATA = self.var("DATA")
@@ -51,7 +50,9 @@ class Streamlines2D(WakeFrame):
         self.SDAT = self.var("SDAT")
 
     def __repr__(self):
-        return f"{type(self).__name__}(step={self.step})"
+        return (
+            f"{type(self).__name__}(step={self.step}, max_length={self.max_length_km})"
+        )
 
     def _calc_streamlines(self, algo, mdata, fdata):
         """
@@ -60,7 +61,7 @@ class Streamlines2D(WakeFrame):
         # prepare:
         n_states = mdata.n_states
         n_turbines = mdata.n_turbines
-        N = int(self.max_length / self.step)
+        N = int(self.max_length_km * 1e3 / self.step)
 
         # calc data: x, y, z, wd
         data = np.zeros((n_states, n_turbines, N, 4), dtype=FC.DTYPE)
@@ -134,7 +135,6 @@ class Streamlines2D(WakeFrame):
         Helper function, calculates streamline coordinates
         for given points and given turbine
         """
-
         # prepare:
         n_states, n_targets, n_tpoints = targets.shape[:3]
         n_points = n_targets * n_tpoints
@@ -151,13 +151,16 @@ class Streamlines2D(WakeFrame):
         del dists, selp
 
         # calculate coordinates:
-        coos = np.zeros((n_states, n_points, 3), dtype=FC.DTYPE)
-        nx = wd2uv(data[:, :, 3])
-        ny = np.stack([-nx[:, :, 1], nx[:, :, 0]], axis=2)
-        delta = points[:, :, :2] - data[:, :, :2]
-        coos[:, :, 0] = slen + np.einsum("spd,spd->sp", delta, nx)
-        coos[:, :, 1] = np.einsum("spd,spd->sp", delta, ny)
+        coos = np.full((n_states, n_points, 3), np.nan, dtype=FC.DTYPE)
         coos[:, :, 2] = points[:, :, 2] - data[:, :, 2]
+        delta = points[:, :, :2] - data[:, :, :2]
+        nx = wd2uv(data[:, :, 3])
+        projx = np.einsum("spd,spd->sp", delta, nx)
+        sel = (projx > -self.step) & (projx < self.step)
+        if np.any(sel):
+            ny = np.stack([-nx[:, :, 1], nx[:, :, 0]], axis=2)
+            coos[sel, 0] = slen[sel] + projx[sel]
+            coos[sel, 1] = np.einsum("spd,spd->sp", delta, ny)[sel]
 
         return coos.reshape(n_states, n_targets, n_tpoints, 3)
 
@@ -262,10 +265,6 @@ class Streamlines2D(WakeFrame):
             The centreline points, shape: (n_states, n_points, 3)
 
         """
-        # calculate long enough streamlines:
-        xmax = np.max(x)
-        self._ensure_min_length(algo, mdata, fdata, xmax)
-
         # get streamline points:
         n_states, n_points = x.shape
         data = self.get_streamline_data(algo, mdata, fdata)[:, downwind_index]

foxes/models/wake_frames/timelines.py

@@ -1,8 +1,9 @@
 import numpy as np
+from xarray import Dataset
 
-from foxes.core import WakeFrame
+from foxes.core import WakeFrame, MData, FData, TData
 from foxes.utils import wd2uv
-from foxes.core.data import MData, FData, TData
+from foxes.algorithms.iterative import Iterative
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -13,12 +14,12 @@ class Timelines(WakeFrame):
 
     Attributes
     ----------
-    max_wake_length: float
-        The maximal wake length
+    max_length_km: float
+        The maximal wake length in km
     cl_ipars: dict
         Interpolation parameters for centre line
         point interpolation
-    dt_min: float, optional
+    dt_min: float
         The delta t value in minutes,
         if not from timeseries data
 
@@ -26,49 +27,39 @@ class Timelines(WakeFrame):
 
     """
 
-    def __init__(self, max_wake_length=2e4, cl_ipars={}, dt_min=None):
+    def __init__(self, max_length_km=2e4, cl_ipars={}, dt_min=None, **kwargs):
         """
         Constructor.
 
         Parameters
         ----------
-        max_wake_length: float
-            The maximal wake length
+        max_length_km: float
+            The maximal wake length in km
         cl_ipars: dict
             Interpolation parameters for centre line
             point interpolation
         dt_min: float, optional
             The delta t value in minutes,
             if not from timeseries data
+        kwargs: dict, optional
+            Additional parameters for the base class
 
         """
-        super().__init__()
-        self.max_wake_length = max_wake_length
+        super().__init__(max_length_km=max_length_km, **kwargs)
         self.cl_ipars = cl_ipars
         self.dt_min = dt_min
 
     def __repr__(self):
-        return f"{type(self).__name__}(dt_min={self.dt_min})"
+        return f"{type(self).__name__}(dt_min={self.dt_min}, max_length_km={self.max_length_km})"
 
-    def initialize(self, algo, verbosity=0):
-        """
-        Initializes the model.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-        verbosity: int
-            The verbosity level, 0 = silent
-
-        """
-        super().initialize(algo, verbosity)
+    def _precalc_data(self, algo, states, heights, verbosity, needs_res=False):
+        """Helper function for pre-calculation of ambient wind vectors"""
 
         if verbosity > 0:
             print(f"{self.name}: Pre-calculating ambient wind vectors")
 
         # get and check times:
-        times = np.asarray(algo.states.index())
+        times = np.asarray(states.index())
         if self.dt_min is None:
             if not np.issubdtype(times.dtype, np.datetime64):
                 raise TypeError(
@@ -83,47 +74,194 @@ class Timelines(WakeFrame):
             n = max(len(times) - 1, 1)
             dt = np.full(n, self.dt_min * 60, dtype="timedelta64[s]").astype(FC.ITYPE)
 
-        # calculate horizontal wind vector in all states:
-        self._uv = np.zeros((algo.n_states, 1, 3), dtype=FC.DTYPE)
-
         # prepare mdata:
-        mdata = algo.get_model_data(algo.states)["data_vars"]
-        mdict = {v: d[1] for v, d in mdata.items()}
-        mdims = {v: d[0] for v, d in mdata.items()}
-        mdata = MData(mdict, mdims, loop_dims=[FC.STATE])
-        del mdict, mdims
+        data = algo.get_model_data(states)["coords"]
+        mdict = {v: np.array(d) for v, d in data.items()}
+        mdims = {v: (v,) for v in data.keys()}
+        data = algo.get_model_data(states)["data_vars"]
+        mdict.update({v: d[1] for v, d in data.items()})
+        mdims.update({v: d[0] for v, d in data.items()})
+        mdata = MData(mdict, mdims, loop_dims=[FC.STATE], states_i0=0)
+        del mdict, mdims, data
 
         # prepare fdata:
         fdata = FData({}, {}, loop_dims=[FC.STATE])
 
         # prepare tdata:
-        tdata = {
-            v: np.zeros((algo.n_states, 1, 1), dtype=FC.DTYPE)
-            for v in algo.states.output_point_vars(algo)
+        n_states = states.size()
+        data = {
+            v: np.zeros((n_states, 1, 1), dtype=FC.DTYPE)
+            for v in states.output_point_vars(algo)
         }
-        pdims = {v: (FC.STATE, FC.TARGET, FC.TPOINT) for v in tdata.keys()}
-        tdata = TData.from_points(
-            points=np.zeros((algo.n_states, 1, 3), dtype=FC.DTYPE),
-            data=tdata,
-            dims=pdims,
+        pdims = {v: (FC.STATE, FC.TARGET, FC.TPOINT) for v in data.keys()}
+        points = np.zeros((n_states, 1, 3), dtype=FC.DTYPE)
+
+        # calculate all heights:
+        self.timelines_data = {"dxy": (("height", FC.STATE, "dir"), [])}
+        for h in heights:
+
+            if verbosity > 0:
+                print(f"  Height: {h} m")
+
+            points[..., 2] = h
+            tdata = TData.from_points(
+                points=points,
+                data=data,
+                dims=pdims,
+            )
+
+            res = states.calculate(algo, mdata, fdata, tdata)
+            del tdata
+
+            uv = wd2uv(res[FV.WD], res[FV.WS])[:, 0, 0, :2]
+            if len(dt) == 1:
+                dxy = uv * dt[0]
+            else:
+                dxy = uv[:-1] * dt[:, None]
+                dxy = np.append(dxy, uv[-1, None, :] * dt[-1], axis=0)
+            self.timelines_data["dxy"][1].append(dxy)
+            """ DEBUG
+            import matplotlib.pyplot as plt
+            xy = np.array([np.sum(self.timelines_data[h][:n], axis=0) for n in range(len(self.timelines_data[h]))])
+            print(xy)
+            plt.plot(xy[:, 0], xy[:, 1])
+            plt.title(f"Height {h} m")
+            plt.show()
+            quit()
+            """
+
+            if needs_res:
+                if "U" not in self.timelines_data:
+                    self.timelines_data["U"] = (("height", FC.STATE), [])
+                    self.timelines_data["V"] = (("height", FC.STATE), [])
+                self.timelines_data["U"][1].append(uv[:, 0])
+                self.timelines_data["V"][1].append(uv[:, 1])
+
+                for v in states.output_point_vars(algo):
+                    if v not in [FV.WS, FV.WD]:
+                        if v not in self.timelines_data:
+                            self.timelines_data[v] = (("height", FC.STATE), [])
+                        self.timelines_data[v][1].append(res[v][:, 0, 0])
+
+            del res, uv, dxy
+
+        self.timelines_data = Dataset(
+            coords={
+                FC.STATE: states.index(),
+                "height": heights,
+            },
+            data_vars={
+                v: (d[0], np.stack(d[1], axis=0))
+                for v, d in self.timelines_data.items()
+            },
         )
 
-        # calculate:
-        res = algo.states.calculate(algo, mdata, fdata, tdata)
-        if len(dt) == 1:
-            self._dxy = wd2uv(res[FV.WD], res[FV.WS])[:, 0, 0, :2] * dt[:, None]
+    def initialize(self, algo, verbosity=0):
+        """
+        Initializes the model.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        verbosity: int
+            The verbosity level, 0 = silent
+
+        """
+        if not isinstance(algo, Iterative):
+            raise TypeError(
+                f"Incompatible algorithm type {type(algo).__name__}, expecting {Iterative.__name__}"
+            )
+        super().initialize(algo, verbosity)
+
+        # find turbine hub heights:
+        t2h = np.zeros(algo.n_turbines, dtype=FC.DTYPE)
+        for ti, t in enumerate(algo.farm.turbines):
+            t2h[ti] = (
+                t.H if t.H is not None else algo.farm_controller.turbine_types[ti].H
+            )
+        heights = np.unique(t2h)
+
+        # pre-calc data:
+        from foxes.input.states import OnePointFlowTimeseries
+
+        if isinstance(algo.states, OnePointFlowTimeseries):
+            self._precalc_data(algo, algo.states.base_states, heights, verbosity)
         else:
-            self._dxy = wd2uv(res[FV.WD], res[FV.WS])[:-1, 0, 0, :2] * dt[:, None]
-            self._dxy = np.insert(self._dxy, 0, self._dxy[0], axis=0)
-
-        """ DEBUG
-        import matplotlib.pyplot as plt
-        xy = np.array([np.sum(self._dxy[:n], axis=0) for n in range(len(self._dxy))])
-        print(xy)
-        plt.plot(xy[:, 0], xy[:, 1])
-        plt.show()
-        quit()
+            self._precalc_data(algo, algo.states, heights, verbosity)
+
+    def set_running(
+        self,
+        algo,
+        data_stash,
+        sel=None,
+        isel=None,
+        verbosity=0,
+    ):
+        """
+        Sets this model status to running, and moves
+        all large data to stash.
+
+        The stashed data will be returned by the
+        unset_running() function after running calculations.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        data_stash: dict
+            Large data stash, this function adds data here.
+            Key: model name. Value: dict, large model data
+        sel: dict, optional
+            The subset selection dictionary
+        isel: dict, optional
+            The index subset selection dictionary
+        verbosity: int
+            The verbosity level, 0 = silent
+
+        """
+        super().set_running(algo, data_stash, sel, isel, verbosity)
+
+        if sel is not None or isel is not None:
+            data_stash[self.name]["data"] = self.timelines_data
+
+            if isel is not None:
+                self.timelines_data = self.timelines_data.isel(isel)
+            if sel is not None:
+                self.timelines_data = self.timelines_data.sel(sel)
+
+    def unset_running(
+        self,
+        algo,
+        data_stash,
+        sel=None,
+        isel=None,
+        verbosity=0,
+    ):
         """
+        Sets this model status to not running, recovering large data
+        from stash
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        data_stash: dict
+            Large data stash, this function adds data here.
+            Key: model name. Value: dict, large model data
+        sel: dict, optional
+            The subset selection dictionary
+        isel: dict, optional
+            The index subset selection dictionary
+        verbosity: int
+            The verbosity level, 0 = silent
+
+        """
+        super().unset_running(algo, data_stash, sel, isel, verbosity)
+
+        data = data_stash[self.name]
+        if "data" in data:
+            self.timelines_data = data.pop("data")
 
     def calc_order(self, algo, mdata, fdata):
         """ "
@@ -147,25 +285,8 @@ class Timelines(WakeFrame):
             The turbine order, shape: (n_states, n_turbines)
 
         """
-        # prepare:
-        n_states = fdata.n_states
-        n_turbines = algo.n_turbines
-        tdata = TData.from_points(points=fdata[FV.TXYH])
-
-        # calculate streamline x coordinates for turbines rotor centre points:
-        # n_states, n_turbines_source, n_turbines_target
-        coosx = np.zeros((n_states, n_turbines, n_turbines), dtype=FC.DTYPE)
-        for ti in range(n_turbines):
-            coosx[:, ti, :] = self.get_wake_coos(algo, mdata, fdata, tdata, ti)[
-                :, :, 0, 0
-            ]
-
-        # derive turbine order:
-        # TODO: Remove loop over states
-        order = np.zeros((n_states, n_turbines), dtype=FC.ITYPE)
-        for si in range(n_states):
-            order[si] = np.lexsort(keys=coosx[si])
-
+        order = np.zeros((fdata.n_states, fdata.n_turbines), dtype=FC.ITYPE)
+        order[:] = np.arange(fdata.n_turbines)[None, :]
         return order
 
     def get_wake_coos(
@@ -206,69 +327,86 @@ class Timelines(WakeFrame):
         n_points = n_targets * n_tpoints
         points = targets.reshape(n_states, n_points, 3)
         rxyz = fdata[FV.TXYH][:, downwind_index]
+        theights = fdata[FV.H][:, downwind_index]
+        heights = self.timelines_data["height"].to_numpy()
+        data_dxy = self.timelines_data["dxy"].to_numpy()
 
         D = np.zeros((n_states, n_points), dtype=FC.DTYPE)
         D[:] = fdata[FV.D][:, downwind_index, None]
 
-        i0 = mdata.states_i0(counter=True, algo=algo)
-        i1 = i0 + mdata.n_states
-        dxy = self._dxy[:i1]
-
-        trace_p = np.zeros((n_states, n_points, 2), dtype=FC.DTYPE)
-        trace_p[:] = points[:, :, :2] - rxyz[:, None, :2]
-        trace_l = np.zeros((n_states, n_points), dtype=FC.DTYPE)
-        trace_d = np.full((n_states, n_points), np.inf, dtype=FC.DTYPE)
-        trace_si = np.zeros((n_states, n_points), dtype=FC.ITYPE)
-        trace_si[:] = i0 + np.arange(n_states)[:, None] + 1
-
         wcoos = np.full((n_states, n_points, 3), 1e20, dtype=FC.DTYPE)
         wcoosx = wcoos[:, :, 0]
         wcoosy = wcoos[:, :, 1]
         wcoos[:, :, 2] = points[:, :, 2] - rxyz[:, None, 2]
-        del rxyz
-
-        while True:
-            sel = (trace_si > 0) & (trace_l < self.max_wake_length)
-            if np.any(sel):
-                trace_si[sel] -= 1
-
-                delta = dxy[trace_si[sel]]
-                dmag = np.linalg.norm(delta, axis=-1)
-
-                trace_p[sel] -= delta
-                trace_l[sel] += dmag
-
-                trp = trace_p[sel]
-                d0 = trace_d[sel]
-                d = np.linalg.norm(trp, axis=-1)
-                trace_d[sel] = d
-
-                seln = d <= np.minimum(d0, 2 * dmag)
-                if np.any(seln):
-                    htrp = trp[seln]
-                    raxis = delta[seln]
-                    raxis = raxis / np.linalg.norm(raxis, axis=-1)[:, None]
-                    saxis = np.concatenate(
-                        [-raxis[:, 1, None], raxis[:, 0, None]], axis=1
-                    )
-
-                    wcx = wcoosx[sel]
-                    wcx[seln] = np.einsum("sd,sd->s", htrp, raxis) + trace_l[sel][seln]
-                    wcoosx[sel] = wcx
-                    del wcx, raxis
-
-                    wcy = wcoosy[sel]
-                    wcy[seln] = np.einsum("sd,sd->s", htrp, saxis)
-                    wcoosy[sel] = wcy
-                    del wcy, saxis, htrp
-
-            else:
-                break
 
-        # turbines that cause wake:
+        i0 = mdata.states_i0(counter=True)
+        i1 = i0 + mdata.n_states
+        trace_si = np.zeros((n_states, n_points), dtype=FC.ITYPE)
+        trace_si[:] = i0 + np.arange(n_states)[:, None]
+        for hi, h in enumerate(heights):
+            dxy = data_dxy[hi][:i1]
+            precond = theights[:, None] == h
+
+            trace_p = np.zeros((n_states, n_points, 2), dtype=FC.DTYPE)
+            trace_p[:] = points[:, :, :2] - rxyz[:, None, :2]
+            trace_l = np.zeros((n_states, n_points), dtype=FC.DTYPE)
+            trace_d = np.full((n_states, n_points), np.inf, dtype=FC.DTYPE)
+            h_trace_si = trace_si.copy()
+
+            # flake8: noqa: F821
+            def _update_wcoos(sel):
+                """Local function that updates coordinates and source times"""
+                nonlocal wcoosx, wcoosy, trace_si
+                d = np.linalg.norm(trace_p, axis=-1)
+                sel = sel & (d <= trace_d)
+                if np.any(sel):
+                    trace_d[sel] = d[sel]
+
+                    nx = dxy[h_trace_si[sel]]
+                    dx = np.linalg.norm(nx, axis=-1)
+                    nx /= dx[:, None]
+                    trp = trace_p[sel]
+                    projx = np.einsum("sd,sd->s", trp, nx)
+
+                    seln = (projx > -dx) & (projx < dx)
+                    if np.any(seln):
+                        wcoosx[sel] = np.where(seln, projx + trace_l[sel], wcoosx[sel])
+
+                        ny = np.concatenate([-nx[:, 1, None], nx[:, 0, None]], axis=1)
+                        projy = np.einsum("sd,sd->s", trp, ny)
+                        wcoosy[sel] = np.where(seln, projy, wcoosy[sel])
+                        del ny, projy
+
+                        trace_si[sel] = np.where(seln, h_trace_si[sel], trace_si[sel])
+
+            # step backwards in time, until wake source turbine is hit:
+            _update_wcoos(precond)
+            while True:
+                sel = precond & (h_trace_si > 0) & (trace_l < self.max_length_km * 1e3)
+                if np.any(sel):
+                    h_trace_si[sel] -= 1
+
+                    delta = dxy[h_trace_si[sel]]
+                    dmag = np.linalg.norm(delta, axis=-1)
+                    trace_p[sel] -= delta
+                    trace_l[sel] += dmag
+                    del delta, dmag
+
+                    # check if this is closer to turbine:
+                    _update_wcoos(sel)
+                    del sel
+
+                else:
+                    del sel
+                    break
+            del trace_p, trace_l, trace_d, h_trace_si, dxy, precond
+
+        # store turbines that cause wake:
+        trace_si = np.minimum(trace_si, i0 + np.arange(n_states)[:, None])
         tdata[FC.STATE_SOURCE_ORDERI] = downwind_index
 
-        # states that cause wake for each target point:
+        # store states that cause wake for each target point,
+        # will be used by model.get_data() during wake calculation:
         tdata.add(
             FC.STATES_SEL,
             trace_si.reshape(n_states, n_targets, n_tpoints),
@@ -301,4 +439,67 @@ class Timelines(WakeFrame):
             The centreline points, shape: (n_states, n_points, 3)
 
         """
-        raise NotImplementedError
+        # prepare:
+        n_states, n_points = x.shape
+        rxyz = fdata[FV.TXYH][:, downwind_index]
+        theights = fdata[FV.H][:, downwind_index]
+        heights = self.timelines_data["height"].to_numpy()
+        data_dxy = self.timelines_data["dxy"].to_numpy()
+
+        points = np.zeros((n_states, n_points, 3), dtype=FC.DTYPE)
+        points[:] = rxyz[:, None, :]
+
+        trace_dp = np.zeros_like(points[..., :2])
+        trace_l = x.copy()
+        trace_si = np.zeros((n_states, n_points), dtype=FC.ITYPE)
+        trace_si[:] = np.arange(n_states)[:, None]
+
+        for hi, h in enumerate(heights):
+            precond = theights == h
+            if np.any(precond):
+                sel = precond[:, None] & (trace_l > 0)
+                while np.any(sel):
+                    dxy = data_dxy[hi][trace_si[sel]]
+
+                    trl = trace_l[sel]
+                    trp = trace_dp[sel]
+                    dl = np.linalg.norm(dxy, axis=-1)
+                    cl = np.abs(trl - dl) < np.abs(trl)
+                    if np.any(cl):
+                        trace_l[sel] = np.where(cl, trl - dl, trl)
+                        trace_dp[sel] = np.where(cl[:, None], trp + dxy, trp)
+                    del trl, trp, dl, cl, dxy
+
+                    trace_si[sel] -= 1
+                    sel = precond[:, None] & (trace_l > 0) & (trace_si >= 0)
+
+                si = trace_si[precond] + 1
+                dxy = data_dxy[hi][si]
+                dl = np.linalg.norm(dxy, axis=-1)[:, :, None]
+                trl = trace_l[precond][:, :, None]
+                trp = trace_dp[precond]
+                sel = np.abs(trl) < 2 * dl
+                trace_dp[precond] = np.where(sel, trp - trl / dl * dxy, np.nan)
+
+                del si, dxy, dl, trl, trp, sel
+            del precond
+        del trace_si, trace_l
+
+        points[..., :2] += trace_dp
+
+        return points
+
+    def finalize(self, algo, verbosity=0):
+        """
+        Finalizes the model.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        verbosity: int
+            The verbosity level, 0 = silent
+
+        """
+        super().finalize(algo, verbosity=verbosity)
+        self.timelines_data = None

foxes/models/wake_frames/yawed_wakes.py

@@ -44,6 +44,7 @@ class YawedWakes(WakeFrame):
         alpha=0.58,
         beta=0.07,
         induction="Madsen",
+        max_length_km=30,
         **wake_k,
     ):
         """
@@ -63,9 +64,11 @@ class YawedWakes(WakeFrame):
             The induction model, if not found in wake model
         wake_k: dict, optional
             Parameters for the WakeK class, if not found in wake model
+        max_length_km: float
+            The maximal wake length in km
 
         """
-        super().__init__()
+        super().__init__(max_length_km=max_length_km)
 
         self.base_frame = base_frame
         self.model = None

foxes/models/wake_models/dist_sliced.py

@@ -1,5 +1,4 @@
 from abc import abstractmethod
-import numpy as np
 
 from foxes.core import WakeModel
 
@@ -153,8 +152,7 @@ class DistSlicedWakeModel(WakeModel):
             (n_states, n_targets, n_tpoints, ...)
 
         """
-        # rounding for safe x > 0 conditions
-        x = np.round(wake_coos[:, :, 0, 0], 12)
+        x = wake_coos[:, :, 0, 0]
         yz = wake_coos[..., 1:3]
 
         wdeltas, st_sel = self.calc_wakes_x_yz(