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

examples/yawed_wake/run.py

@@ -34,18 +34,24 @@ if __name__ == "__main__":
         "-w",
         "--wakes",
         help="The wake models",
-        default=["Bastankhah2016_linear_ka02", "CrespoHernandez_quadratic_ka04"],
+        default=["TurbOPark_vector_ambka004", "CrespoHernandez_quadratic_ambka04"],
         nargs="+",
     )
+    parser.add_argument(
+        "-d", "--deflection", help="The wake deflection", default="Jimenez"
+    )
     parser.add_argument("-r", "--rotor", help="The rotor model", default="centre")
     parser.add_argument(
         "-p", "--pwakes", help="The partial wakes models", default=None, nargs="+"
     )
-    parser.add_argument("-f", "--frame", help="The wake frame", default="yawed")
+    parser.add_argument("-f", "--frame", help="The wake frame", default="rotor_wd")
     parser.add_argument(
         "-m", "--tmodels", help="The turbine models", default=[], nargs="+"
     )
     parser.add_argument("-v", "--var", help="The plot variable", default=FV.WS)
+    parser.add_argument(
+        "-it", "--iterative", help="Use iterative algorithm", action="store_true"
+    )
     parser.add_argument("-e", "--engine", help="The engine", default="process")
     parser.add_argument(
         "-n", "--n_cpus", help="The number of cpus", default=None, type=int
@@ -76,7 +82,9 @@ if __name__ == "__main__":
 
     # set turbines in yaw
     yawm = np.array([[args.yawm, args.yawm2]])
-    mbook.turbine_models["set_yawm"] = foxes.models.turbine_models.SetFarmVars()
+    mbook.turbine_models["set_yawm"] = foxes.models.turbine_models.SetFarmVars(
+        pre_rotor=True
+    )
     mbook.turbine_models["set_yawm"].add_var(FV.YAWM, yawm)
 
     # create states
@@ -96,12 +104,14 @@ if __name__ == "__main__":
     )
 
     # create algorithm
-    algo = foxes.algorithms.Downwind(
+    Algo = foxes.algorithms.Iterative if args.iterative else foxes.algorithms.Downwind
+    algo = Algo(
         farm,
         states=states,
         rotor_model=args.rotor,
         wake_models=args.wakes,
         wake_frame=args.frame,
+        wake_deflection=args.deflection,
         partial_wakes=args.pwakes,
         mbook=mbook,
         engine=args.engine,
@@ -119,7 +129,7 @@ if __name__ == "__main__":
         print("\nHorizontal flow figure output:")
         o = foxes.output.FlowPlots2D(algo, farm_results)
         g = o.gen_states_fig_xy(
-            args.var, resolution=10, xmin=-100, xmax=3000, rotor_color="red"
+            args.var, resolution=10, xmin=-500, xmax=3000, rotor_color="red"
         )
         fig = next(g)
         plt.show()
@@ -130,7 +140,7 @@ if __name__ == "__main__":
         o = foxes.output.FlowPlots2D(algo, farm_results)
         g = o.gen_states_fig_yz(
             args.var,
-            resolution=10,
+            resolution=5,
             x=750,
             ymin=-200,
             ymax=200,
@@ -190,7 +200,7 @@ if __name__ == "__main__":
     # power results
     P0 = o.calc_mean_farm_power(ambient=True)
     P = o.calc_mean_farm_power()
-    print(f"\nFarm power        : {P/1000:.1f} MW")
-    print(f"Farm ambient power: {P0/1000:.1f} MW")
-    print(f"Farm efficiency   : {o.calc_farm_efficiency()*100:.2f} %")
+    print(f"\nFarm power        : {P / 1000:.1f} MW")
+    print(f"Farm ambient power: {P0 / 1000:.1f} MW")
+    print(f"Farm efficiency   : {o.calc_farm_efficiency() * 100:.2f} %")
     print(f"Annual farm yield : {turbine_results[FV.YLD].sum():.2f} GWh.")

foxes/__init__.py

@@ -3,24 +3,28 @@ Farm Optimization and eXtended yield Evaluation Software
 
 """
 
-from .config import config, get_path  # noqa: F401
-from .core import Engine, WindFarm, Turbine, get_engine, reset_engine  # noqa: F401
-from .models import ModelBook  # noqa: F401
-from .data import (
-    parse_Pct_file_name,
-    parse_Pct_two_files,
-    FARM,
-    STATES,
-    PCTCURVE,
-    StaticData,
-)  # noqa: F401
+from .config import config as config
+from .config import get_path as get_path
+from .core import Engine as Engine
+from .core import WindFarm as WindFarm
+from .core import Turbine as Turbine
+from .core import get_engine as get_engine
+from .core import reset_engine as reset_engine
+from .models import ModelBook as ModelBook
 
-from . import algorithms  # noqa: F401
-from . import engines  # noqa: F401
-from . import models  # noqa: F401
-from . import input  # noqa: F401
-from . import output  # noqa: F401
-from . import utils  # noqa: F401
+from .data import parse_Pct_file_name as parse_Pct_file_name
+from .data import parse_Pct_two_files as parse_Pct_two_files
+from .data import FARM as FARM
+from .data import STATES as STATES
+from .data import PCTCURVE as PCTCURVE
+from .data import StaticData as StaticData
+
+from . import algorithms as algorithms
+from . import engines as engines
+from . import models as models
+from . import input as input
+from . import output as output
+from . import utils as utils
 
 import importlib
 from pathlib import Path

foxes/algorithms/__init__.py

@@ -2,10 +2,10 @@
 Algorithms define the main calculation routines.
 """
 
-from .downwind.downwind import Downwind
-from .iterative.iterative import Iterative
-from .sequential import Sequential
+from .downwind.downwind import Downwind as Downwind
+from .iterative.iterative import Iterative as Iterative
+from .sequential import Sequential as Sequential
 
-from . import downwind
-from . import iterative
-from . import sequential
+from . import downwind as downwind
+from . import iterative as iterative
+from . import sequential as sequential

foxes/algorithms/downwind/__init__.py

@@ -1,3 +1,3 @@
-from .downwind import Downwind
+from .downwind import Downwind as Downwind
 
-from . import models
+from . import models as models

foxes/algorithms/downwind/downwind.py

@@ -32,6 +32,8 @@ class Downwind(Algorithm):
     partial_wakes: dict
         The partial wakes mapping. Key: wake model name,
         value: foxes.core.PartialWakesModel
+    deflection: foxes.core.WakeDeflection
+        The wake deflection model
     ground_models: dict
         The ground models mapping. Key: wake model name,
         value: foxes.core.GroundModel
@@ -70,6 +72,7 @@ class Downwind(Algorithm):
         wake_models,
         rotor_model="centre",
         wake_frame="rotor_wd",
+        wake_deflection="no_deflection",
         partial_wakes=None,
         ground_models=None,
         farm_controller="basic_ctrl",
@@ -94,6 +97,8 @@ class Downwind(Algorithm):
         wake_frame: str
             The wake frame. Will be looked up in the
             model book
+        deflection: foxes.core.WakeDeflection, optional
+            The wake deflection model
         partial_wakes: dict, list or str, optional
             The partial wakes mapping. Key: wake model name,
             value: partial wake model name
@@ -123,6 +128,9 @@ class Downwind(Algorithm):
         self.__wake_frame = self.mbook.wake_frames.get_item(wake_frame)
         self.wake_frame.name = wake_frame
 
+        self.__wake_deflection = self.mbook.wake_deflections.get_item(wake_deflection)
+        self.wake_deflection.name = wake_deflection
+
         self.__wake_models = {}
         for w in wake_models:
             m = self.mbook.wake_models.get_item(w)
@@ -251,6 +259,19 @@ class Downwind(Algorithm):
         """
         return self.__wake_frame
 
+    @property
+    def wake_deflection(self):
+        """
+        The wake deflection
+
+        Returns
+        -------
+        m: foxes.core.WakeDeflection
+            The wake deflection model
+
+        """
+        return self.__wake_deflection
+
     @property
     def partial_wakes(self):
         """
@@ -310,6 +331,15 @@ class Downwind(Algorithm):
         """
         return getattr(mdls, name)
 
+    def update_n_turbines(self):
+        """
+        Reset the number of turbines,
+        according to self.farm
+        """
+        if self.n_turbines != self.farm.n_turbines:
+            super().update_n_turbines()
+            self.farm_controller.find_turbine_types(self)
+
     def print_deco(self, func_name=None, n_points=None):
         """
         Helper function for printing model names
@@ -334,25 +364,26 @@ class Downwind(Algorithm):
             if n_points is not None:
                 print(f"  n_points : {n_points}")
             print(deco)
-            print(f"  states   : {self.states}")
-            print(f"  rotor    : {self.rotor_model}")
+            print(f"  states    : {self.states}")
+            print(f"  rotor     : {self.rotor_model}")
             print(f"  controller: {self.farm_controller}")
             print(f"  wake frame: {self.wake_frame}")
+            print(f"  deflection: {self.wake_deflection}")
             print(deco)
-            print(f"  wakes:")
+            print("  wakes:")
             for i, w in enumerate(self.wake_models.values()):
                 print(f"    {i}) {w.name}: {w}")
             print(deco)
-            print(f"  partial wakes:")
+            print("  partial wakes:")
             for i, (w, p) in enumerate(self.partial_wakes.items()):
                 print(f"    {i}) {w}: {p.name}, {p}")
             print(deco)
-            print(f"  turbine models:")
+            print("  turbine models:")
             for i, m in enumerate(self.farm_controller.pre_rotor_models.models):
                 print(f"    {i}) {m.name}: {m} [pre-rotor]")
             for i, m in enumerate(self.farm_controller.post_rotor_models.models):
                 print(
-                    f"    {i+len(self.farm_controller.pre_rotor_models.models)}) {m.name}: {m}"
+                    f"    {i + len(self.farm_controller.pre_rotor_models.models)}) {m.name}: {m}"
                 )
             print(deco)
             print()
@@ -364,7 +395,7 @@ class Downwind(Algorithm):
         if self.verbosity > 0:
             deco = "-" * 50
             print(f"\n{deco}")
-            print(f"  Model oder")
+            print("  Model oder")
             print(f"{deco}")
 
             for i, m in enumerate(mlist.models):
@@ -402,6 +433,7 @@ class Downwind(Algorithm):
             self.states,
             self.farm_controller,
             self.rotor_model,
+            self.wake_deflection,
             self.wake_frame,
         ]
         mdls += list(self.wake_models.values())
@@ -445,7 +477,7 @@ class Downwind(Algorithm):
         # 2) calculate ambient rotor results:
         mlist.models.append(self.rotor_model)
         calc_pars.append(calc_parameters.get(mlist.models[-1].name, {}))
-        calc_pars[-1].update({"store": True})
+        calc_pars[-1]["store"] = True
 
         # 3) run post-rotor turbine models via farm controller:
         mlist.models.append(self.farm_controller)
@@ -463,7 +495,7 @@ class Downwind(Algorithm):
             calc_pars.append(calc_parameters.get(mlist.models[-1].name, {}))
 
         # 6) reorder back to state-turbine dimensions:
-        if outputs != False:
+        if not isinstance(outputs, bool) or outputs:
             mlist.models.append(self.get_model("ReorderFarmOutput")(outputs))
             calc_pars.append(calc_parameters.get(mlist.models[-1].name, {}))
 
@@ -476,7 +508,7 @@ class Downwind(Algorithm):
     def _launch_parallel_farm_calc(
         self,
         mlist,
-        *data,
+        model_data,
         outputs=None,
         normalize=False,
         **kwargs,
@@ -488,8 +520,8 @@ class Downwind(Algorithm):
         ----------
         mlist: foxes.models.FarmDataModelList
             The model list
-        data: tuple of xarray.Dataset
-            The (mdata, fdata) inputs
+        model_data: xarray.Dataset
+            The initial model data
         outputs: list of str, optional
             The output variables, or None for defaults
         normalize: bool
@@ -506,7 +538,7 @@ class Downwind(Algorithm):
         """
         out_vars = self.farm_vars if outputs is None else outputs
         farm_results = get_engine().run_calculation(
-            self, mlist, *data, out_vars=out_vars, **kwargs
+            self, mlist, model_data, out_vars=out_vars, **kwargs
         )
 
         if normalize:
@@ -573,8 +605,8 @@ class Downwind(Algorithm):
         # get input model data:
         model_data = self.get_models_data()
         self.print("\nInput data:\n\n", model_data, "\n")
-        self.print(f"\nFarm variables:", ", ".join(self.farm_vars))
-        self.print(f"\nOutput variables:", ", ".join(outputs))
+        self.print("\nFarm variables:", ", ".join(self.farm_vars))
+        self.print("\nOutput variables:", ", ".join(outputs))
 
         # run main calculation:
         farm_results = super().calc_farm(
@@ -779,7 +811,7 @@ class Downwind(Algorithm):
         if persist_mdata:
             model_data = model_data.persist()
         self.print("\nInput data:\n\n", model_data, "\n")
-        self.print(f"\nOutput farm variables:", ", ".join(self.farm_vars))
+        self.print("\nOutput farm variables:", ", ".join(self.farm_vars))
 
         # chunk farm results:
         self.print("\nInput farm data:\n\n", farm_results, "\n")
@@ -798,7 +830,7 @@ class Downwind(Algorithm):
 
         # check vars:
         ovars = mlist.output_point_vars(self) if outputs is None else outputs
-        self.print(f"\nOutput point variables:", ", ".join(ovars))
+        self.print("\nOutput point variables:", ", ".join(ovars))
 
         # calculate:
         point_results = super().calc_points(

foxes/algorithms/downwind/models/__init__.py

@@ -1,6 +1,6 @@
-from .set_amb_farm_results import SetAmbFarmResults
-from .set_amb_point_results import SetAmbPointResults
-from .farm_wakes_calc import FarmWakesCalculation
-from .point_wakes_calc import PointWakesCalculation
-from .init_farm_data import InitFarmData
-from .reorder_farm_output import ReorderFarmOutput
+from .set_amb_farm_results import SetAmbFarmResults as SetAmbFarmResults
+from .set_amb_point_results import SetAmbPointResults as SetAmbPointResults
+from .farm_wakes_calc import FarmWakesCalculation as FarmWakesCalculation
+from .point_wakes_calc import PointWakesCalculation as PointWakesCalculation
+from .init_farm_data import InitFarmData as InitFarmData
+from .reorder_farm_output import ReorderFarmOutput as ReorderFarmOutput

foxes/algorithms/downwind/models/farm_wakes_calc.py

@@ -1,7 +1,7 @@
 import numpy as np
 from copy import deepcopy
 
-from foxes.core import FarmDataModel, TData
+from foxes.core import FarmDataModel
 import foxes.constants as FC
 import foxes.variables as FV
 
@@ -69,8 +69,14 @@ class FarmWakesCalculation(FarmDataModel):
         for wname, wmodel in algo.wake_models.items():
             pwake = algo.partial_wakes[wname]
             if pwake.name not in pwake2tdata:
-                tpoints, tweights = pwake.get_wake_points(algo, mdata, fdata)
-                pwake2tdata[pwake.name] = TData.from_tpoints(tpoints, tweights)
+                wmodels = [
+                    wm
+                    for wn, wm in algo.wake_models.items()
+                    if algo.partial_wakes[wn] is pwake
+                ]
+                pwake2tdata[pwake.name] = pwake.get_initial_tdata(
+                    algo, mdata, fdata, amb_res, rwghts, wmodels
+                )
 
         def _get_wdata(tdatap, wdeltas, variables, s):
             """Helper function for wake data extraction"""
@@ -78,12 +84,10 @@ class FarmWakesCalculation(FarmDataModel):
             wdelta = {v: d[s] for v, d in wdeltas.items()}
             return tdata, wdelta
 
-        def _evaluate(
-            gmodel, tdata, amb_res, rwghts, wake_res, wdeltas, oi, wmodel, pwake
-        ):
+        def _evaluate(gmodel, tdata, rwghts, wake_res, wdeltas, oi, wmodel, pwake):
             """Helper function for data evaluation at turbines"""
             wres = gmodel.finalize_farm_wakes(
-                algo, mdata, fdata, tdata, amb_res, rwghts, wdeltas, wmodel, oi, pwake
+                algo, mdata, fdata, tdata, rwghts, wdeltas, wmodel, oi, pwake
             )
 
             hres = {
@@ -124,7 +128,6 @@ class FarmWakesCalculation(FarmDataModel):
                         _evaluate(
                             gmodel,
                             tdatap,
-                            amb_res,
                             rwghts,
                             wake_res,
                             wdeltas,
@@ -149,7 +152,6 @@ class FarmWakesCalculation(FarmDataModel):
                         _evaluate(
                             gmodel,
                             tdatap,
-                            amb_res,
                             rwghts,
                             wake_res,
                             wdeltas,

foxes/algorithms/downwind/models/init_farm_data.py

@@ -74,19 +74,18 @@ class InitFarmData(FarmDataModel):
         n_states = fdata.n_states
         n_turbines = algo.n_turbines
 
-        # define FV.TXYH as vector [X, Y, H]:
-        fdata[FV.TXYH] = np.full(
-            (n_states, n_turbines, 3), np.nan, dtype=config.dtype_double
+        # add and set X, Y, H, D:
+        fdata.add(
+            FV.TXYH,
+            np.zeros((n_states, n_turbines, 3), dtype=config.dtype_double),
+            (FC.STATE, FC.TURBINE, FC.XYH),
+        )
+        fdata.add(
+            FV.D,
+            np.zeros((n_states, n_turbines), dtype=config.dtype_double),
+            (FC.STATE, FC.TURBINE),
         )
-        fdata.dims[FV.TXYH] = (FC.STATE, FC.TURBINE, FC.XYH)
-        for i, v in enumerate([FV.X, FV.Y, FV.H]):
-            fdata[v] = fdata[FV.TXYH][..., i]
-            fdata.dims[v] = (FC.STATE, FC.TURBINE)
-
-        # set X, Y, H, D:
-        fdata[FV.D] = np.zeros((n_states, n_turbines), dtype=config.dtype_double)
         for ti, t in enumerate(algo.farm.turbines):
-
             if len(t.xy.shape) == 1:
                 fdata[FV.TXYH][:, ti, :2] = t.xy[None, :]
             else:
@@ -104,34 +103,64 @@ class InitFarmData(FarmDataModel):
                 D = algo.farm_controller.turbine_types[ti].D
             fdata[FV.D][:, ti] = D
 
-        # calc WD and YAW at rotor centres:
+        # calc WD at rotor centres:
         svrs = algo.states.output_point_vars(algo)
         tdata = TData.from_points(points=fdata[FV.TXYH], variables=svrs)
         sres = algo.states.calculate(algo, mdata, fdata, tdata)
-        fdata[FV.WD] = sres[FV.WD][:, :, 0]
+        fdata.add(
+            FV.WD,
+            sres[FV.WD][:, :, 0],
+            (FC.STATE, FC.TURBINE),
+        )
+        fdata.add(
+            FV.AMB_WD,
+            fdata[FV.WD].copy(),
+            (FC.STATE, FC.TURBINE),
+        )
         del tdata, sres, svrs
 
-        # calculate and inverse:
+        # calculate downwind order:
         order = algo.wake_frame.calc_order(algo, mdata, fdata)
         ssel = np.zeros_like(order)
         ssel[:] = np.arange(n_states)[:, None]
-        fdata[FV.ORDER] = order
-        fdata[FV.ORDER_SSEL] = ssel
-        fdata[FV.ORDER_INV] = np.zeros_like(order)
-        fdata[FV.ORDER_INV][ssel, order] = np.arange(n_turbines)[None, :]
 
         # apply downwind order to all data:
-        fdata[FV.TXYH] = fdata[FV.TXYH][ssel, order]
+        for data in [fdata, mdata]:
+            for k in data.keys():
+                if (
+                    k not in [FV.X, FV.Y, FV.H]
+                    and tuple(data.dims[k][:2]) == (FC.STATE, FC.TURBINE)
+                    and np.any(data[k] != data[k][0, 0, None, None])
+                ):
+                    data[k][:] = data[k][ssel, order]
+
+        # add derived data:
         for i, v in enumerate([FV.X, FV.Y, FV.H]):
-            fdata[v] = fdata[FV.TXYH][..., i]
-        for v in [FV.D, FV.WD]:
-            if np.any(fdata[v] != fdata[v][0, 0, None, None]):
-                fdata[v] = fdata[v][ssel, order]
-        fdata[FV.YAW] = fdata[FV.WD].copy()
-        for k in mdata.keys():
-            if tuple(mdata.dims[k][:2]) == (FC.STATE, FC.TURBINE) and np.any(
-                mdata[k] != mdata[k][0, 0, None, None]
-            ):
-                mdata[k] = mdata[k][ssel, order]
+            fdata.add(
+                v,
+                fdata[FV.TXYH][:, :, i],
+                (FC.STATE, FC.TURBINE),
+            )
+        fdata.add(
+            FV.YAW,
+            fdata[FV.WD].copy(),
+            (FC.STATE, FC.TURBINE),
+        )
+        fdata.add(
+            FV.ORDER,
+            order,
+            (FC.STATE, FC.TURBINE),
+        )
+        fdata.add(
+            FV.ORDER_SSEL,
+            ssel,
+            (FC.STATE, FC.TURBINE),
+        )
+        fdata.add(
+            FV.ORDER_INV,
+            np.zeros_like(order),
+            (FC.STATE, FC.TURBINE),
+        )
+        fdata[FV.ORDER_INV][ssel, order] = np.arange(n_turbines)[None, :]
 
         return {v: fdata[v] for v in self.output_farm_vars(algo)}

foxes/algorithms/downwind/models/point_wakes_calc.py

@@ -1,4 +1,5 @@
 from foxes.core import PointDataModel
+import foxes.variables as FV
 
 
 class PointWakesCalculation(PointDataModel):
@@ -114,17 +115,17 @@ class PointWakesCalculation(PointDataModel):
             (n_states, n_targets, n_tpoints)
 
         """
-        res = {}
+
         wmodels = (
             algo.wake_models.values() if self.wake_models is None else self.wake_models
         )
+        pvrs = self.pvars + [FV.UV]
         for wmodel in wmodels:
             gmodel = algo.ground_models[wmodel.name]
 
             wdeltas = gmodel.new_point_wake_deltas(algo, mdata, fdata, tdata, wmodel)
 
-            if len(set(self.pvars).intersection(wdeltas.keys())):
-
+            if len(set(pvrs).intersection(wdeltas.keys())):
                 if downwind_index is None:
                     for oi in range(fdata.n_turbines):
                         gmodel.contribute_to_point_wakes(
@@ -135,18 +136,11 @@ class PointWakesCalculation(PointDataModel):
                         algo, mdata, fdata, tdata, downwind_index, wdeltas, wmodel
                     )
 
-                for v in self.pvars:
-                    if v not in res and v in tdata:
-                        res[v] = tdata[v].copy()
+                gmodel.finalize_point_wakes(algo, mdata, fdata, tdata, wdeltas, wmodel)
 
-                gmodel.finalize_point_wakes(algo, mdata, fdata, res, wdeltas, wmodel)
-
-                for v in res.keys():
+                for v in tdata.keys():
                     if v in wdeltas:
-                        res[v] += wdeltas[v]
-
-        for v in res.keys():
-            tdata[v] = res[v]
+                        tdata[v] += wdeltas[v]
 
         if self.emodels is not None:
             self.emodels.calculate(algo, mdata, fdata, tdata, self.emodels_cpars)

foxes/algorithms/downwind/models/set_amb_farm_results.py

@@ -65,5 +65,5 @@ class SetAmbFarmResults(FarmDataModel):
 
         """
         for v in self.vars:
-            fdata[FV.var2amb[v]] = fdata[v].copy()
+            fdata.add(FV.var2amb[v], fdata[v].copy(), fdata.dims[v])
         return {v: fdata[v] for v in self.output_farm_vars(algo)}

foxes/algorithms/downwind/models/set_amb_point_results.py

@@ -60,7 +60,7 @@ class SetAmbPointResults(PointDataModel):
         """
         return [FV.var2amb[v] for v in self.vars] + [FV.WEIGHT]
 
-    def calculate(self, algo, mdata, fdata, pdata):
+    def calculate(self, algo, mdata, fdata, tdata):
         """
         The main model calculation.
 
@@ -71,11 +71,11 @@ class SetAmbPointResults(PointDataModel):
         ----------
         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
+        tdata: foxes.core.TData
             The point data
 
         Returns
@@ -86,5 +86,5 @@ class SetAmbPointResults(PointDataModel):
 
         """
         for v in self.vars:
-            pdata[FV.var2amb[v]] = pdata[v].copy()
-        return {v: pdata[v] for v in self.output_point_vars(algo)}
+            tdata.add(FV.var2amb[v], tdata[v].copy(), tdata.dims[v])
+        return {v: tdata[v] for v in self.output_point_vars(algo)}

foxes/algorithms/iterative/__init__.py

@@ -1,4 +1,8 @@
-from .iterative import Iterative
-from .models.convergence import ConvCrit, ConvCritList, ConvVarDelta, DefaultConv
+from .iterative import Iterative as Iterative
 
-from . import models
+from .models.convergence import ConvCrit as ConvCrit
+from .models.convergence import ConvCritList as ConvCritList
+from .models.convergence import ConvVarDelta as ConvVarDelta
+from .models.convergence import DefaultConv as DefaultConv
+
+from . import models as models

foxes/algorithms/iterative/iterative.py

@@ -114,7 +114,7 @@ class Iterative(Downwind):
 
         """
         if self.initialized:
-            raise ValueError(f"Attempt to set_urelax after initialization")
+            raise ValueError("Attempt to set_urelax after initialization")
         if self._urelax is None:
             self._urelax = Dict(
                 first={},
@@ -219,7 +219,6 @@ class Iterative(Downwind):
 
             # do not rotate back from downwind order:
             if not self._final_run:
-
                 # add under-relaxation during wake calculation:
                 urelax = None
                 if self._urelax is not None and len(self._urelax["pre_wake"]):

foxes/algorithms/iterative/models/__init__.py

@@ -1,3 +1,7 @@
-from .convergence import ConvCrit, ConvCritList, ConvVarDelta, DefaultConv
-from .farm_wakes_calc import FarmWakesCalculation
-from .urelax import URelax
+from .convergence import ConvCrit as ConvCrit
+from .convergence import ConvCritList as ConvCritList
+from .convergence import ConvVarDelta as ConvVarDelta
+from .convergence import DefaultConv as DefaultConv
+
+from .farm_wakes_calc import FarmWakesCalculation as FarmWakesCalculation
+from .urelax import URelax as URelax