foxes 0.6.1__py3-none-any.whl → 0.7__py3-none-any.whl

foxes/models/wake_superpositions/ws_pow.py

@@ -49,6 +49,10 @@ class WSPow(WakeSuperposition):
         self.lim_low = lim_low
         self.lim_high = lim_high
 
+    def __repr__(self):
+        a = f"pow={self.pow}, scale_amb={self.scale_amb}, lim_low={self.lim_low}, lim_high={self.lim_high}"
+        return f"{type(self).__name__}({a})"
+
     def input_farm_vars(self, algo):
         """
         The variables which are needed for running
@@ -67,48 +71,51 @@ class WSPow(WakeSuperposition):
         """
         return [FV.AMB_REWS] if self.scale_amb else [FV.REWS]
 
-    def calc_wakes_plus_wake(
+    def add_wake(
         self,
         algo,
         mdata,
         fdata,
-        pdata,
-        states_source_turbine,
-        sel_sp,
+        tdata,
+        downwind_index,
+        st_sel,
         variable,
         wake_delta,
         wake_model_result,
     ):
         """
-        Add a wake delta to previous wake deltas.
+        Add a wake delta to previous wake deltas,
+        at rotor points.
 
         Parameters
         ----------
         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
-            The evaluation point data
-        states_source_turbine: numpy.ndarray
-            For each state, one turbine index for the
-            wake causing turbine. Shape: (n_states,)
-        sel_sp: numpy.ndarray of bool
-            The selection of points, shape: (n_states, n_points)
+        tdata: foxes.core.TData
+            The target point data
+        downwind_index: int
+            The index of the wake causing turbine
+            in the downwnd order
+        st_sel: numpy.ndarray of bool
+            The selection of targets, shape: (n_states, n_targets)
         variable: str
             The variable name for which the wake deltas applies
         wake_delta: numpy.ndarray
-            The original wake deltas, shape: (n_states, n_points)
+            The original wake deltas, shape:
+            (n_states, n_targets, n_tpoints, ...)
         wake_model_result: numpy.ndarray
-            The new wake deltas of the selected points,
-            shape: (n_sel_sp,)
+            The new wake deltas of the selected rotors,
+            shape: (n_st_sel, n_tpoints, ...)
 
         Returns
         -------
         wdelta: numpy.ndarray
-            The updated wake deltas, shape: (n_states, n_points)
+            The updated wake deltas, shape:
+            (n_states, n_targets, n_tpoints, ...)
 
         """
         if variable not in [FV.REWS, FV.REWS2, FV.REWS3, FV.WS]:
@@ -116,19 +123,19 @@ class WSPow(WakeSuperposition):
                 f"Superposition '{self.name}': Expecting wind speed variable, got {variable}"
             )
 
-        if np.any(sel_sp):
+        if np.any(st_sel):
             scale = self.get_data(
                 FV.AMB_REWS if self.scale_amb else FV.REWS,
-                FC.STATE_POINT,
+                FC.STATE_TARGET,
                 lookup="w",
                 algo=algo,
                 fdata=fdata,
-                pdata=pdata,
+                tdata=tdata,
+                downwind_index=downwind_index,
                 upcast=True,
-                states_source_turbine=states_source_turbine,
-            )[sel_sp]
+            )[st_sel, None]
 
-            wake_delta[sel_sp] += np.abs(scale * wake_model_result) ** self.pow
+            wake_delta[st_sel] += np.abs(scale * wake_model_result) ** self.pow
 
         return wake_delta
 
@@ -137,7 +144,6 @@ class WSPow(WakeSuperposition):
         algo,
         mdata,
         fdata,
-        pdata,
         variable,
         amb_results,
         wake_delta,
@@ -150,24 +156,25 @@ class WSPow(WakeSuperposition):
         ----------
         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
-            The evaluation point data
         variable: str
             The variable name for which the wake deltas applies
         amb_results: numpy.ndarray
-            The ambient results, shape: (n_states, n_points)
+            The ambient results at targets,
+            shape: (n_states, n_targets, n_tpoints)
         wake_delta: numpy.ndarray
-            The wake deltas, shape: (n_states, n_points)
+            The wake deltas at targets, shape:
+            (n_states, n_targets, n_tpoints)
 
         Returns
         -------
         final_wake_delta: numpy.ndarray
             The final wake delta, which will be added to the ambient
-            results by simple plus operation. Shape: (n_states, n_points)
+            results by simple plus operation. Shape:
+            (n_states, n_targets, n_tpoints)
 
         """
         w = -(wake_delta ** (1 / self.pow))

foxes/models/wake_superpositions/ws_product.py

@@ -45,6 +45,10 @@ class WSProduct(WakeSuperposition):
         self.lim_low = lim_low
         self.lim_high = lim_high
 
+    def __repr__(self):
+        a = f"lim_low={self.lim_low}, lim_high={self.lim_high}"
+        return f"{type(self).__name__}({a})"
+
     def input_farm_vars(self, algo):
         """
         The variables which are needed for running
@@ -63,48 +67,51 @@ class WSProduct(WakeSuperposition):
         """
         return [FV.AMB_REWS] if self.scale_amb else [FV.REWS]
 
-    def calc_wakes_plus_wake(
+    def add_wake(
         self,
         algo,
         mdata,
         fdata,
-        pdata,
-        states_source_turbine,
-        sel_sp,
+        tdata,
+        downwind_index,
+        st_sel,
         variable,
         wake_delta,
         wake_model_result,
     ):
         """
-        Add a wake delta to previous wake deltas.
+        Add a wake delta to previous wake deltas,
+        at rotor points.
 
         Parameters
         ----------
         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
-            The evaluation point data
-        states_source_turbine: numpy.ndarray
-            For each state, one turbine index for the
-            wake causing turbine. Shape: (n_states,)
-        sel_sp: numpy.ndarray of bool
-            The selection of points, shape: (n_states, n_points)
+        tdata: foxes.core.TData
+            The target point data
+        downwind_index: int
+            The index of the wake causing turbine
+            in the downwnd order
+        st_sel: numpy.ndarray of bool
+            The selection of targets, shape: (n_states, n_targets)
         variable: str
             The variable name for which the wake deltas applies
         wake_delta: numpy.ndarray
-            The original wake deltas, shape: (n_states, n_points)
+            The original wake deltas, shape:
+            (n_states, n_targets, n_tpoints, ...)
         wake_model_result: numpy.ndarray
-            The new wake deltas of the selected points,
-            shape: (n_sel_sp,)
+            The new wake deltas of the selected rotors,
+            shape: (n_st_sel, n_tpoints, ...)
 
         Returns
         -------
         wdelta: numpy.ndarray
-            The updated wake deltas, shape: (n_states, n_points)
+            The updated wake deltas, shape:
+            (n_states, n_targets, n_tpoints, ...)
 
         """
         if variable not in [FV.REWS, FV.REWS2, FV.REWS3, FV.WS]:
@@ -112,11 +119,11 @@ class WSProduct(WakeSuperposition):
                 f"Superposition '{self.name}': Expecting wind speed variable, got {variable}"
             )
 
-        if np.any(sel_sp):
+        if np.any(st_sel):
             if np.max(np.abs(wake_delta)) < 1e-14:
                 wake_delta[:] = 1
 
-            wake_delta[sel_sp] *= 1 + wake_model_result
+            wake_delta[st_sel] *= 1 + wake_model_result
 
         return wake_delta
 
@@ -125,7 +132,6 @@ class WSProduct(WakeSuperposition):
         algo,
         mdata,
         fdata,
-        pdata,
         variable,
         amb_results,
         wake_delta,
@@ -138,24 +144,25 @@ class WSProduct(WakeSuperposition):
         ----------
         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
-            The evaluation point data
         variable: str
             The variable name for which the wake deltas applies
         amb_results: numpy.ndarray
-            The ambient results, shape: (n_states, n_points)
+            The ambient results at targets,
+            shape: (n_states, n_targets, n_tpoints)
         wake_delta: numpy.ndarray
-            The wake deltas, shape: (n_states, n_points)
+            The wake deltas at targets, shape:
+            (n_states, n_targets, n_tpoints)
 
         Returns
         -------
         final_wake_delta: numpy.ndarray
             The final wake delta, which will be added to the ambient
-            results by simple plus operation. Shape: (n_states, n_points)
+            results by simple plus operation. Shape:
+            (n_states, n_targets, n_tpoints)
 
         """
         w = amb_results * (wake_delta - 1)

foxes/models/wake_superpositions/ws_quadratic.py

@@ -44,6 +44,10 @@ class WSQuadratic(WakeSuperposition):
         self.lim_low = lim_low
         self.lim_high = lim_high
 
+    def __repr__(self):
+        a = f"scale_amb={self.scale_amb}, lim_low={self.lim_low}, lim_high={self.lim_high}"
+        return f"{type(self).__name__}({a})"
+
     def input_farm_vars(self, algo):
         """
         The variables which are needed for running
@@ -62,48 +66,51 @@ class WSQuadratic(WakeSuperposition):
         """
         return [FV.AMB_REWS] if self.scale_amb else [FV.REWS]
 
-    def calc_wakes_plus_wake(
+    def add_wake(
         self,
         algo,
         mdata,
         fdata,
-        pdata,
-        states_source_turbine,
-        sel_sp,
+        tdata,
+        downwind_index,
+        st_sel,
         variable,
         wake_delta,
         wake_model_result,
     ):
         """
-        Add a wake delta to previous wake deltas.
+        Add a wake delta to previous wake deltas,
+        at rotor points.
 
         Parameters
         ----------
         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
-            The evaluation point data
-        states_source_turbine: numpy.ndarray
-            For each state, one turbine index for the
-            wake causing turbine. Shape: (n_states,)
-        sel_sp: numpy.ndarray of bool
-            The selection of points, shape: (n_states, n_points)
+        tdata: foxes.core.TData
+            The target point data
+        downwind_index: int
+            The index of the wake causing turbine
+            in the downwnd order
+        st_sel: numpy.ndarray of bool
+            The selection of targets, shape: (n_states, n_targets)
         variable: str
             The variable name for which the wake deltas applies
         wake_delta: numpy.ndarray
-            The original wake deltas, shape: (n_states, n_points)
+            The original wake deltas, shape:
+            (n_states, n_targets, n_tpoints, ...)
         wake_model_result: numpy.ndarray
-            The new wake deltas of the selected points,
-            shape: (n_sel_sp,)
+            The new wake deltas of the selected rotors,
+            shape: (n_st_sel, n_tpoints, ...)
 
         Returns
         -------
         wdelta: numpy.ndarray
-            The updated wake deltas, shape: (n_states, n_points)
+            The updated wake deltas, shape:
+            (n_states, n_targets, n_tpoints, ...)
 
         """
         if variable not in [FV.REWS, FV.REWS2, FV.REWS3, FV.WS]:
@@ -111,19 +118,19 @@ class WSQuadratic(WakeSuperposition):
                 f"Superposition '{self.name}': Expecting wind speed variable, got {variable}"
             )
 
-        if np.any(sel_sp):
+        if np.any(st_sel):
             scale = self.get_data(
                 FV.AMB_REWS if self.scale_amb else FV.REWS,
-                FC.STATE_POINT,
+                FC.STATE_TARGET,
                 lookup="w",
                 algo=algo,
                 fdata=fdata,
-                pdata=pdata,
+                tdata=tdata,
+                downwind_index=downwind_index,
                 upcast=True,
-                states_source_turbine=states_source_turbine,
-            )[sel_sp]
+            )[st_sel, None]
 
-            wake_delta[sel_sp] += (scale * wake_model_result) ** 2
+            wake_delta[st_sel] += (scale * wake_model_result) ** 2
 
         return wake_delta
 
@@ -132,7 +139,6 @@ class WSQuadratic(WakeSuperposition):
         algo,
         mdata,
         fdata,
-        pdata,
         variable,
         amb_results,
         wake_delta,
@@ -145,24 +151,25 @@ class WSQuadratic(WakeSuperposition):
         ----------
         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
-            The evaluation point data
         variable: str
             The variable name for which the wake deltas applies
         amb_results: numpy.ndarray
-            The ambient results, shape: (n_states, n_points)
+            The ambient results at targets,
+            shape: (n_states, n_targets, n_tpoints)
         wake_delta: numpy.ndarray
-            The wake deltas, shape: (n_states, n_points)
+            The wake deltas at targets, shape:
+            (n_states, n_targets, n_tpoints)
 
         Returns
         -------
         final_wake_delta: numpy.ndarray
             The final wake delta, which will be added to the ambient
-            results by simple plus operation. Shape: (n_states, n_points)
+            results by simple plus operation. Shape:
+            (n_states, n_targets, n_tpoints)
 
         """
         w = -np.sqrt(wake_delta)

foxes/opt/constraints/min_dist.py

@@ -202,7 +202,7 @@ class MinDistConstraint(FarmConstraint):
         """
         n_pop = problem_results["n_pop"].values
         n_states = problem_results["n_org_states"].values
-        n_turbines = problem_results.dims[FC.TURBINE]
+        n_turbines = problem_results.sizes[FC.TURBINE]
 
         xy = np.stack(
             [problem_results[FV.X].to_numpy(), problem_results[FV.Y].to_numpy()],

foxes/opt/objectives/farm_vars.py

@@ -208,7 +208,7 @@ class FarmVarObjective(FarmObjective):
         """
         n_pop = problem_results["n_pop"].values
         n_states = problem_results["n_org_states"].values
-        n_turbines = problem_results.dims[FC.TURBINE]
+        n_turbines = problem_results.sizes[FC.TURBINE]
         data = (
             problem_results[self.variable]
             .to_numpy()

foxes/opt/problems/layout/farm_layout.py

@@ -1,11 +1,11 @@
 import numpy as np
 
-from foxes.opt.core import FarmVarsProblem
+from foxes.opt.core.farm_opt_problem import FarmOptProblem
 import foxes.variables as FV
 import foxes.constants as FC
 
 
-class FarmLayoutOptProblem(FarmVarsProblem):
+class FarmLayoutOptProblem(FarmOptProblem):
     """
     The turbine positioning optimization problem
 
@@ -79,118 +79,59 @@ class FarmLayoutOptProblem(FarmVarsProblem):
         out[:] = b.p_max()[None, :]
         return out.reshape(self.n_sel_turbines * 2)
 
-    def initialize(self, verbosity=1, **kwargs):
+    def update_problem_individual(self, vars_int, vars_float):
         """
-        Initialize the object.
+        Update the algo and other data using
+        the latest optimization variables.
 
-        Parameters
-        ----------
-        verbosity: int
-            The verbosity level, 0 = silent
-        kwargs: dict, optional
-            Additional parameters for super class init
-
-        """
-        super().initialize(
-            pre_rotor_vars=[FV.X, FV.Y],
-            post_rotor_vars=[],
-            verbosity=verbosity,
-            **kwargs,
-        )
-
-    def opt2farm_vars_individual(self, vars_int, vars_float):
-        """
-        Translates optimization variables to farm variables
+        This function is called before running the farm
+        calculation.
 
         Parameters
         ----------
-        vars_int: numpy.ndarray
-            The integer optimization variable values,
-            shape: (n_vars_int,)
-        vars_float: numpy.ndarray
-            The float optimization variable values,
-            shape: (n_vars_float,)
-
-        Returns
-        -------
-        farm_vars: dict
-            The foxes farm variables. Key: var name,
-            value: numpy.ndarray with values, shape:
-            (n_states, n_sel_turbines)
-
-        """
-        farm_vars = {
-            FV.X: np.zeros((self.algo.n_states, self.n_sel_turbines), dtype=FC.DTYPE),
-            FV.Y: np.zeros((self.algo.n_states, self.n_sel_turbines), dtype=FC.DTYPE),
-        }
-        xy = vars_float.reshape(self.n_sel_turbines, 2)
-        farm_vars[FV.X][:] = xy[None, :, 0]
-        farm_vars[FV.Y][:] = xy[None, :, 1]
-
-        return farm_vars
+        vars_int: np.array
+            The integer variable values, shape: (n_vars_int,)
+        vars_float: np.array
+            The float variable values, shape: (n_vars_float,)
 
-    def opt2farm_vars_population(self, vars_int, vars_float, n_states):
         """
-        Translates optimization variables to farm variables
-
-        Parameters
-        ----------
-        vars_int: numpy.ndarray
-            The integer optimization variable values,
-            shape: (n_pop, n_vars_int)
-        vars_float: numpy.ndarray
-            The float optimization variable values,
-            shape: (n_pop, n_vars_float)
-        n_states: int
-            The number of original (non-pop) states
+        super().update_problem_individual(vars_int, vars_float)
 
-        Returns
-        -------
-        farm_vars: dict
-            The foxes farm variables. Key: var name,
-            value: numpy.ndarray with values, shape:
-            (n_pop, n_states, n_sel_turbines)
+        xy = vars_float.reshape(self.n_sel_turbines, 2)
+        for i, ti in enumerate(self.sel_turbines):
+            t = self.algo.farm.turbines[ti]
+            t.xy = xy[i]
 
+    def update_problem_population(self, vars_int, vars_float):
         """
-        n_pop = len(vars_float)
-        farm_vars = {
-            FV.X: np.zeros((n_pop, n_states, self.n_sel_turbines), dtype=FC.DTYPE),
-            FV.Y: np.zeros((n_pop, n_states, self.n_sel_turbines), dtype=FC.DTYPE),
-        }
-        xy = vars_float.reshape(n_pop, self.n_sel_turbines, 2)
-        farm_vars[FV.X][:] = xy[:, None, :, 0]
-        farm_vars[FV.Y][:] = xy[:, None, :, 1]
-
-        return farm_vars
+        Update the algo and other data using
+        the latest optimization variables.
 
-    def finalize_individual(self, vars_int, vars_float, verbosity=1):
-        """
-        Finalization, given the champion data.
+        This function is called before running the farm
+        calculation.
 
         Parameters
         ----------
         vars_int: np.array
-            The optimal integer variable values, shape: (n_vars_int,)
+            The integer variable values, shape: (n_pop, n_vars_int,)
         vars_float: np.array
-            The optimal float variable values, shape: (n_vars_float,)
-        verbosity: int
-            The verbosity level, 0 = silent
-
-        Returns
-        -------
-        problem_results: Any
-            The results of the variable application
-            to the problem
-        objs: np.array
-            The objective function values, shape: (n_objectives,)
-        cons: np.array
-            The constraints values, shape: (n_constraints,)
+            The float variable values, shape: (n_pop, n_vars_float,)
 
         """
-        res, objs, cons = super().finalize_individual(vars_int, vars_float, verbosity)
+        super().update_problem_population(vars_int, vars_float)
 
-        xy = vars_float.reshape(self.n_sel_turbines, 2)
-        for i, ti in enumerate(self.sel_turbines):
-            self.farm.turbines[ti].xy = xy[i]
+        n_pop = len(vars_float)
+        n_ostates = self._org_n_states
+        n_states = n_pop * n_ostates
 
-        return res, objs, cons
+        xy = vars_float.reshape(n_pop, self.n_sel_turbines, 2)
+        sxy = np.zeros(
+            (n_pop, n_ostates, self.n_sel_turbines, 2), dtype=vars_float.dtype
+        )
+        sxy[:] = xy[:, None, :, :]
+        sxy = sxy.reshape(n_states, self.n_sel_turbines, 2)
+        del xy
+
+        for i, ti in enumerate(self.sel_turbines):
+            t = self.algo.farm.turbines[ti]
+            t.xy = sxy[:, i]

foxes/output/__init__.py

@@ -13,6 +13,7 @@ from .turbine_type_curves import TurbineTypeCurves
 from .animation import Animator
 from .calc_points import PointCalculator
 from .slice_data import SliceData
+from .rotor_point_plots import RotorPointPlot
 
 from .flow_plots_2d import FlowPlots2D, SeqFlowAnimationPlugin
 from . import grids

foxes/output/farm_results_eval.py

@@ -106,7 +106,7 @@ class FarmResultsEval(Output):
             The results per turbine
 
         """
-        n_turbines = self.results.dims[FC.TURBINE]
+        n_turbines = self.results.sizes[FC.TURBINE]
 
         rdata = {}
         for v, op in vars_op.items():

foxes/output/flow_plots_2d/flow_plots.py

@@ -725,6 +725,7 @@ class FlowPlots2D(SliceData):
             data_format="numpy",
             ret_states=True,
             ret_grid=True,
+            x_direction=x_direction,
             **kwargs,
         )
         x_pos, y_pos, z_pos, __ = gdata
@@ -898,6 +899,7 @@ class FlowPlots2D(SliceData):
             data_format="numpy",
             ret_states=True,
             ret_grid=True,
+            x_direction=x_direction,
             **kwargs,
         )
         x_pos, y_pos, z_pos, __ = gdata

foxes/output/flow_plots_2d/get_fig.py

@@ -150,6 +150,8 @@ def get_fig(
     hax.set_xlabel(xlabel)
     hax.set_ylabel(ylabel)
     hax.set_aspect("equal", adjustable="box")
+    hax.set_xlim(x_pos.min(), x_pos.max())
+    hax.set_ylim(y_pos.min(), y_pos.max())
 
     ttl = None
     if animated:

foxes/output/grids.py

@@ -688,7 +688,7 @@ def data2xr(
         and isinstance(state_mean, bool)
         and not state_mean
     ):
-        if point_results.dims[FC.STATE] > 1:
+        if point_results.sizes[FC.STATE] > 1:
             coords[FC.STATE] = point_results[FC.STATE].to_numpy()
         else:
             attrs[FC.STATE] = str(point_results[FC.STATE][0].to_numpy())