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

foxes/output/flow_plots_2d/flow_plots.py

@@ -482,6 +482,7 @@ class FlowPlots2D(SliceData):
         ret_im=False,
         animated=False,
         rotor_color=None,
+        precalc=False,
         **kwargs,
     ):
         """
@@ -527,6 +528,11 @@ class FlowPlots2D(SliceData):
             Switch for usage for an animation
         rotor_color: str, optional
             Indicate the rotor orientation by a colored line
+        precalc: bool or tuple
+            Flag for pre-calculation run, adding an additional
+            generator call before the actual plot generations,
+            yields data, states, gdata. The same tuple can be given
+            for avoiding its calculation and picking up from there.
         kwargs: dict, optional
             Additional parameters for SliceData.get_states_data_xy
 
@@ -546,15 +552,21 @@ class FlowPlots2D(SliceData):
         wdi = variables.index(FV.WD)
         wsi = variables.index(FV.WS)
 
-        data, states, gdata = self.get_states_data_xy(
-            variables=variables,
-            vmin={var: vmin} if vmin is not None else {},
-            vmax={var: vmax} if vmax is not None else {},
-            data_format="numpy",
-            ret_states=True,
-            ret_grid=True,
-            **kwargs,
-        )
+        if isinstance(precalc, (tuple, list)):
+            data, states, gdata = precalc
+        else:
+            data, states, gdata = self.get_states_data_xy(
+                variables=variables,
+                vmin={var: vmin} if vmin is not None else {},
+                vmax={var: vmax} if vmax is not None else {},
+                data_format="numpy",
+                ret_states=True,
+                ret_grid=True,
+                **kwargs,
+            )
+            if precalc:
+                yield data, states, gdata
+
         x_pos, y_pos, z_pos, __ = gdata
 
         # define wind vector arrows:
@@ -573,8 +585,12 @@ class FlowPlots2D(SliceData):
 
         # loop over states:
         for si, s in enumerate(states):
-            if animated and si > 0 and vmin is not None and vmax is not None:
+            if animated and si == 0:
+                vmin = vmin if vmin is not None else np.min(data[..., vi])
+                vmax = vmax if vmax is not None else np.max(data[..., vi])
+            elif animated and si > 0:
                 add_bar = False
+
             if not animated and title is None:
                 ttl = f"State {s}"
                 ttl += f", z =  {int(np.round(z_pos))} m"
@@ -652,6 +668,7 @@ class FlowPlots2D(SliceData):
         ret_im=False,
         animated=False,
         rotor_color=None,
+        precalc=False,
         **kwargs,
     ):
         """
@@ -699,6 +716,11 @@ class FlowPlots2D(SliceData):
             Switch for usage for an animation
         rotor_color: str, optional
             Indicate the rotor orientation by a colored line
+        precalc: bool or tuple
+            Flag for pre-calculation run, adding an additional
+            generator call before the actual plot generations,
+            yields data, states, gdata. The same tuple can be given
+            for avoiding its calculation and picking up from there.
         kwargs: dict, optional
             Additional parameters for SliceData.get_states_data_xz
 
@@ -718,16 +740,22 @@ class FlowPlots2D(SliceData):
         wdi = variables.index(FV.WD)
         wsi = variables.index(FV.WS)
 
-        data, states, gdata = self.get_states_data_xz(
-            variables=variables,
-            vmin={var: vmin} if vmin is not None else {},
-            vmax={var: vmax} if vmax is not None else {},
-            data_format="numpy",
-            ret_states=True,
-            ret_grid=True,
-            x_direction=x_direction,
-            **kwargs,
-        )
+        if isinstance(precalc, (tuple, list)):
+            data, states, gdata = precalc
+        else:
+            data, states, gdata = self.get_states_data_xz(
+                variables=variables,
+                vmin={var: vmin} if vmin is not None else {},
+                vmax={var: vmax} if vmax is not None else {},
+                data_format="numpy",
+                ret_states=True,
+                ret_grid=True,
+                x_direction=x_direction,
+                **kwargs,
+            )
+            if precalc:
+                yield data, states, gdata
+
         x_pos, y_pos, z_pos, __ = gdata
 
         # define wind vector arrows:
@@ -826,6 +854,7 @@ class FlowPlots2D(SliceData):
         ret_im=False,
         animated=False,
         rotor_color=None,
+        precalc=False,
         **kwargs,
     ):
         """
@@ -873,6 +902,11 @@ class FlowPlots2D(SliceData):
             Switch for usage for an animation
         rotor_color: str, optional
             Indicate the rotor orientation by a colored line
+        precalc: bool or tuple
+            Flag for pre-calculation run, adding an additional
+            generator call before the actual plot generations,
+            yields data, states, gdata. The same tuple can be given
+            for avoiding its calculation and picking up from there.
         kwargs: dict, optional
             Additional parameters for SliceData.get_states_data_yz
 
@@ -892,16 +926,22 @@ class FlowPlots2D(SliceData):
         wdi = variables.index(FV.WD)
         wsi = variables.index(FV.WS)
 
-        data, states, gdata = self.get_states_data_yz(
-            variables=variables,
-            vmin={var: vmin} if vmin is not None else {},
-            vmax={var: vmax} if vmax is not None else {},
-            data_format="numpy",
-            ret_states=True,
-            ret_grid=True,
-            x_direction=x_direction,
-            **kwargs,
-        )
+        if isinstance(precalc, (tuple, list)):
+            data, states, gdata = precalc
+        else:
+            data, states, gdata = self.get_states_data_yz(
+                variables=variables,
+                vmin={var: vmin} if vmin is not None else {},
+                vmax={var: vmax} if vmax is not None else {},
+                data_format="numpy",
+                ret_states=True,
+                ret_grid=True,
+                x_direction=x_direction,
+                **kwargs,
+            )
+            if precalc:
+                yield data, states, gdata
+
         x_pos, y_pos, z_pos, __ = gdata
 
         # define wind vector arrows:

foxes/output/grids.py

@@ -12,7 +12,6 @@ def calc_point_results(
     g_pts,
     farm_results=None,
     seq_iter=None,
-    runner=None,
     verbosity=0,
     **kwargs,
 ):
@@ -28,9 +27,7 @@ def calc_point_results(
     farm_results: xarray.Dataset, optional
         The farm results
     seq_iter: foxes.algorithms.sequential.SequentialIter, optional
-        The sequential itarator
-    runner: foxes.utils.runners.Runner, optional
-        The runner
+        The sequential iterator
     verbosity: int
         The verbosity level, 0 = silent
     kwargs: dict, optional
@@ -41,11 +38,7 @@ def calc_point_results(
     if averb is not None:
         algo.verbosity = verbosity
     fres = farm_results if seq_iter is None else seq_iter.farm_results
-    if runner is None:
-        point_results = algo.calc_points(fres, points=g_pts, **kwargs)
-    else:
-        kwargs["points"] = g_pts
-        point_results = runner.run(algo.calc_points, args=(fres,), kwargs=kwargs)
+    point_results = algo.calc_points(fres, points=g_pts, **kwargs)
     if averb is not None:
         algo.verbosity = averb
 
@@ -54,7 +47,8 @@ def calc_point_results(
 
 def get_grid_xy(
     farm_results,
-    resolution,
+    resolution=None,
+    n_img_points=None,
     xmin=None,
     ymin=None,
     xmax=None,
@@ -62,6 +56,8 @@ def get_grid_xy(
     z=None,
     xspace=500.0,
     yspace=500.0,
+    states_sel=None,
+    states_isel=None,
     verbosity=0,
 ):
     """
@@ -74,6 +70,8 @@ def get_grid_xy(
         dimensions (state, turbine)
     resolution: float
         The resolution in m
+    n_img_points: tuple of int, optional
+        The number of image points (n, m) in the two directions
     xmin: float
         The min x coordinate, or None for automatic
     ymin: float
@@ -88,6 +86,10 @@ def get_grid_xy(
         The extra space in x direction, before and after wind farm
     yspace: float
         The extra space in y direction, before and after wind farm
+    states_sel: list, optional
+        Reduce to selected states
+    states_isel: list, optional
+        Reduce to the selected states indices
     verbosity: int, optional
         The verbosity level
 
@@ -103,8 +105,11 @@ def get_grid_xy(
         The grid points, shape: (n_states, n_pts, 3)
 
     """
-
     # prepare:
+    if states_isel is not None:
+        farm_results = farm_results.isel({FC.STATE: states_isel})
+    if states_sel is not None:
+        farm_results = farm_results.sel({FC.STATE: states_sel})
     n_states = farm_results[FV.H].shape[0]
 
     # get base rectangle:
@@ -115,10 +120,22 @@ def get_grid_xy(
     y_max = ymax if ymax is not None else farm_results[FV.Y].max().to_numpy() + yspace
     z_max = z if z is not None else farm_results[FV.H].max().to_numpy()
 
+    # compute number of points:
+    if resolution is not None and n_img_points is None:
+        nx = int((x_max - x_min) / resolution + 0.5) + 1
+        ny = int((y_max - y_min) / resolution + 0.5) + 1
+    elif resolution is None and n_img_points is not None:
+        nx, ny = n_img_points
+    else:
+        raise ValueError(
+            f"Expecting either 'resolution' or 'n_img_points', got: resolution = {resolution}, n_img_points = {n_img_points}"
+        )
+
+    # compute points:
     x_pos, x_res = np.linspace(
         x_min,
         x_max,
-        num=int((x_max - x_min) / resolution) + 1,
+        num=nx,
         endpoint=True,
         retstep=True,
         dtype=None,
@@ -126,7 +143,7 @@ def get_grid_xy(
     y_pos, y_res = np.linspace(
         y_min,
         y_max,
-        num=int((y_max - y_min) / resolution) + 1,
+        num=ny,
         endpoint=True,
         retstep=True,
         dtype=None,
@@ -158,7 +175,8 @@ def get_grid_xy(
 
 def get_grid_xz(
     farm_results,
-    resolution,
+    resolution=None,
+    n_img_points=None,
     x_direction=270,
     xmin=None,
     zmin=0.0,
@@ -167,6 +185,8 @@ def get_grid_xz(
     y=None,
     xspace=500.0,
     zspace=500.0,
+    states_sel=None,
+    states_isel=None,
     verbosity=0,
 ):
     """
@@ -177,8 +197,10 @@ def get_grid_xz(
     farm_results: xarray.Dataset
         The farm results. The calculated variables have
         dimensions (state, turbine)
-    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
     x_direction: float
         The direction of the x axis, 0 = north
     xmin: float
@@ -195,6 +217,10 @@ def get_grid_xz(
         The extra space in x direction, before and after wind farm
     zspace: float
         The extra space in z direction, below and above wind farm
+    states_sel: list, optional
+        Reduce to selected states
+    states_isel: list, optional
+        Reduce to the selected states indices
     verbosity: int, optional
         The verbosity level
 
@@ -212,6 +238,10 @@ def get_grid_xz(
     """
 
     # prepare:
+    if states_isel is not None:
+        farm_results = farm_results.isel({FC.STATE: states_isel})
+    if states_sel is not None:
+        farm_results = farm_results.sel({FC.STATE: states_sel})
     n_states, n_turbines = farm_results[FV.H].shape
     n_x = np.append(wd2uv(x_direction), [0.0], axis=0)
     n_z = np.array([0.0, 0.0, 1.0])
@@ -236,10 +266,22 @@ def get_grid_xz(
     y_max = y if y is not None else np.max(yy)
     del xx, yy, zz
 
+    # compute number of points:
+    if resolution is not None and n_img_points is None:
+        nx = int((x_max - x_min) / resolution + 0.5) + 1
+        nz = int((z_max - z_min) / resolution + 0.5) + 1
+    elif resolution is None and n_img_points is not None:
+        nx, nz = n_img_points
+    else:
+        raise ValueError(
+            f"Expecting either 'resolution' or 'n_img_points', got: resolution = {resolution}, n_img_points = {n_img_points}"
+        )
+
+    # compute points:
     x_pos, x_res = np.linspace(
         x_min,
         x_max,
-        num=int((x_max - x_min) / resolution) + 1,
+        num=nx,
         endpoint=True,
         retstep=True,
         dtype=None,
@@ -247,7 +289,7 @@ def get_grid_xz(
     z_pos, z_res = np.linspace(
         z_min,
         z_max,
-        num=int((z_max - z_min) / resolution) + 1,
+        num=nz,
         endpoint=True,
         retstep=True,
         dtype=None,
@@ -279,7 +321,8 @@ def get_grid_xz(
 
 def get_grid_yz(
     farm_results,
-    resolution,
+    resolution=None,
+    n_img_points=None,
     x_direction=270,
     ymin=None,
     zmin=0.0,
@@ -288,6 +331,8 @@ def get_grid_yz(
     x=None,
     yspace=500.0,
     zspace=500.0,
+    states_sel=None,
+    states_isel=None,
     verbosity=0,
 ):
     """
@@ -298,8 +343,10 @@ def get_grid_yz(
     farm_results: xarray.Dataset
         The farm results. The calculated variables have
         dimensions (state, turbine)
-    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
     x_direction: float
         The direction of the x axis, 0 = north
     ymin: float
@@ -316,6 +363,10 @@ def get_grid_yz(
         The extra space in y direction, before and after wind farm
     zspace: float
         The extra space in z direction, below and above wind farm
+    states_sel: list, optional
+        Reduce to selected states
+    states_isel: list, optional
+        Reduce to the selected states indices
     verbosity: int, optional
         The verbosity level
 
@@ -333,6 +384,10 @@ def get_grid_yz(
     """
 
     # prepare:
+    if states_isel is not None:
+        farm_results = farm_results.isel({FC.STATE: states_isel})
+    if states_sel is not None:
+        farm_results = farm_results.sel({FC.STATE: states_sel})
     n_states, n_turbines = farm_results[FV.H].shape
     n_x = np.append(wd2uv(x_direction), [0.0], axis=0)
     n_z = np.array([0.0, 0.0, 1.0])
@@ -357,10 +412,22 @@ def get_grid_yz(
     x_max = x if x is not None else np.max(xx)
     del xx, yy, zz
 
+    # compute number of points:
+    if resolution is not None and n_img_points is None:
+        ny = int((y_max - y_min) / resolution + 0.5) + 1
+        nz = int((z_max - z_min) / resolution + 0.5) + 1
+    elif resolution is None and n_img_points is not None:
+        ny, nz = n_img_points
+    else:
+        raise ValueError(
+            f"Expecting either 'resolution' or 'n_img_points', got: resolution = {resolution}, n_img_points = {n_img_points}"
+        )
+
+    # compute points:
     y_pos, y_res = np.linspace(
         y_min,
         y_max,
-        num=int((y_max - y_min) / resolution) + 1,
+        num=ny,
         endpoint=True,
         retstep=True,
         dtype=None,
@@ -368,7 +435,7 @@ def get_grid_yz(
     z_pos, z_res = np.linspace(
         z_min,
         z_max,
-        num=int((z_max - z_min) / resolution) + 1,
+        num=nz,
         endpoint=True,
         retstep=True,
         dtype=None,
@@ -614,7 +681,10 @@ def np2xr_sp(data, states, a_pos, b_pos, c_pos, ori, label_map={}):
     return Dataset(
         coords={s: states, b: b_pos, a: a_pos},
         data_vars={
-            v: ((s, b, a), np.swapaxes(d.reshape(n_s, n_a, n_b), 1, 2))
+            label_map.get(v, v): (
+                (s, b, a),
+                np.swapaxes(d.reshape(n_s, n_a, n_b), 1, 2),
+            )
             for v, d in data.items()
         },
         attrs={c: float(c_pos)},

foxes/output/results_writer.py

@@ -83,7 +83,7 @@ class ResultsWriter(Output):
         Parameters
         ----------
         file_path: str
-            Path the the csv file
+            Path for the csv file
         variables: dict or list of str, optional
             The variables to be written. If a dict, then
             the keys are the foxes variables and the values
@@ -150,7 +150,7 @@ class ResultsWriter(Output):
         Parameters
         ----------
         file_path: str
-            Path the the csv file
+            Path for the nc file
         variables: dict or list of str, optional
             The variables to be written. If a dict, then
             the keys are the foxes variables and the values

foxes/output/rose_plot.py

@@ -118,7 +118,7 @@ class RosePlotOutput(Output):
         var: str
             The data variable name
         var_bins: list of float
-            The variable bin seperation values
+            The variable bin separation values
         wd_var: str, optional
             The wind direction variable name
         turbine: int, optional
@@ -231,7 +231,7 @@ class RosePlotOutput(Output):
         var: str
             The data variable name
         var_bins: list of float
-            The variable bin seperation values
+            The variable bin separation values
         wd_var: str, optional
             The wind direction variable name
         turbine: int, optional
@@ -330,7 +330,7 @@ class RosePlotOutput(Output):
         var: str
             The data variable name
         var_bins: list of float
-            The variable bin seperation values
+            The variable bin separation values
         ret_data: bool
             Flag for returning wind rose data
         kwargs: dict, optional

foxes/output/seq_plugins/__init__.py

@@ -0,0 +1,2 @@
+from .seq_flow_ani_plugin import SeqFlowAnimationPlugin
+from .seq_wake_debug_plugin import SeqWakeDebugPlugin

foxes/output/{flow_plots_2d → seq_plugins}/seq_flow_ani_plugin.py

@@ -1,6 +1,8 @@
+from copy import deepcopy
+
 from foxes.algorithms.sequential import SequentialPlugin
 
-from .flow_plots import FlowPlots2D
+from ..flow_plots_2d.flow_plots import FlowPlots2D
 
 
 class SeqFlowAnimationPlugin(SequentialPlugin):
@@ -12,16 +14,14 @@ class SeqFlowAnimationPlugin(SequentialPlugin):
     ----------
     orientation: str
         The orientation, either "yx", "xz" or "yz"
-    runner: foxes.utils.runners.Runner
-        The runner
     pars: dict
         Additional parameters for plotting
 
-    :group: output.flow_plots_2d
+    :group: output.seq_plugins
 
     """
 
-    def __init__(self, orientation, runner=None, **pars):
+    def __init__(self, orientation, **pars):
         """
         Constructor.
 
@@ -29,15 +29,12 @@ class SeqFlowAnimationPlugin(SequentialPlugin):
         ----------
         orientation: str
             The orientation, either "yx", "xz" or "yz"
-        runner: foxes.utils.runners.Runner, optional
-            The runner
         pars: dict, optional
             Additional parameters for plotting
 
         """
         super().__init__()
         self.orientation = orientation
-        self.runner = runner
         self.pars = pars
 
         if "title" in self.pars and callable(self.pars["title"]):
@@ -52,7 +49,7 @@ class SeqFlowAnimationPlugin(SequentialPlugin):
         Parameters
         ----------
         algo: foxes.algorithms.sequential.Sequential
-            The current sequetial algorithm
+            The current sequential algorithm
 
         """
         super().initialize(algo)
@@ -65,7 +62,7 @@ class SeqFlowAnimationPlugin(SequentialPlugin):
         Parameters
         ----------
         algo: foxes.algorithms.sequential.Sequential
-            The latest sequetial algorithm
+            The latest sequential algorithm
         fres: xarray.Dataset
             The latest farm results
         pres: xarray.Dataset, optional
@@ -74,28 +71,73 @@ class SeqFlowAnimationPlugin(SequentialPlugin):
         """
         super().update(algo, fres, pres)
 
-        o = FlowPlots2D(algo, fres, self.runner)
+        o = FlowPlots2D(algo, fres)
 
         if self._tfun is not None:
             self.pars["title"] = self._tfun(algo.states.counter, algo.states.index()[0])
 
         if self.orientation == "xy":
-            self._data.append(next(o.gen_states_fig_xy(**self.pars)))
+            d = next(o.gen_states_fig_xy(**self.pars, precalc=True))
         elif self.orientation == "xz":
-            self._data.append(next(o.gen_states_fig_xz(**self.pars)))
+            d = next(o.gen_states_fig_xz(**self.pars, precalc=True))
         elif self.orientation == "yz":
-            self._data.append(next(o.gen_states_fig_yz(**self.pars)))
+            d = next(o.gen_states_fig_yz(**self.pars, precalc=True))
         else:
             raise KeyError(
                 f"Unkown orientation '{self.orientation}', choises: xy, xz, yz"
             )
 
-        if (
-            self.pars.get("vmin", None) is not None
-            and self.pars.get("vmax", None) is not None
-        ):
-            self.pars["add_bar"] = False
+        # minimize stored data:
+        od = [d[0], d[1], None]
+        if len(self._data) == 0:
+            od[2] = d[2]
+        of = (
+            fres
+            if ("rotor_color" in self.pars and self.pars["rotor_color"] is not None)
+            else None
+        )
+
+        self._data.append((of, od))
+
+    def gen_images(self, ax):
+        """
+
+        Parameters
+        ----------
+        ax: matplotlib.Axis
+            The plotting axis
+
+        Yields
+        ------
+        imgs: tuple
+            The (figure, artists) tuple
+
+        """
+        fig = ax.get_figure()
+        gdata = None
+        while len(self._data):
+
+            fres, d = self._data.pop(0)
+
+            if d[2] is not None:
+                gdata = d[2]
+
+            o = FlowPlots2D(self.algo, fres)
+
+            yield next(
+                o.gen_states_fig_xy(
+                    **self.pars,
+                    ax=ax,
+                    fig=fig,
+                    ret_im=True,
+                    precalc=(d[0], d[1], gdata),
+                )
+            )
+
+            del o, fres, d
 
-    def gen_images(self):
-        for d in self._data:
-            yield d
+            if (
+                self.pars.get("vmin", None) is not None
+                and self.pars.get("vmax", None) is not None
+            ):
+                self.pars["add_bar"] = False