foxes 0.8.2__py3-none-any.whl → 1.1.0.2__py3-none-any.whl

foxes/output/seq_plugins/seq_wake_debug_plugin.py

@@ -0,0 +1,145 @@
+from foxes.algorithms.sequential import SequentialPlugin
+from foxes.models.wake_frames.seq_dynamic_wakes import SeqDynamicWakes
+
+
+class SeqWakeDebugPlugin(SequentialPlugin):
+    """
+    Plugin for creating wake debug plots in animations
+
+    Attributes
+    ----------
+    show_p: bool
+        Flag for showing wake points
+    show_v: bool
+        Flag for showing wake vectors
+    vpars: dict
+        Additional parameters for vector lines
+    ppars: dict
+        Additional parameters for point scatter
+
+    :group: output.seq_plugins
+
+    """
+
+    def __init__(self, show_p=True, show_v=True, vpars={}, **ppars):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        show_p: bool
+            Flag for showing wake points
+        show_v: bool
+            Flag for showing wake vectors
+        vpars: dict
+            Additional parameters for vector lines
+        ppars: dict, optional
+            Additional parameters for point scatter
+
+        """
+        super().__init__()
+        self.show_p = show_p
+        self.show_v = show_v
+
+        self.vpars = dict(color="blue")
+        self.vpars.update(vpars)
+
+        self.ppars = dict(color="blue")
+        self.ppars.update(ppars)
+
+    def initialize(self, algo):
+        """
+        Initialize data based on the intial iterator
+
+        Parameters
+        ----------
+        algo: foxes.algorithms.sequential.Sequential
+            The current sequential algorithm
+
+        """
+        super().initialize(algo)
+        self._data = []
+
+    def update(self, algo, fres, pres=None):
+        """
+        Updates data based on current iteration
+
+        Parameters
+        ----------
+        algo: foxes.algorithms.sequential.Sequential
+            The latest sequential algorithm
+        fres: xarray.Dataset
+            The latest farm results
+        pres: xarray.Dataset, optional
+            The latest point results
+
+        """
+        super().update(algo, fres, pres)
+
+        wframe = algo.wake_frame
+        if not isinstance(wframe, SeqDynamicWakes):
+            raise ValueError(
+                f"Wake frame not of type SeqDynamicWakes, got {type(algo.wake_frame).__name__}"
+            )
+
+        counter = algo.counter
+        N = counter + 1
+        dt = wframe._dt[counter] if counter < len(wframe._dt) else wframe._dt[-1]
+
+        self._data.append(
+            (
+                dt,
+                wframe._traces_p[:N].copy(),
+                wframe._traces_v[:N].copy(),
+            )
+        )
+
+    def gen_images(self, ax):
+        """
+
+        Parameters
+        ----------
+        ax: matplotlib.Axis
+            The plotting axis
+
+        Yields
+        ------
+        imgs: tuple
+            The (figure, artists) tuple
+
+        """
+        while len(self._data):
+
+            dt, pts, v = self._data.pop(0)
+
+            N = len(pts)
+            artists = []
+            if self.show_p:
+                artists += [
+                    ax.scatter(
+                        pts[:, downwind_index, 0],
+                        pts[:, downwind_index, 1],
+                        animated=True,
+                        **self.ppars,
+                    )
+                    for downwind_index in range(self.algo.n_turbines)
+                ]
+
+            if self.show_v:
+                for downwind_index in range(self.algo.n_turbines):
+                    for i in range(N):
+                        p = pts[i, downwind_index]
+                        dxy = v[i, downwind_index] * dt
+                        artists.append(
+                            ax.arrow(
+                                p[0],
+                                p[1],
+                                dxy[0],
+                                dxy[1],
+                                length_includes_head=True,
+                                animated=True,
+                                **self.vpars,
+                            )
+                        )
+
+            yield ax.get_figure(), artists

foxes/output/slice_data.py

@@ -18,23 +18,20 @@ class SliceData(Output):
         The algorithm for point calculation
     farm_results: xarray.Dataset
         The farm results
-    runner: foxes.utils.runners.Runner, optional
-        The runner
     verbosity_delta: int
         Verbosity threshold for printing calculation info
-            
+
     :group: output
 
     """
 
     def __init__(
-        self, 
-        algo, 
-        farm_results, 
-        runner=None, 
+        self,
+        algo,
+        farm_results,
         verbosity_delta=1,
         **kwargs,
-        ):
+    ):
         """
         Constructor.
 
@@ -44,8 +41,6 @@ class SliceData(Output):
             The algorithm for point calculation
         farm_results: xarray.Dataset
             The farm results
-        runner: foxes.utils.runners.Runner, optional
-            The runner
         verbosity_delta: int
             Verbosity threshold for printing calculation info
         kwargs: dict, optional
@@ -55,7 +50,6 @@ class SliceData(Output):
         super().__init__(**kwargs)
         self.algo = algo
         self.fres = farm_results
-        self.runner = runner
         self.verbosity_delta = verbosity_delta
 
     def _data_mod(
@@ -129,8 +123,6 @@ class SliceData(Output):
         label_map,
         vmin,
         vmax,
-        states_sel,
-        states_isel,
         weight_turbine,
         to_file,
         write_pars,
@@ -144,9 +136,7 @@ class SliceData(Output):
             algo=self.algo,
             farm_results=self.fres,
             g_pts=g_pts,
-            sel={FC.STATE: states_sel} if states_sel is not None else None,
-            isel={FC.STATE: states_isel} if states_isel is not None else None,
-            verbosity=verbosity-self.verbosity_delta,
+            verbosity=verbosity - self.verbosity_delta,
             **kwargs,
         )
         states = point_results[FC.STATE].to_numpy()
@@ -197,7 +187,8 @@ class SliceData(Output):
 
     def get_mean_data_xy(
         self,
-        resolution,
+        resolution=None,
+        n_img_points=None,
         variables=None,
         data_format="xarray",
         xmin=None,
@@ -229,8 +220,10 @@ class SliceData(Output):
 
         Parameters
         ----------
-        resolution: float
+        resolution: float, optional
             The resolution in m
+        n_img_points: tuple of int, optional
+            The number of image points (n, m) in the two directions
         variables: list of str, optional
             The variables, or None for all
         data_format: str
@@ -294,16 +287,19 @@ class SliceData(Output):
 
         """
         gdata = grids.get_grid_xy(
-            self.fres, 
-            resolution, 
-            xmin, 
-            ymin, 
-            xmax, 
-            ymax, 
-            z, 
-            xspace, 
-            yspace, 
-            verbosity-self.verbosity_delta,
+            farm_results=self.fres,
+            resolution=resolution,
+            n_img_points=n_img_points,
+            xmin=xmin,
+            ymin=ymin,
+            xmax=xmax,
+            ymax=ymax,
+            z=z,
+            xspace=xspace,
+            yspace=yspace,
+            states_sel=states_sel,
+            states_isel=states_isel,
+            verbosity=verbosity - self.verbosity_delta,
         )
 
         data = self._calc_mean_data(
@@ -318,13 +314,13 @@ class SliceData(Output):
             label_map,
             vmin,
             vmax,
-            states_sel,
-            states_isel,
             weight_turbine,
             to_file,
             write_pars,
             ret_states,
             verbosity,
+            states_sel=states_sel,
+            states_isel=states_isel,
             **kwargs,
         )
 
@@ -335,7 +331,8 @@ class SliceData(Output):
 
     def get_mean_data_xz(
         self,
-        resolution,
+        resolution=None,
+        n_img_points=None,
         variables=None,
         data_format="xarray",
         x_direction=270,
@@ -368,8 +365,10 @@ class SliceData(Output):
 
         Parameters
         ----------
-        resolution: float
+        resolution: float, optional
             The resolution in m
+        n_img_points: tuple of int, optional
+            The number of image points (n, m) in the two directions
         variables: list of str, optional
             The variables, or None for all
         data_format: str
@@ -435,17 +434,20 @@ class SliceData(Output):
 
         """
         gdata = grids.get_grid_xz(
-            self.fres,
-            resolution,
-            x_direction,
-            xmin,
-            zmin,
-            xmax,
-            zmax,
-            y,
-            xspace,
-            zspace,
-            verbosity-self.verbosity_delta,
+            farm_results=self.fres,
+            resolution=resolution,
+            n_img_points=n_img_points,
+            x_direction=x_direction,
+            xmin=xmin,
+            zmin=zmin,
+            xmax=xmax,
+            zmax=zmax,
+            y=y,
+            xspace=xspace,
+            zspace=zspace,
+            states_sel=states_sel,
+            states_isel=states_isel,
+            verbosity=verbosity - self.verbosity_delta,
         )
         gdatb = (gdata[0], gdata[2], gdata[1], gdata[3])
 
@@ -461,13 +463,13 @@ class SliceData(Output):
             label_map,
             vmin,
             vmax,
-            states_sel,
-            states_isel,
             weight_turbine,
             to_file,
             write_pars,
             ret_states,
             verbosity,
+            states_sel=states_sel,
+            states_isel=states_isel,
             **kwargs,
         )
 
@@ -478,7 +480,8 @@ class SliceData(Output):
 
     def get_mean_data_yz(
         self,
-        resolution,
+        resolution=None,
+        n_img_points=None,
         variables=None,
         data_format="xarray",
         x_direction=270,
@@ -511,8 +514,10 @@ class SliceData(Output):
 
         Parameters
         ----------
-        resolution: float
+        resolution: float, optional
             The resolution in m
+        n_img_points: tuple of int, optional
+            The number of image points (n, m) in the two directions
         variables: list of str, optional
             The variables, or None for all
         data_format: str
@@ -578,17 +583,20 @@ class SliceData(Output):
 
         """
         gdata = grids.get_grid_yz(
-            self.fres,
-            resolution,
-            x_direction,
-            ymin,
-            zmin,
-            ymax,
-            zmax,
-            x,
-            yspace,
-            zspace,
-            verbosity-self.verbosity_delta,
+            farm_results=self.fres,
+            resolution=resolution,
+            n_img_points=n_img_points,
+            x_direction=x_direction,
+            ymin=ymin,
+            zmin=zmin,
+            ymax=ymax,
+            zmax=zmax,
+            x=x,
+            yspace=yspace,
+            zspace=zspace,
+            states_sel=states_sel,
+            states_isel=states_isel,
+            verbosity=verbosity - self.verbosity_delta,
         )
         gdatb = (gdata[1], gdata[2], gdata[0], gdata[3])
 
@@ -604,13 +612,13 @@ class SliceData(Output):
             label_map,
             vmin,
             vmax,
-            states_sel,
-            states_isel,
             weight_turbine,
             to_file,
             write_pars,
             ret_states,
             verbosity,
+            states_sel=states_sel,
+            states_isel=states_isel,
             **kwargs,
         )
 
@@ -635,8 +643,6 @@ class SliceData(Output):
         label_map,
         vmin,
         vmax,
-        states_sel,
-        states_isel,
         to_file,
         write_pars,
         ret_states,
@@ -645,15 +651,11 @@ class SliceData(Output):
     ):
         """Helper function for states data calculation"""
         # calculate point results:
-        if states_sel is not None:
-            kwargs["sel"] = {FC.STATE: states_sel}
-        if states_isel is not None:
-            kwargs["isel"] = {FC.STATE: states_isel}
         point_results = grids.calc_point_results(
             algo=self.algo,
             farm_results=self.fres,
             g_pts=g_pts,
-            verbosity=verbosity-self.verbosity_delta,
+            verbosity=verbosity - self.verbosity_delta,
             **kwargs,
         )
         states = point_results[FC.STATE].to_numpy()
@@ -700,7 +702,8 @@ class SliceData(Output):
 
     def get_states_data_xy(
         self,
-        resolution,
+        resolution=None,
+        n_img_points=None,
         variables=None,
         data_format="xarray",
         xmin=None,
@@ -731,8 +734,10 @@ class SliceData(Output):
 
         Parameters
         ----------
-        resolution: float
+        resolution: float, optional
             The resolution in m
+        n_img_points: tuple of int, optional
+            The number of image points (n, m) in the two directions
         variables: list of str, optional
             The variables, or None for all
         data_format: str
@@ -794,16 +799,19 @@ class SliceData(Output):
 
         """
         gdata = grids.get_grid_xy(
-            self.fres, 
-            resolution, 
-            xmin, 
-            ymin, 
-            xmax, 
-            ymax, 
-            z, 
-            xspace, 
-            yspace, 
-            verbosity-self.verbosity_delta,
+            farm_results=self.fres,
+            resolution=resolution,
+            n_img_points=n_img_points,
+            xmin=xmin,
+            ymin=ymin,
+            xmax=xmax,
+            ymax=ymax,
+            z=z,
+            xspace=xspace,
+            yspace=yspace,
+            states_sel=states_sel,
+            states_isel=states_isel,
+            verbosity=verbosity - self.verbosity_delta,
         )
 
         data = self._calc_states_data(
@@ -818,12 +826,12 @@ class SliceData(Output):
             label_map,
             vmin,
             vmax,
-            states_sel,
-            states_isel,
             to_file,
             write_pars,
             ret_states,
             verbosity,
+            states_sel=states_sel,
+            states_isel=states_isel,
             **kwargs,
         )
 
@@ -834,7 +842,8 @@ class SliceData(Output):
 
     def get_states_data_xz(
         self,
-        resolution,
+        resolution=None,
+        n_img_points=None,
         variables=None,
         data_format="xarray",
         x_direction=270,
@@ -866,8 +875,10 @@ class SliceData(Output):
 
         Parameters
         ----------
-        resolution: float
+        resolution: float, optional
             The resolution in m
+        n_img_points: tuple of int, optional
+            The number of image points (n, m) in the two directions
         variables: list of str, optional
             The variables, or None for all
         data_format: str
@@ -931,17 +942,20 @@ class SliceData(Output):
 
         """
         gdata = grids.get_grid_xz(
-            self.fres,
-            resolution,
-            x_direction,
-            xmin,
-            zmin,
-            xmax,
-            zmax,
-            y,
-            xspace,
-            zspace,
-            verbosity-self.verbosity_delta,
+            farm_results=self.fres,
+            resolution=resolution,
+            n_img_points=n_img_points,
+            x_direction=x_direction,
+            xmin=xmin,
+            zmin=zmin,
+            xmax=xmax,
+            zmax=zmax,
+            y=y,
+            xspace=xspace,
+            zspace=zspace,
+            states_sel=states_sel,
+            states_isel=states_isel,
+            verbosity=verbosity - self.verbosity_delta,
         )
         gdatb = (gdata[0], gdata[2], gdata[1], gdata[3])
 
@@ -957,12 +971,12 @@ class SliceData(Output):
             label_map,
             vmin,
             vmax,
-            states_sel,
-            states_isel,
             to_file,
             write_pars,
             ret_states,
             verbosity,
+            states_sel=states_sel,
+            states_isel=states_isel,
             **kwargs,
         )
 
@@ -973,7 +987,8 @@ class SliceData(Output):
 
     def get_states_data_yz(
         self,
-        resolution,
+        resolution=None,
+        n_img_points=None,
         variables=None,
         data_format="xarray",
         x_direction=270,
@@ -1005,8 +1020,10 @@ class SliceData(Output):
 
         Parameters
         ----------
-        resolution: float
+        resolution: float, optional
             The resolution in m
+        n_img_points: tuple of int, optional
+            The number of image points (n, m) in the two directions
         variables: list of str, optional
             The variables, or None for all
         data_format: str
@@ -1070,17 +1087,20 @@ class SliceData(Output):
 
         """
         gdata = grids.get_grid_yz(
-            self.fres,
-            resolution,
-            x_direction,
-            ymin,
-            zmin,
-            ymax,
-            zmax,
-            x,
-            yspace,
-            zspace,
-            verbosity-self.verbosity_delta,
+            farm_results=self.fres,
+            resolution=resolution,
+            n_img_points=n_img_points,
+            x_direction=x_direction,
+            ymin=ymin,
+            zmin=zmin,
+            ymax=ymax,
+            zmax=zmax,
+            x=x,
+            yspace=yspace,
+            zspace=zspace,
+            states_sel=states_sel,
+            states_isel=states_isel,
+            verbosity=verbosity - self.verbosity_delta,
         )
         gdatb = (gdata[1], gdata[2], gdata[0], gdata[3])
 
@@ -1096,12 +1116,12 @@ class SliceData(Output):
             label_map,
             vmin,
             vmax,
-            states_sel,
-            states_isel,
             to_file,
             write_pars,
             ret_states,
             verbosity,
+            states_sel=states_sel,
+            states_isel=states_isel,
             **kwargs,
         )
 

foxes/output/state_turbine_map.py

@@ -7,7 +7,7 @@ from .output import Output
 
 class StateTurbineMap(Output):
     """
-    Creates heat maps with turbines on the one
+    Creates heat maps with turbines on one axis
     and states on the other axis.
 
     Attributes
@@ -37,6 +37,7 @@ class StateTurbineMap(Output):
         title=None,
         ax=None,
         figsize=None,
+        rotate_xlabels=None,
         **kwargs,
     ):
         """
@@ -53,6 +54,8 @@ class StateTurbineMap(Output):
         figsize: tuple
             The figsize argument for plt.subplots()
             in case ax is not provided
+        rotate_xlabels: float, optional
+            Rotate the x-labels by this number of degrees
         kwargs: dict, optional
             Additional parameters for plt.pcolormesh()
 
@@ -73,29 +76,31 @@ class StateTurbineMap(Output):
         states = np.append(states, states[-1] + ds)
         turbines = np.arange(len(turbines) + 1)
 
-        y, x = np.meshgrid(states, turbines)
+        y, x = np.meshgrid(turbines, states)
         z = self.results[variable].to_numpy()
 
         prgs = {"shading": "flat"}
         prgs.update(kwargs)
 
-        c = ax.pcolormesh(x, y, z.T, **prgs)
+        c = ax.pcolormesh(x, y, z, **prgs)
 
-        ax.set_xticks(turbines[:-1] + 0.5)
-        ax.set_xticklabels(turbines[:-1])
-        yt = ax.get_yticks()
-        ytl = ax.get_yticklabels()
-        ax.set_yticks(yt[:-1] + 0.5 * (yt[-1] - yt[-2]), ytl[:-1])
+        ax.set_yticks(turbines[:-1] + 0.5)
+        ax.set_yticklabels(turbines[:-1])
+        xt = ax.get_xticks()
+        xtl = ax.get_xticklabels()
+        ax.set_xticks(
+            xt[:-1] + 0.5 * (xt[-1] - xt[-2]), xtl[:-1], rotation=rotate_xlabels
+        )
         if len(turbines) > 10:
-            xt = ax.get_xticks()
-            xtl = [None for t in xt]
-            xtl[::5] = ax.get_xticklabels()[::5]
-            ax.set_xticks(xt, xtl)
+            yt = ax.get_yticks()
+            ytl = [None for t in yt]
+            ytl[::5] = ax.get_yticklabels()[::5]
+            ax.set_yticks(yt, ytl)
         fig.colorbar(c, ax=ax)
 
         t = title if title is not None else variable
         ax.set_title(t)
-        ax.set_xlabel("Turbine index")
-        ax.set_ylabel("State")
+        ax.set_ylabel("Turbine index")
+        ax.set_xlabel("State")
 
         return ax