foxes 1.2.5__py3-none-any.whl → 1.4__py3-none-any.whl

foxes/input/states/wrg_states.py

@@ -1,8 +1,9 @@
 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.utils import ReaderWRG, weibull_weights
 from foxes.data import STATES
 import foxes.variables as FV
 import foxes.constants as FC
@@ -25,6 +26,8 @@ class WRGStates(States):
     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
 
@@ -36,7 +39,7 @@ class WRGStates(States):
         ws_bins,
         fixed_vars={},
         bounds_extra_space="1D",
-        **kwargs,
+        **interpn_pars,
     ):
         """
         Constructor
@@ -54,15 +57,16 @@ class WRGStates(States):
         bounds_extra_space: float or str, optional
             The extra space, either float in m,
             or str for units of D, e.g. '2.5D'
-        kwargs: dict, optional
-            Parameters for the base class
+        interpn_pars: dict, optional
+            Additional parameters for scipy.interpolate.interpn
 
         """
-        super().__init__(**kwargs)
+        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):
         """
@@ -100,11 +104,14 @@ class WRGStates(States):
         elif verbosity:
             print(f"States '{self.name}': Reading file {fpath}")
         wrg = ReaderWRG(fpath)
-        self._p0 = np.array([wrg.x0, wrg.y0], dtype=config.dtype_double)
-        self._nx = wrg.nx
-        self._ny = wrg.ny
-        self._ns = wrg.n_sectors
-        self._res = wrg.resolution
+        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:
@@ -112,48 +119,56 @@ class WRGStates(States):
                 extra_space=self.bounds_extra_space, algo=algo
             )
             if verbosity > 0:
-                print(
-                    f"States '{self.name}': Restricting to bounds {xy_min} - {xy_max}"
-                )
-            xy_min -= self._p0
-            xy_max -= self._p0
-            ij_min = np.asarray(xy_min / self._res, dtype=config.dtype_int)
-            ij_max = np.asarray(xy_max / self._res, dtype=config.dtype_int) + 1
+                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("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 = []
-        fs = []
-        for s in range(self._ns):
-            A.append(wrg.data[f"A_{s}"].to_numpy().reshape(self._ny, self._nx)[sy, sx])
-            k.append(wrg.data[f"k_{s}"].to_numpy().reshape(self._ny, self._nx)[sy, sx])
-            fs.append(
-                wrg.data[f"fs_{s}"].to_numpy().reshape(self._ny, self._nx)[sy, sx]
-            )
+        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
-        fs = np.stack(fs, axis=0).T
-        self._data = np.stack([A, k, fs], axis=-1)  # (x, y, wd, AKfs)
+        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.WSWD = self.var("WSWD")
-        self._wds = np.arange(0.0, 360.0, 360 / self._ns)
+        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) * self._ns
-        wswd = np.zeros((len(self._wss), self._ns, 2), dtype=config.dtype_double)
-        wswd[..., 0] = self._wss[:, None]
-        wswd[..., 1] = self._wds[None, :]
-        wswd = wswd.reshape(self._N, 2)
+        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.WSWD] = [self.var(FV.WS), self.var(FV.WD)]
-        idata.data_vars[self.WSWD] = ((FC.STATE, self.WSWD), wswd)
+        idata["coords"][self.VARS] = ["ws", "wd", "dws"]
+        idata["data_vars"][self.DATA] = ((FC.STATE, self.VARS), data)
 
         return idata
 
@@ -184,6 +199,105 @@ class WRGStates(States):
             The output variable names
 
         """
-        ovars = set([FV.WS, FV.WD, FV.WEIGHT])
-        ovars.update(self.fixed_vars.values())
+        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),
+        )
+
+        tdata[FV.WEIGHT] *= weibull_weights(
+            ws=out[FV.WS],
+            ws_deltas=wsd[:, None, None],
+            A=A,
+            k=k,
+        )
+
+        return out

foxes/input/yaml/__init__.py

@@ -1,3 +1,9 @@
-from .dict import read_dict, run_dict, run_outputs, run_obj_function, get_output_obj
-from .yaml import foxes_yaml
-from .windio.windio import read_windio, foxes_windio
+from .dict import read_dict as read_dict
+from .dict import run_dict as run_dict
+from .dict import run_outputs as run_outputs
+from .dict import run_obj_function as run_obj_function
+from .dict import get_output_obj as get_output_obj
+
+from .yaml import foxes_yaml as foxes_yaml
+from .windio.windio import read_windio as read_windio
+from .windio.windio import foxes_windio as foxes_windio

foxes/input/yaml/dict.py

@@ -75,13 +75,13 @@ def read_dict(
             print(*args, **kwargs)
 
     # set working directory:
-    l = 0
+    ld = 0
     for c, d in zip(
         [FC.WORK_DIR, FC.INPUT_DIR, FC.OUTPUT_DIR], [work_dir, input_dir, output_dir]
     ):
         if d is not None:
             config[c] = d
-            l = max(l, len(str(d)))
+            ld = max(ld, len(str(d)))
     _print("\n--------------------- Reading foxes parameter dict ---------------------")
     _print("Working directory  :", config.work_dir)
     _print("Input directory    :", config.input_dir)
@@ -95,9 +95,9 @@ def read_dict(
         else:
             states = algo.states
     else:
-        assert (
-            algo is None
-        ), f"Cannot handle both the algo and the states argument, please drop one"
+        assert algo is None, (
+            "Cannot handle both the algo and the states argument, please drop one"
+        )
 
     # create model book:
     if mbook is None:
@@ -119,9 +119,9 @@ def read_dict(
         else:
             mbook = algo.mbook
     else:
-        assert (
-            algo is None
-        ), f"Cannot handle both the algo and the mbook argument, please drop one"
+        assert algo is None, (
+            "Cannot handle both the algo and the mbook argument, please drop one"
+        )
 
     # create farm:
     if farm is None:
@@ -129,8 +129,8 @@ def read_dict(
             _print("Creating wind farm")
             fdict = idict.get_item("wind_farm")
             lyts = [
-                Dict(l, name=f"{fdict.name}.layout{i}")
-                for i, l in enumerate(fdict.pop_item("layouts"))
+                Dict(lo, name=f"{fdict.name}.layout{i}")
+                for i, lo in enumerate(fdict.pop_item("layouts"))
             ]
             farm = WindFarm(**fdict)
             for lyt in lyts:
@@ -141,9 +141,9 @@ def read_dict(
         else:
             farm = algo.farm
     else:
-        assert (
-            algo is None
-        ), f"Cannot handle both the algo and the farm argument, please drop one"
+        assert algo is None, (
+            "Cannot handle both the algo and the farm argument, please drop one"
+        )
 
     # create engine:
     engine = None
@@ -321,12 +321,12 @@ def run_obj_function(
 
         def _set_label(rlabels, k, r):
             if k not in ["", "none", "None", "_", "__"]:
-                assert (
-                    k[0] == "$"
-                ), f"Output {i} of type '{ocls}', function '{fname}': result labels must start with '$', got '{k}'"
-                assert (
-                    "[" not in k and "]" not in k and "," not in k
-                ), f"Output {i} of type '{ocls}', function '{fname}': result labels cannot contain '[' or ']' or comma, got '{k}'"
+                assert k[0] == "$", (
+                    f"Output {i} of type '{ocls}', function '{fname}': result labels must start with '$', got '{k}'"
+                )
+                assert "[" not in k and "]" not in k and "," not in k, (
+                    f"Output {i} of type '{ocls}', function '{fname}': result labels cannot contain '[' or ']' or comma, got '{k}'"
+                )
                 _print(f"    result label {k}: {type(r).__name__}")
                 rlabels[k] = r
 

foxes/input/yaml/windio/__init__.py

@@ -1,5 +1,10 @@
-from .windio import foxes_windio, read_windio
-from .read_site import read_site
-from .read_fields import read_wind_resource_field
-from .read_farm import read_layout, read_turbine_types, read_farm
-from .read_attributes import read_attributes
+from .windio import foxes_windio as foxes_windio
+from .windio import read_windio as read_windio
+
+from .read_farm import read_layout as read_layout
+from .read_farm import read_turbine_types as read_turbine_types
+from .read_farm import read_farm as read_farm
+
+from .read_site import read_site as read_site
+from .read_fields import read_wind_resource_field as read_wind_resource_field
+from .read_attributes import read_attributes as read_attributes

foxes/input/yaml/windio/read_attributes.py

@@ -202,7 +202,7 @@ def _read_rotor_averaging(rotor_averaging, algo_dict, verbosity):
     elif background_averaging in ["none", "None", None]:
         algo_dict["rotor_model"] = None
     elif background_averaging == "grid":
-        algo_dict["rotor_model"] = f"grid{nx*ny}"
+        algo_dict["rotor_model"] = f"grid{nx * ny}"
     else:
         algo_dict["rotor_model"] = background_averaging
 
@@ -215,7 +215,7 @@ def _read_rotor_averaging(rotor_averaging, algo_dict, verbosity):
             algo_dict["partial_wakes"] = "rotor_points"
         else:
             if grid == "grid":
-                algo_dict["partial_wakes"] = f"grid{nx*ny}"
+                algo_dict["partial_wakes"] = f"grid{nx * ny}"
             else:
                 algo_dict["partial_wakes"] = grid
     else:

foxes/input/yaml/windio/read_farm.py

@@ -77,7 +77,7 @@ def read_turbine_types(wio_farm, mbook, ws_exp_P, ws_exp_ct, verbosity):
                 return FV.REWS if wse == 1 else (FV.REWS2 if wse == 2 else FV.REWS3)
 
             _print(f"            Creating model '{tname}'", level=3)
-            _print(f"              Turbine type class: PCtFomTwo", level=3)
+            _print("              Turbine type class: PCtFomTwo", level=3)
             mbook.turbine_types[tname] = TurbineType.new(
                 ttype_type="PCtFromTwo",
                 data_source_P=data_P,
@@ -111,7 +111,7 @@ def read_turbine_types(wio_farm, mbook, ws_exp_P, ws_exp_ct, verbosity):
             data_ct = pd.DataFrame(data={"ws": ws_ct, "ct": ct})
 
             _print(f"            Creating model '{tname}'", level=3)
-            _print(f"              Turbine type class: CpCtFromTwo", level=3)
+            _print("              Turbine type class: CpCtFromTwo", level=3)
             mbook.turbine_types[tname] = TurbineType.new(
                 ttype_type="CpCtFromTwo",
                 data_source_cp=data_cp,
@@ -126,7 +126,7 @@ def read_turbine_types(wio_farm, mbook, ws_exp_P, ws_exp_ct, verbosity):
             _print("               ", mbook.turbine_types[tname], level=3)
 
         else:
-            raise KeyError(f"Expecting either 'power_curve' or 'Cp_curve'")
+            raise KeyError("Expecting either 'power_curve' or 'Cp_curve'")
 
     return ttypes
 
@@ -157,7 +157,7 @@ def read_layout(lname, ldict, farm, ttypes, verbosity=1):
     cdict = Dict(ldict["coordinates"], name="coordinates")
     tmap = ldict.get_item("turbine_types", None)
     if verbosity > 2:
-        print(f"          Turbine type map:", tmap)
+        print("          Turbine type map:", tmap)
     for i, xy in enumerate(zip(cdict["x"], cdict["y"])):
         tt = ttypes[tmap[i] if tmap is not None else 0]
         farm.add_turbine(
@@ -211,7 +211,7 @@ def read_farm(wio_dict, mbook, verbosity):
     if isinstance(wfarm, dict):
         layouts = Dict(wfarm, name=wio_farm.name + ".layouts")
     else:
-        layouts = {str(i): l for i, l in enumerate(wfarm)}
+        layouts = {str(i): lf for i, lf in enumerate(wfarm)}
         layouts = Dict(layouts, name=wio_farm.name + ".layouts")
     if verbosity > 2:
         print("    Reading layouts")

foxes/input/yaml/windio/read_fields.py

@@ -22,6 +22,8 @@ wio2foxes = {
     "LMO": FV.MOL,
     "z0": FV.Z0,
     "reference_height": FV.H,
+    "weibull_a": FV.WEIBULL_A,
+    "weibull_k": FV.WEIBULL_k,
 }
 
 """ Mapping from foxes to windio variables
@@ -134,8 +136,6 @@ def read_wind_resource_field(
 
     """
     if name in [
-        "weibull_a",
-        "weibull_k",
         "potential_temperature",
         "friction_velocity",
         "k",
@@ -178,6 +178,8 @@ def read_wind_resource_field(
         "LMO",
         "z0",
         "reference_height",
+        "weibull_a",
+        "weibull_k",
     ] and _read_multi_dimensional_data(name, wio_data, fields, dims):
         return True
 

foxes/input/yaml/windio/read_site.py

@@ -159,6 +159,55 @@ def _get_MultiHeightNCTimeseries(
     return False
 
 
+def _get_WeibullSectors(
+    coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
+):
+    """Try to generate Weibull sector parameters
+    :group: input.yaml.windio
+    """
+    if (
+        FV.WEIBULL_A in fields
+        and FV.WEIBULL_k in fields
+        and "sector_probability" in fields
+        and len(dims[FV.WEIBULL_A]) == 1
+        and len(dims[FV.WEIBULL_k]) == 1
+        and len(dims["sector_probability"]) == 1
+    ):
+        if verbosity > 2:
+            print("        selecting class 'WeibullSectors'")
+
+        data = {}
+        fix = {}
+        c = dims[FV.WEIBULL_A][0]
+        for v, d in fields.items():
+            if dims[v] == (c,):
+                data[v] = d
+            elif len(dims[v]) == 0:
+                fix[v] = d
+            elif verbosity > 2:
+                print(f"        ignoring field '{v}' with dims {dims[v]}")
+        fix.update({v: d for v, d in fixval.items() if v not in data})
+
+        if FV.WD in coords:
+            data[FV.WD] = coords[FV.WD]
+
+        sdata = pd.DataFrame(index=range(len(fields[FV.WEIBULL_A])), data=data)
+        sdata.index.name = "sector"
+        states_dict.update(
+            dict(
+                states_type="WeibullSectors",
+                data_source=sdata,
+                ws_bins=coords.get(FV.WS, np.arange(30)),
+                output_vars=ovars,
+                var2ncvar={FV.WEIGHT: "sector_probability"},
+                fixed_vars=fix,
+                profiles=profiles,
+            )
+        )
+        return True
+    return False
+
+
 def get_states(coords, fields, dims, verbosity=1):
     """
     Reads states parameters from windio input
@@ -200,6 +249,9 @@ def get_states(coords, fields, dims, verbosity=1):
         or _get_MultiHeightNCTimeseries(
             coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
         )
+        or _get_WeibullSectors(
+            coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
+        )
     ):
         return States.new(**states_dict)
     else:

foxes/input/yaml/windio/windio.py

@@ -43,7 +43,7 @@ def read_windio(wio_dict, verbosity=1):
     if not isinstance(wio_dict, Dict):
         wio_dict = Dict(wio_dict, name="windio")
 
-    _print(f"Reading windio data")
+    _print("Reading windio data")
     _print("  Name:", wio_dict.pop_item("name", None))
     _print("  Contents:", [k for k in wio_dict.keys()])
 

foxes/models/__init__.py

@@ -2,18 +2,19 @@
 Model collection.
 """
 
-from . import turbine_types
-from . import rotor_models
-from . import turbine_models
-from . import farm_models
-from . import partial_wakes
-from . import wake_frames
-from . import wake_models
-from . import wake_superpositions
-from . import farm_controllers
-from . import vertical_profiles
-from . import point_models
-from . import axial_induction
-from . import ground_models
+from . import turbine_types as turbine_types
+from . import rotor_models as rotor_models
+from . import turbine_models as turbine_models
+from . import farm_models as farm_models
+from . import partial_wakes as partial_wakes
+from . import wake_frames as wake_frames
+from . import wake_models as wake_models
+from . import wake_deflections as wake_deflections
+from . import wake_superpositions as wake_superpositions
+from . import farm_controllers as farm_controllers
+from . import vertical_profiles as vertical_profiles
+from . import point_models as point_models
+from . import axial_induction as axial_induction
+from . import ground_models as ground_models
 
-from .model_book import ModelBook
+from .model_book import ModelBook as ModelBook

foxes/models/axial_induction/__init__.py

@@ -1,2 +1,2 @@
-from .betz import BetzAxialInduction
-from .madsen import MadsenAxialInduction
+from .betz import BetzAxialInduction as BetzAxialInduction
+from .madsen import MadsenAxialInduction as MadsenAxialInduction

foxes/models/farm_controllers/__init__.py

@@ -2,4 +2,4 @@
 Farm controller models.
 """
 
-from .basic import BasicFarmController
+from .basic import BasicFarmController as BasicFarmController

foxes/models/farm_models/__init__.py

@@ -2,4 +2,4 @@
 Farm models.
 """
 
-from .turbine2farm import Turbine2FarmModel
+from .turbine2farm import Turbine2FarmModel as Turbine2FarmModel

foxes/models/ground_models/__init__.py

@@ -1,2 +1,3 @@
-from .no_ground import NoGround
-from .wake_mirror import WakeMirror, GroundMirror
+from .no_ground import NoGround as NoGround
+from .wake_mirror import WakeMirror as WakeMirror
+from .wake_mirror import GroundMirror as GroundMirror

foxes/models/ground_models/wake_mirror.py

@@ -75,13 +75,14 @@ class WakeMirror(GroundModel):
         # 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)
+        wcoos = algo.wake_frame.get_wake_coos(
+            algo, mdata, fdata, tdata, downwind_index, wmodel
+        )
         wmodel.contribute(algo, mdata, fdata, tdata, downwind_index, wcoos, wake_deltas)
 
         # contribution from mirrors:
         tdata[FC.TARGETS] = tdata[FC.TARGETS].copy()  # making sure this is no ref
         for h in self.heights:
-
             fdata[FV.TXYH][:, downwind_index, 2] = hh + 2 * (h - hh)
 
             pwake.contribute(
@@ -136,7 +137,6 @@ class WakeMirror(GroundModel):
         # contribution from mirrors:
         tdata[FC.TARGETS] = tdata[FC.TARGETS].copy()  # making sure this is no ref
         for h in self.heights:
-
             fdata[FV.TXYH][:, downwind_index, 2] = hh + 2 * (h - hh)
 
             wcoos = algo.wake_frame.get_wake_coos(