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

foxes/__init__.py

@@ -1,26 +1,30 @@
 """
 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 .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  # 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 . 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
@@ -61,8 +63,6 @@ class Downwind(Algorithm):
         FV.TI,
         FV.CT,
         FV.P,
-        FV.ORDER,
-        FV.WEIGHT,
     ]
 
     def __init__(
@@ -72,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",
@@ -96,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
@@ -125,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)
@@ -253,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):
         """
@@ -312,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
@@ -336,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()
@@ -366,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):
@@ -404,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())
@@ -447,9 +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_rpoints": True, "store_rweights": True, "store_amb_res": True}
-        )
+        calc_pars[-1].update({"store": True})
 
         # 3) run post-rotor turbine models via farm controller:
         mlist.models.append(self.farm_controller)
@@ -467,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, {}))
 
@@ -475,13 +503,14 @@ class Downwind(Algorithm):
 
     def _calc_farm_vars(self, mlist):
         """Helper function that gathers the farm variables"""
-        self.farm_vars = sorted(list(set([FV.WEIGHT] + mlist.output_farm_vars(self))))
+        self.farm_vars = sorted(list(mlist.output_farm_vars(self)))
 
     def _launch_parallel_farm_calc(
         self,
         mlist,
         *data,
         outputs=None,
+        normalize=False,
         **kwargs,
     ):
         """
@@ -495,6 +524,8 @@ class Downwind(Algorithm):
             The (mdata, fdata) inputs
         outputs: list of str, optional
             The output variables, or None for defaults
+        normalize: bool
+            Normalize the weights to 1 wrt sum over states
         kwargs: dict, optional
             Additional parameters for running
 
@@ -510,6 +541,9 @@ class Downwind(Algorithm):
             self, mlist, *data, out_vars=out_vars, **kwargs
         )
 
+        if normalize:
+            farm_results[FV.WEIGHT] /= farm_results[FV.WEIGHT].sum(dim=FC.STATE)
+
         return farm_results
 
     def calc_farm(
@@ -571,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(
@@ -679,13 +713,7 @@ class Downwind(Algorithm):
         """
         return (
             get_engine()
-            .run_calculation(
-                self,
-                mlist,
-                *data,
-                out_vars=outputs,
-                **kwargs,
-            )
+            .run_calculation(self, mlist, *data, out_vars=outputs, **kwargs)
             .sel({FC.TPOINT: 0})
             .rename({FC.TARGET: FC.POINT})
         )
@@ -783,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")
@@ -802,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(
@@ -812,8 +840,6 @@ class Downwind(Algorithm):
             point_data,
             outputs=ovars,
             parameters=calc_pars,
-            # sel=sel,
-            # isel=isel,
             **kwargs,
         )
         del model_data, farm_results, point_data

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,8 +1,9 @@
 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
 
 
 class FarmWakesCalculation(FarmDataModel):
@@ -58,8 +59,9 @@ class FarmWakesCalculation(FarmDataModel):
         """
         # collect ambient rotor results and weights:
         rotor = algo.rotor_model
-        weights = algo.get_from_chunk_store(FC.ROTOR_WEIGHTS, mdata=mdata)
+        rwghts = algo.get_from_chunk_store(FC.ROTOR_WEIGHTS, mdata=mdata)
         amb_res = algo.get_from_chunk_store(FC.AMB_ROTOR_RES, mdata=mdata)
+        weights = algo.get_from_chunk_store(FC.WEIGHT_RES, mdata=mdata)
 
         # generate all wake evaluation points
         # (n_states, n_order, n_rpoints)
@@ -67,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"""
@@ -76,21 +84,23 @@ class FarmWakesCalculation(FarmDataModel):
             wdelta = {v: d[s] for v, d in wdeltas.items()}
             return tdata, wdelta
 
-        def _evaluate(
-            gmodel, tdata, amb_res, weights, 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, weights, wdeltas, wmodel, oi, pwake
+                algo, mdata, fdata, tdata, rwghts, wdeltas, wmodel, oi, pwake
             )
 
-            hres = {v: d[:, oi, None] for v, d in wake_res.items()}
+            hres = {
+                v: d[:, oi, None] if d.shape[1] > 1 else d[:, 0, None]
+                for v, d in wake_res.items()
+            }
             for v, d in wres.items():
                 if v in wake_res:
                     hres[v] += d[:, None]
+            hres[FV.WEIGHT] = weights
 
             rotor.eval_rpoint_results(
-                algo, mdata, fdata, hres, weights, downwind_index=oi
+                algo, mdata, fdata, hres, rwghts, downwind_index=oi
             )
 
             res = algo.farm_controller.calculate(
@@ -118,8 +128,7 @@ class FarmWakesCalculation(FarmDataModel):
                         _evaluate(
                             gmodel,
                             tdatap,
-                            amb_res,
-                            weights,
+                            rwghts,
                             wake_res,
                             wdeltas,
                             oi,
@@ -143,8 +152,7 @@ class FarmWakesCalculation(FarmDataModel):
                         _evaluate(
                             gmodel,
                             tdatap,
-                            amb_res,
-                            weights,
+                            rwghts,
                             wake_res,
                             wdeltas,
                             oi,

foxes/algorithms/downwind/models/init_farm_data.py

@@ -43,7 +43,6 @@ class InitFarmData(FarmDataModel):
             FV.WD,
             FV.YAW,
             FV.ORDER,
-            FV.WEIGHT,
             FV.ORDER_SSEL,
             FV.ORDER_INV,
         ]
@@ -87,7 +86,6 @@ class InitFarmData(FarmDataModel):
         # 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:
@@ -106,10 +104,11 @@ class InitFarmData(FarmDataModel):
             fdata[FV.D][:, ti] = D
 
         # calc WD and YAW at rotor centres:
-        tdata = TData.from_points(points=fdata[FV.TXYH])
+        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]
-        del tdata, sres
+        del tdata, sres, svrs
 
         # calculate and inverse:
         order = algo.wake_frame.calc_order(algo, mdata, fdata)
@@ -124,7 +123,7 @@ class InitFarmData(FarmDataModel):
         fdata[FV.TXYH] = fdata[FV.TXYH][ssel, order]
         for i, v in enumerate([FV.X, FV.Y, FV.H]):
             fdata[v] = fdata[FV.TXYH][..., i]
-        for v in [FV.D, FV.WD, FV.WEIGHT]:
+        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()

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/reorder_farm_output.py

@@ -75,7 +75,11 @@ class ReorderFarmOutput(FarmDataModel):
 
         out = {}
         for v in self.output_farm_vars(algo):
-            if v != FV.ORDER and np.any(fdata[v] != fdata[v][0, 0, None, None]):
+            if (
+                v != FV.ORDER
+                and fdata[v].shape[1] > 1
+                and np.any(fdata[v] != fdata[v][0, 0, None, None])
+            ):
                 out[v] = fdata[v][ssel, order_inv]
             else:
                 out[v] = fdata[v]

foxes/algorithms/downwind/models/set_amb_point_results.py

@@ -58,9 +58,9 @@ class SetAmbPointResults(PointDataModel):
             The output variable names
 
         """
-        return [FV.var2amb[v] for v in self.vars]
+        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

foxes/algorithms/iterative/models/farm_wakes_calc.py

@@ -1,8 +1,9 @@
 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
 
 
 class FarmWakesCalculation(FarmDataModel):
@@ -88,8 +89,9 @@ class FarmWakesCalculation(FarmDataModel):
         """
         # collect ambient rotor results and weights:
         rotor = algo.rotor_model
-        weights = algo.get_from_chunk_store(FC.ROTOR_WEIGHTS, mdata=mdata)
+        rwghts = algo.get_from_chunk_store(FC.ROTOR_WEIGHTS, mdata=mdata)
         amb_res = algo.get_from_chunk_store(FC.AMB_ROTOR_RES, mdata=mdata)
+        weights = algo.get_from_chunk_store(FC.WEIGHT_RES, mdata=mdata)
 
         # generate all wake evaluation points
         # (n_states, n_order, n_rpoints)
@@ -97,8 +99,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"""
@@ -115,7 +123,6 @@ class FarmWakesCalculation(FarmDataModel):
             wdeltas = pwake.new_wake_deltas(algo, mdata, fdata, tdatap, wmodel)
 
             for oi in range(n_turbines):
-
                 if oi > 0:
                     tdata, wdelta = _get_wdata(
                         tdatap, wdeltas, [FC.STATE, FC.TARGET], np.s_[:, :oi]
@@ -138,8 +145,7 @@ class FarmWakesCalculation(FarmDataModel):
                     mdata,
                     fdata,
                     tdatap,
-                    amb_res,
-                    weights,
+                    rwghts,
                     wdeltas,
                     wmodel,
                     oi,
@@ -151,7 +157,8 @@ class FarmWakesCalculation(FarmDataModel):
 
             del pwake, tdatap, wdeltas
 
-        rotor.eval_rpoint_results(algo, mdata, fdata, wake_res, weights)
+        wake_res[FV.WEIGHT] = weights
+        rotor.eval_rpoint_results(algo, mdata, fdata, wake_res, rwghts)
         res = algo.farm_controller.calculate(algo, mdata, fdata, pre_rotor=False)
         if self.urelax is not None:
             res = self.urelax.calculate(algo, mdata, fdata, res)

foxes/algorithms/sequential/__init__.py

@@ -1,4 +1,4 @@
-from .sequential import Sequential
-from .models import SequentialPlugin
+from .sequential import Sequential as Sequential
+from .models import SequentialPlugin as SequentialPlugin
 
-from . import models
+from . import models as models

foxes/algorithms/sequential/models/__init__.py

@@ -1,2 +1,2 @@
-from .plugin import SequentialPlugin
-from .seq_state import SeqState
+from .plugin import SequentialPlugin as SequentialPlugin
+from .seq_state import SeqState as SeqState