foxes 0.5.1__py3-none-any.whl → 0.5.2__py3-none-any.whl

foxes/output/flow_plots_2d/flow_plots.py

@@ -1,82 +1,39 @@
 import numpy as np
 
-from foxes.output import Output
-import foxes.constants as FC
+from foxes.output import SliceData
 import foxes.variables as FV
 
-from .common import (
-    get_grid_xy,
-    get_grid_xz,
-    get_grid_yz,
-    calc_point_results,
-    get_fig,
-)
+from .get_fig import get_fig
 
 
-class FlowPlots2D(Output):
+class FlowPlots2D(SliceData):
     """
     Class for horizontal or vertical 2D flow plots
 
-    Attributes
-    ----------
-    algo: foxes.Algorithm
-        The algorithm for point calculation
-    farm_results: xarray.Dataset
-        The farm results
-    runner: foxes.utils.runners.Runner, optional
-        The runner
-
     :group: output.flow_plots_2d
 
     """
 
-    def __init__(self, algo, farm_results, runner=None):
-        """
-        Constructor.
-
-        Parameters
-        ----------
-        algo: foxes.Algorithm
-            The algorithm for point calculation
-        farm_results: xarray.Dataset
-            The farm results
-        runner: foxes.utils.runners.Runner, optional
-            The runner
-
-        """
-        self.algo = algo
-        self.fres = farm_results
-        self.runner = runner
-
     def get_mean_fig_xy(
         self,
         var,
-        resolution,
-        xmin=None,
-        ymin=None,
-        xmax=None,
-        ymax=None,
         xlabel="x [m]",
         ylabel="y [m]",
-        z=None,
-        xspace=500.0,
-        yspace=500.0,
         levels=None,
-        vmin=None,
-        vmax=None,
         figsize=None,
-        normalize_xy=None,
-        normalize_var=None,
         title=None,
         vlabel=None,
         fig=None,
         ax=None,
         add_bar=True,
         cmap=None,
-        weight_turbine=0,
-        verbosity=0,
+        vmin=None,
+        vmax=None,
+        quiver_n=None,
+        quiver_pars={},
         ret_state=False,
         ret_im=False,
+        ret_data=False,
         animated=False,
         **kwargs,
     ):
@@ -87,38 +44,14 @@ class FlowPlots2D(Output):
         ----------
         var: str
             The variable name
-        resolution: float
-            The resolution in m
-        xmin: float, optional
-            The min x coordinate, or None for automatic
-        ymin: float, optional
-            The min y coordinate, or None for automatic
-        xmax: float, optional
-            The max x coordinate, or None for automatic
-        ymax: float, optional
-            The max y coordinate, or None for automatic
         xlabel: str, optional
             The x axis label
         ylabel: str, optional
             The y axis label
-        z: float, optional
-            The z coordinate of the plane
-        xspace: float, optional
-            The extra space in x direction, before and after wind farm
-        yspace: float, optional
-            The extra space in y direction, before and after wind farm
         levels: int, optional
             The number of levels for the contourf plot, or None for pure image
-        vmin: float, optional
-            Minimum variable value
-        vmax: float, optional
-            Maximum variable value
         figsize: tuple, optional
             The figsize for plt.Figure
-        normalize_xy: float, optional
-            Divide x and y by this value
-        normalize_var: float, optional
-            Divide the variable by this value
         title: str, optional
             The title
         vlabel: str, optional
@@ -131,22 +64,27 @@ class FlowPlots2D(Output):
             Add a color bar
         cmap: str, optional
             The colormap
-        weight_turbine: int, optional
-            Index of the turbine from which to take the weight
-        verbosity: int, optional
-            The verbosity level
+        vmin: float, optional
+            The minimal variable value
+        vmax: float, optional
+            The maximal variable value
+        quiver_n: int, optional
+            Place a vector at each `n`th point
+        quiver_pars: dict, optional
+            Parameters for plt.quiver
         ret_state: bool
             Flag for state index return
         ret_im: bool
             Flag for image return
+        ret_data: bool
+            Flag for returning image data
         animated: bool
             Switch for usage for an animation
         kwargs: dict, optional
-            Parameters forwarded to the algorithm's calc_points
-            function.
+            Additional parameters for SliceData.get_mean_data_xy
 
-        Yields
-        ------
+        Returns
+        -------
         fig: matplotlib.Figure
             The figure object
         si: int, optional
@@ -154,145 +92,109 @@ class FlowPlots2D(Output):
         im: tuple, optional
             The image objects, matplotlib.collections.QuadMesh
             or matplotlib.QuadContourSet
+        data: numpy.ndarray, optional
+            The image data, shape: (n_x, n_y)
 
         """
+        variables = list(set([var]+[FV.WD, FV.WS]))
+        vi = variables.index(var)
+        wdi = variables.index(FV.WD)
+        wsi = variables.index(FV.WS)
 
-        # create grid:
-        x_pos, y_pos, z_pos, g_pts = get_grid_xy(
-            self.fres, resolution, xmin, ymin, xmax, ymax, z, xspace, yspace, verbosity
-        )
-
-        # calculate point results:
-        data = calc_point_results(
-            algo=self.algo,
-            farm_results=self.fres,
-            g_pts=g_pts,
-            verbosity=verbosity,
-            **kwargs,
-        )[var].to_numpy()
-
-        # take mean over states:
-        weights = self.fres[FV.WEIGHT][:, weight_turbine].to_numpy()
-        data = np.einsum("s,sp->p", weights, data)[None]
-
-        # find data min max:
-        vmin = vmin if vmin is not None else np.nanmin(data)
-        vmax = vmax if vmax is not None else np.nanmax(data)
-        if normalize_var is not None:
-            vmin /= normalize_var
-            vmax /= normalize_var
-
-        # normalize x and y:
-        if normalize_xy is not None:
-            x_pos /= normalize_xy
-            y_pos /= normalize_xy
+        data, gdata = self.get_mean_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_grid=True, **kwargs)
+        x_pos, y_pos, z_pos, __ = gdata
 
         if title is None:
             title = f"States mean, z =  {int(np.round(z_pos))} m"
 
+        # define wind vector arrows:
+        qpars = dict(angles="xy", scale_units="xy", scale=0.05)
+        qpars.update(quiver_pars)
+        quiv = (
+            None
+            if quiver_n is None
+            else (
+                quiver_n,
+                qpars,
+                data[None, :, :, wdi],
+                data[None, :, :, wsi],
+            )
+        )
+
         # create plot:
-        return get_fig(
+        out = get_fig(
             var=var,
             fig=fig,
             figsize=figsize,
             ax=ax,
-            data=data,
+            data=data[None, :, :, vi],
             si=0,
             s=None,
-            normalize_var=normalize_var,
             levels=levels,
             x_pos=x_pos,
             y_pos=y_pos,
-            vmin=vmin,
-            vmax=vmax,
             cmap=cmap,
             xlabel=xlabel,
             ylabel=ylabel,
             title=title,
             add_bar=add_bar,
             vlabel=vlabel,
+            quiv=quiv,
             ret_state=ret_state,
             ret_im=ret_im,
             animated=animated,
         )
 
+        if ret_data:
+            out = list(out) if isinstance(out, tuple) else [out]
+            return tuple(out + [data[:, :, 0]])
+        
+        return out
+
     def get_mean_fig_xz(
         self,
         var,
-        resolution,
         x_direction=270,
-        xmin=None,
-        zmin=0.0,
-        xmax=None,
-        zmax=None,
         xlabel="x [m]",
         zlabel="z [m]",
-        y=None,
-        xspace=500.0,
-        zspace=500.0,
         levels=None,
-        vmin=None,
-        vmax=None,
         figsize=None,
-        normalize_x=None,
-        normalize_z=None,
-        normalize_var=None,
         title=None,
         vlabel=None,
         fig=None,
         ax=None,
         add_bar=True,
         cmap=None,
-        weight_turbine=0,
-        verbosity=0,
+        vmin=None,
+        vmax=None,
+        quiver_n=None,
+        quiver_pars={},
         ret_state=False,
         ret_im=False,
+        ret_data=False,
         animated=False,
         **kwargs,
     ):
         """
-        Generates 2D farm flow figure in a vertical xz-plane.
+        Generates 2D farm flow figure in a horizontal xz-plane.
 
         Parameters
         ----------
         var: str
             The variable name
-        resolution: float
-            The resolution in m
         x_direction: float, optional
             The direction of the x axis, 0 = north
-        xmin: float, optional
-            The min x coordinate, or None for automatic
-        zmin: float, optional
-            The min z coordinate
-        xmax: float, optional
-            The max x coordinate, or None for automatic
-        zmax: float, optional
-            The max z coordinate, or None for automatic
         xlabel: str, optional
             The x axis label
         zlabel: str, optional
             The z axis label
-        y: float, optional
-            The y coordinate of the plane
-        xspace: float, optional
-            The extra space in x direction, before and after wind farm
-        zspace: float, optional
-            The extra space in z direction, below and above wind farm
         levels: int, optional
             The number of levels for the contourf plot, or None for pure image
-        vmin: float, optional
-            Minimum variable value
-        vmax: float, optional
-            Maximum variable value
         figsize: tuple, optional
             The figsize for plt.Figure
-        normalize_x: float, optional
-            Divide x by this value
-        normalize_z: float, optional
-            Divide z by this value
-        normalize_var: float, optional
-            Divide the variable by this value
         title: str, optional
             The title
         vlabel: str, optional
@@ -305,22 +207,27 @@ class FlowPlots2D(Output):
             Add a color bar
         cmap: str, optional
             The colormap
-        weight_turbine: int, optional
-            Index of the turbine from which to take the weight
-        verbosity: int, optional
-            The verbosity level
+        vmin: float, optional
+            The minimal variable value
+        vmax: float, optional
+            The maximal variable value
+        quiver_n: int, optional
+            Place a vector at each `n`th point
+        quiver_pars: dict, optional
+            Parameters for plt.quiver
         ret_state: bool
             Flag for state index return
         ret_im: bool
             Flag for image return
+        ret_data: bool
+            Flag for returning image data
         animated: bool
             Switch for usage for an animation
         kwargs: dict, optional
-            Parameters forwarded to the algorithm's calc_points
-            function.
+            Additional parameters for SliceData.get_mean_data_xz
 
-        Yields
-        ------
+        Returns
+        -------
         fig: matplotlib.Figure
             The figure object
         si: int, optional
@@ -328,68 +235,51 @@ class FlowPlots2D(Output):
         im: tuple, optional
             The image objects, matplotlib.collections.QuadMesh
             or matplotlib.QuadContourSet
+        data: numpy.ndarray, optional
+            The image data, shape: (n_x, n_y)
 
         """
-
-        # create grid:
-        x_pos, y_pos, z_pos, g_pts = get_grid_xz(
-            self.fres,
-            resolution,
-            x_direction,
-            xmin,
-            zmin,
-            xmax,
-            zmax,
-            y,
-            xspace,
-            zspace,
-            verbosity,
-        )
-
-        # calculate point results:
-        data = calc_point_results(
-            algo=self.algo,
-            farm_results=self.fres,
-            g_pts=g_pts,
-            verbosity=verbosity,
-            **kwargs,
-        )[var].to_numpy()
-
-        # take mean over states:
-        weights = self.fres[FV.WEIGHT][:, weight_turbine].to_numpy()
-        data = np.einsum("s,sp->p", weights, data)[None]
-
-        # find data min max:
-        vmin = vmin if vmin is not None else np.nanmin(data)
-        vmax = vmax if vmax is not None else np.nanmax(data)
-        if normalize_var is not None:
-            vmin /= normalize_var
-            vmax /= normalize_var
-
-        # normalize x and z:
-        if normalize_x is not None:
-            x_pos /= normalize_x
-        if normalize_z is not None:
-            z_pos /= normalize_z
+        variables = list(set([var]+[FV.WD, FV.WS]))
+        vi = variables.index(var)
+        wdi = variables.index(FV.WD)
+        wsi = variables.index(FV.WS)
+
+        data, gdata = self.get_mean_data_xz(variables=variables, 
+                        vmin={var: vmin} if vmin is not None else {},
+                        vmax={var: vmax} if vmax is not None else {},
+                        x_direction=x_direction, data_format="numpy", 
+                        ret_grid=True, **kwargs)
+        x_pos, y_pos, z_pos, __ = gdata
 
         if title is None:
             title = f"States mean, x direction {x_direction}°, y =  {int(np.round(y_pos))} m"
 
+        # define wind vector arrows:
+        qpars = dict(angles="xy", scale_units="xy", scale=0.05)
+        qpars.update(quiver_pars)
+        quiv = (
+            None
+            if quiver_n is None
+            else (
+                quiver_n,
+                qpars,
+                data[None, :, :, wdi],
+                data[None, :, :, wsi],
+            )
+        )
+
         # create plot:
-        return get_fig(
+        out = get_fig(
             var=var,
             fig=fig,
             figsize=figsize,
             ax=ax,
-            data=data,
+            data=data[None, :, :, vi],
             si=0,
             s=None,
-            normalize_var=normalize_var,
             levels=levels,
             x_pos=x_pos,
             y_pos=z_pos,
-            vmin=vmin,
-            vmax=vmax,
             cmap=cmap,
             xlabel=xlabel,
             ylabel=zlabel,
@@ -398,86 +288,57 @@ class FlowPlots2D(Output):
             vlabel=vlabel,
             ret_state=ret_state,
             ret_im=ret_im,
+            quiv=quiv,
             animated=animated,
         )
 
+        if ret_data:
+            out = list(out) if isinstance(out, tuple) else [out]
+            return tuple(out + [data[:, :, 0]])
+        
+        return out
+
     def get_mean_fig_yz(
         self,
         var,
-        resolution,
         x_direction=270,
-        ymin=None,
-        zmin=0.0,
-        ymax=None,
-        zmax=None,
         ylabel="x [m]",
         zlabel="z [m]",
-        x=None,
-        yspace=500.0,
-        zspace=500.0,
         levels=None,
-        vmin=None,
-        vmax=None,
         figsize=None,
-        normalize_y=None,
-        normalize_z=None,
-        normalize_var=None,
         title=None,
         vlabel=None,
         fig=None,
         ax=None,
         add_bar=True,
         cmap=None,
-        weight_turbine=0,
-        verbosity=1,
+        vmin=None,
+        vmax=None,
+        quiver_n=None,
+        quiver_pars={},
         ret_state=False,
         ret_im=False,
+        ret_data=False,
         animated=False,
         **kwargs,
     ):
         """
-        Generates 2D farm flow figure in a vertical yz-plane.
+        Generates 2D farm flow figure in a horizontal yz-plane.
 
         Parameters
         ----------
         var: str
             The variable name
-        resolution: float
-            The resolution in m
         x_direction: float, optional
             The direction of the x axis, 0 = north
-        ymin: float, optional
-            The min y coordinate, or None for automatic
-        zmin: float, optional
-            The min z coordinate
-        ymax: float, optional
-            The max y coordinate, or None for automatic
-        zmax: float, optional
-            The max z coordinate, or None for automatic
         ylabel: str, optional
             The y axis label
         zlabel: str, optional
             The z axis label
-        x: float, optional
-            The x coordinate of the plane
-        yspace: float, optional
-            The extra space in y direction, before and after wind farm
-        zspace: float, optional
-            The extra space in z direction, below and above wind farm
         levels: int, optional
             The number of levels for the contourf plot, or None for pure image
-        vmin: float, optional
-            Minimum variable value
-        vmax: float, optional
-            Maximum variable value
         figsize: tuple, optional
             The figsize for plt.Figure
-        normalize_y: float, optional
-            Divide y by this value
-        normalize_z: float, optional
-            Divide z by this value
-        normalize_var: float, optional
-            Divide the variable by this value
         title: str, optional
             The title
         vlabel: str, optional
@@ -490,22 +351,27 @@ class FlowPlots2D(Output):
             Add a color bar
         cmap: str, optional
             The colormap
-        weight_turbine: int, optional
-            Index of the turbine from which to take the weight
-        verbosity: int, optional
-            The verbosity level
+        vmin: float, optional
+            The minimal variable value
+        vmax: float, optional
+            The maximal variable value
+        quiver_n: int, optional
+            Place a vector at each `n`th point
+        quiver_pars: dict, optional
+            Parameters for plt.quiver
         ret_state: bool
             Flag for state index return
         ret_im: bool
             Flag for image return
+        ret_data: bool
+            Flag for returning image data
         animated: bool
             Switch for usage for an animation
         kwargs: dict, optional
-            Parameters forwarded to the algorithm's calc_points
-            function.
+            Additional parameters for SliceData.get_mean_data_yz
 
-        Yields
-        ------
+        Returns
+        -------
         fig: matplotlib.Figure
             The figure object
         si: int, optional
@@ -513,68 +379,51 @@ class FlowPlots2D(Output):
         im: tuple, optional
             The image objects, matplotlib.collections.QuadMesh
             or matplotlib.QuadContourSet
+        data: numpy.ndarray, optional
+            The image data, shape: (n_x, n_y)
 
         """
-
-        # create grid:
-        x_pos, y_pos, z_pos, g_pts = get_grid_yz(
-            self.fres,
-            resolution,
-            x_direction,
-            ymin,
-            zmin,
-            ymax,
-            zmax,
-            x,
-            yspace,
-            zspace,
-            verbosity,
-        )
-
-        # calculate point results:
-        data = calc_point_results(
-            algo=self.algo,
-            farm_results=self.fres,
-            g_pts=g_pts,
-            verbosity=verbosity,
-            **kwargs,
-        )[var].to_numpy()
-
-        # take mean over states:
-        weights = self.fres[FV.WEIGHT][:, weight_turbine].to_numpy()
-        data = np.einsum("s,sp->p", weights, data)[None]
-
-        # find data min max:
-        vmin = vmin if vmin is not None else np.nanmin(data)
-        vmax = vmax if vmax is not None else np.nanmax(data)
-        if normalize_var is not None:
-            vmin /= normalize_var
-            vmax /= normalize_var
-
-        # normalize x and z:
-        if normalize_y is not None:
-            y_pos /= normalize_y
-        if normalize_z is not None:
-            z_pos /= normalize_z
+        variables = list(set([var]+[FV.WD, FV.WS]))
+        vi = variables.index(var)
+        wdi = variables.index(FV.WD)
+        wsi = variables.index(FV.WS)
+
+        data, gdata = self.get_mean_data_yz(variables=variables, 
+                        vmin={var: vmin} if vmin is not None else {},
+                        vmax={var: vmax} if vmax is not None else {},
+                        x_direction=x_direction, data_format="numpy", 
+                        ret_grid=True, **kwargs)
+        x_pos, y_pos, z_pos, __ = gdata
 
         if title is None:
             title = f"States mean, x direction {x_direction}°, x =  {int(np.round(x_pos))} m"
 
+        # define wind vector arrows:
+        qpars = dict(angles="xy", scale_units="xy", scale=0.05)
+        qpars.update(quiver_pars)
+        quiv = (
+            None
+            if quiver_n is None
+            else (
+                quiver_n,
+                qpars,
+                data[None, :, :, wdi],
+                data[None, :, :, wsi],
+            )
+        )
+
         # create plot:
-        return get_fig(
+        out = get_fig(
             var=var,
             fig=fig,
             figsize=figsize,
             ax=ax,
-            data=data,
+            data=data[None, :, :, vi],
             si=0,
             s=None,
-            normalize_var=normalize_var,
             levels=levels,
             x_pos=y_pos,
             y_pos=z_pos,
-            vmin=vmin,
-            vmax=vmax,
             cmap=cmap,
             xlabel=ylabel,
             ylabel=zlabel,
@@ -583,38 +432,34 @@ class FlowPlots2D(Output):
             vlabel=vlabel,
             ret_state=ret_state,
             ret_im=ret_im,
+            quiv=quiv,
             invert_axis="x",
             animated=animated,
         )
 
+        if ret_data:
+            out = list(out) if isinstance(out, tuple) else [out]
+            return tuple(out + [data[:, :, 0]])
+        
+        return out
+        
     def gen_states_fig_xy(
         self,
         var,
-        resolution,
-        xmin=None,
-        ymin=None,
-        xmax=None,
-        ymax=None,
         xlabel="x [m]",
         ylabel="y [m]",
-        z=None,
-        xspace=500.0,
-        yspace=500.0,
         levels=None,
-        vmin=None,
-        vmax=None,
         figsize=None,
-        normalize_xy=None,
-        normalize_var=None,
         title=None,
         vlabel=None,
         fig=None,
         ax=None,
         add_bar=True,
         cmap=None,
+        vmin=None,
+        vmax=None,
         quiver_n=None,
         quiver_pars={},
-        verbosity=0,
         ret_state=False,
         ret_im=False,
         animated=False,
@@ -627,38 +472,14 @@ class FlowPlots2D(Output):
         ----------
         var: str
             The variable name
-        resolution: float
-            The resolution in m
-        xmin: float, optional
-            The min x coordinate, or None for automatic
-        ymin: float, optional
-            The min y coordinate, or None for automatic
-        xmax: float, optional
-            The max x coordinate, or None for automatic
-        ymax: float, optional
-            The max y coordinate, or None for automatic
         xlabel: str, optional
             The x axis label
         ylabel: str, optional
             The y axis label
-        z: float, optional
-            The z coordinate of the plane
-        xspace: float, optional
-            The extra space in x direction, before and after wind farm
-        yspace: float, optional
-            The extra space in y direction, before and after wind farm
         levels: int, optional
             The number of levels for the contourf plot, or None for pure image
-        vmin: float, optional
-            Minimum variable value
-        vmax: float, optional
-            Maximum variable value
         figsize: tuple, optional
             The figsize for plt.Figure
-        normalize_xy: float, optional
-            Divide x and y by this value
-        normalize_var: float, optional
-            Divide the variable by this value
         title: str, optional
             The title
         vlabel: str, optional
@@ -671,12 +492,14 @@ class FlowPlots2D(Output):
             Add a color bar
         cmap: str, optional
             The colormap
+        vmin: float, optional
+            The minimal variable value
+        vmax: float, optional
+            The maximal variable value
         quiver_n: int, optional
             Place a vector at each `n`th point
         quiver_pars: dict, optional
             Parameters for plt.quiver
-        verbosity: int, optional
-            The verbosity level
         ret_state: bool
             Flag for state index return
         ret_im: bool
@@ -684,8 +507,7 @@ class FlowPlots2D(Output):
         animated: bool
             Switch for usage for an animation
         kwargs: dict, optional
-            Parameters forwarded to the algorithm's calc_points
-            function.
+            Additional parameters for SliceData.get_states_data_xy
 
         Yields
         ------
@@ -698,21 +520,17 @@ class FlowPlots2D(Output):
             or matplotlib.QuadContourSet
 
         """
-
-        # create grid:
-        x_pos, y_pos, z_pos, g_pts = get_grid_xy(
-            self.fres, resolution, xmin, ymin, xmax, ymax, z, xspace, yspace, verbosity
-        )
-
-        # calculate point results:
-        point_results = calc_point_results(
-            algo=self.algo,
-            farm_results=self.fres,
-            g_pts=g_pts,
-            verbosity=verbosity,
-            **kwargs,
-        )
-        data = point_results[var].to_numpy()
+        variables = list(set([var]+[FV.WD, FV.WS]))
+        vi = variables.index(var)
+        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)
+        x_pos, y_pos, z_pos, __ = gdata
 
         # define wind vector arrows:
         qpars = dict(angles="xy", scale_units="xy", scale=0.05)
@@ -723,26 +541,13 @@ class FlowPlots2D(Output):
             else (
                 quiver_n,
                 qpars,
-                point_results[FV.WD].to_numpy(),
-                point_results[FV.WS].to_numpy(),
+                data[..., wdi],
+                data[..., wsi],
             )
         )
-        del point_results
-
-        # find data min max:
-        vmin = vmin if vmin is not None else np.nanmin(data)
-        vmax = vmax if vmax is not None else np.nanmax(data)
-        if normalize_var is not None:
-            vmin /= normalize_var
-            vmax /= normalize_var
-
-        # normalize x and y:
-        if normalize_xy is not None:
-            x_pos /= normalize_xy
-            y_pos /= normalize_xy
 
         # loop over states:
-        for si, s in enumerate(self.fres[FC.STATE].to_numpy()):
+        for si, s in enumerate(states):
             if not animated and title is None:
                 ttl = f"State {s}"
                 ttl += f", z =  {int(np.round(z_pos))} m"
@@ -754,59 +559,44 @@ class FlowPlots2D(Output):
                 fig=fig,
                 figsize=figsize,
                 ax=ax,
-                data=data,
+                data=data[..., vi],
                 si=si,
                 s=s,
-                normalize_var=normalize_var,
                 levels=levels,
                 x_pos=x_pos,
                 y_pos=y_pos,
-                vmin=vmin,
-                vmax=vmax,
                 cmap=cmap,
                 xlabel=xlabel,
                 ylabel=ylabel,
                 title=ttl,
                 add_bar=add_bar,
                 vlabel=vlabel,
+                quiv=quiv,
                 ret_state=ret_state,
                 ret_im=ret_im,
-                quiv=quiv,
                 animated=animated,
             )
 
             yield out
-
+    
     def gen_states_fig_xz(
         self,
         var,
-        resolution,
         x_direction=270.0,
-        xmin=None,
-        zmin=0.0,
-        xmax=None,
-        zmax=None,
         xlabel="x [m]",
         zlabel="z [m]",
-        y=None,
-        xspace=500.0,
-        zspace=500.0,
         levels=None,
-        vmin=None,
-        vmax=None,
         figsize=None,
-        normalize_x=None,
-        normalize_z=None,
-        normalize_var=None,
         title=None,
         vlabel=None,
         fig=None,
         ax=None,
         add_bar=True,
         cmap=None,
+        vmin=None,
+        vmax=None,
         quiver_n=None,
         quiver_pars={},
-        verbosity=0,
         ret_state=False,
         ret_im=False,
         animated=False,
@@ -819,42 +609,16 @@ class FlowPlots2D(Output):
         ----------
         var: str
             The variable name
-        resolution: float
-            The resolution in m
         x_direction: float, optional
             The direction of the x axis, 0 = north
-        xmin: float, optional
-            The min x coordinate, or None for automatic
-        zmin: float, optional
-            The min z coordinate
-        xmax: float, optional
-            The max x coordinate, or None for automatic
-        zmax: float, optional
-            The max z coordinate, or None for automatic
         xlabel: str, optional
             The x axis label
         zlabel: str, optional
             The z axis label
-        y: float, optional
-            The y coordinate of the plane
-        xspace: float, optional
-            The extra space in x direction, before and after wind farm
-        zspace: float, optional
-            The extra space in z direction, below and above wind farm
         levels: int, optional
             The number of levels for the contourf plot, or None for pure image
-        vmin: float, optional
-            Minimum variable value
-        vmax: float, optional
-            Maximum variable value
         figsize: tuple, optional
             The figsize for plt.Figure
-        normalize_x: float, optional
-            Divide x by this value
-        normalize_z: float, optional
-            Divide z by this value
-        normalize_var: float, optional
-            Divide the variable by this value
         title: str, optional
             The title
         vlabel: str, optional
@@ -867,12 +631,14 @@ class FlowPlots2D(Output):
             Add a color bar
         cmap: str, optional
             The colormap
+        vmin: float, optional
+            The minimal variable value
+        vmax: float, optional
+            The maximal variable value
         quiver_n: int, optional
             Place a vector at ech `n`th point
         quiver_pars: dict, optional
             Parameters for plt.quiver
-        verbosity: int, optional
-            The verbosity level
         ret_state: bool
             Flag for state index return
         ret_im: bool
@@ -880,8 +646,7 @@ class FlowPlots2D(Output):
         animated: bool
             Switch for usage for an animation
         kwargs: dict, optional
-            Parameters forwarded to the algorithm's calc_points
-            function.
+            Additional parameters for SliceData.get_states_data_xz
 
         Yields
         ------
@@ -894,31 +659,17 @@ class FlowPlots2D(Output):
             or matplotlib.QuadContourSet
 
         """
-
-        # create grid:
-        x_pos, y_pos, z_pos, g_pts = get_grid_xz(
-            self.fres,
-            resolution,
-            x_direction,
-            xmin,
-            zmin,
-            xmax,
-            zmax,
-            y,
-            xspace,
-            zspace,
-            verbosity,
-        )
-
-        # calculate point results:
-        point_results = calc_point_results(
-            algo=self.algo,
-            farm_results=self.fres,
-            g_pts=g_pts,
-            verbosity=verbosity,
-            **kwargs,
-        )
-        data = point_results[var].to_numpy()
+        variables = list(set([var]+[FV.WD, FV.WS]))
+        vi = variables.index(var)
+        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, 
+                        **kwargs)
+        x_pos, y_pos, z_pos, __ = gdata
 
         # define wind vector arrows:
         qpars = dict(angles="xy", scale_units="xy", scale=0.05)
@@ -929,27 +680,13 @@ class FlowPlots2D(Output):
             else (
                 quiver_n,
                 qpars,
-                point_results[FV.WD].to_numpy(),
-                point_results[FV.WS].to_numpy(),
+                data[..., wdi],
+                data[..., wsi],
             )
         )
-        del point_results
-
-        # find data min max:
-        vmin = vmin if vmin is not None else np.nanmin(data)
-        vmax = vmax if vmax is not None else np.nanmax(data)
-        if normalize_var is not None:
-            vmin /= normalize_var
-            vmax /= normalize_var
-
-        # normalize x and z:
-        if normalize_x is not None:
-            x_pos /= normalize_x
-        if normalize_z is not None:
-            z_pos /= normalize_z
 
         # loop over states:
-        for si, s in enumerate(self.fres[FC.STATE].to_numpy()):
+        for si, s in enumerate(states):
             if not animated and title is None:
                 ttl = f"State {s}"
                 ttl += f", x direction = {x_direction}°"
@@ -962,24 +699,21 @@ class FlowPlots2D(Output):
                 fig=fig,
                 figsize=figsize,
                 ax=ax,
-                data=data,
+                data=data[..., vi],
                 si=si,
                 s=s,
-                normalize_var=normalize_var,
                 levels=levels,
                 x_pos=x_pos,
                 y_pos=z_pos,
-                vmin=vmin,
-                vmax=vmax,
                 cmap=cmap,
                 xlabel=xlabel,
                 ylabel=zlabel,
                 title=ttl,
                 add_bar=add_bar,
                 vlabel=vlabel,
+                quiv=quiv,
                 ret_state=ret_state,
                 ret_im=ret_im,
-                quiv=quiv,
                 animated=animated,
             )
 
@@ -988,81 +722,43 @@ class FlowPlots2D(Output):
     def gen_states_fig_yz(
         self,
         var,
-        resolution,
         x_direction=270.0,
-        ymin=None,
-        zmin=0.0,
-        ymax=None,
-        zmax=None,
         ylabel="y [m]",
         zlabel="z [m]",
-        x=None,
-        yspace=500.0,
-        zspace=500.0,
         levels=None,
-        vmin=None,
-        vmax=None,
         figsize=None,
-        normalize_y=None,
-        normalize_z=None,
-        normalize_var=None,
         title=None,
         vlabel=None,
         fig=None,
         ax=None,
         add_bar=True,
         cmap=None,
+        vmin=None,
+        vmax=None,
         quiver_n=None,
         quiver_pars={},
-        verbosity=1,
         ret_state=False,
         ret_im=False,
         animated=False,
         **kwargs,
     ):
         """
-        Generates 2D farm flow figure in a plane.
+        Generates 2D farm flow figure in a vertical yz-plane.
 
         Parameters
         ----------
         var: str
             The variable name
-        resolution: float
-            The resolution in m
         x_direction: float, optional
             The direction of the x axis, 0 = north
-        ymin: float, optional
-            The min y coordinate, or None for automatic
-        zmin: float, optional
-            The min z coordinate
-        ymax: float, optional
-            The max y coordinate, or None for automatic
-        zmax: float, optional
-            The max z coordinate, or None for automatic
         ylabel: str, optional
             The y axis label
         zlabel: str, optional
             The z axis label
-        x: float, optional
-            The x coordinate of the plane
-        yspace: float, optional
-            The extra space in y direction, left and right of wind farm
-        zspace: float, optional
-            The extra space in z direction, below and above wind farm
         levels: int, optional
             The number of levels for the contourf plot, or None for pure image
-        vmin: float, optional
-            Minimum variable value
-        vmax: float, optional
-            Maximum variable value
         figsize: tuple, optional
             The figsize for plt.Figure
-        normalize_y: float, optional
-            Divide y by this value
-        normalize_z: float, optional
-            Divide z by this value
-        normalize_var: float, optional
-            Divide the variable by this value
         title: str, optional
             The title
         vlabel: str, optional
@@ -1075,12 +771,14 @@ class FlowPlots2D(Output):
             Add a color bar
         cmap: str, optional
             The colormap
+        vmin: float, optional
+            The minimal variable value
+        vmax: float, optional
+            The maximal variable value
         quiver_n: int, optional
             Place a vector at ech `n`th point
         quiver_pars: dict, optional
             Parameters for plt.quiver
-        verbosity: int, optional
-            The verbosity level
         ret_state: bool
             Flag for state index return
         ret_im: bool
@@ -1088,8 +786,7 @@ class FlowPlots2D(Output):
         animated: bool
             Switch for usage for an animation
         kwargs: dict, optional
-            Parameters forwarded to the algorithm's calc_points
-            function.
+            Additional parameters for SliceData.get_states_data_yz
 
         Yields
         ------
@@ -1102,31 +799,19 @@ class FlowPlots2D(Output):
             or matplotlib.QuadContourSet
 
         """
+        variables = list(set([var]+[FV.WD, FV.WS]))
+        vi = variables.index(var)
+        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, 
+                        **kwargs)
+        x_pos, y_pos, z_pos, __ = gdata
 
-        # create grid:
-        x_pos, y_pos, z_pos, g_pts = get_grid_yz(
-            self.fres,
-            resolution,
-            x_direction,
-            ymin,
-            zmin,
-            ymax,
-            zmax,
-            x,
-            yspace,
-            zspace,
-            verbosity,
-        )
-
-        # calculate point results:
-        point_results = calc_point_results(
-            algo=self.algo,
-            farm_results=self.fres,
-            g_pts=g_pts,
-            verbosity=verbosity,
-            **kwargs,
-        )
-        data = point_results[var].to_numpy()
+        # define wind vector arrows:
         qpars = dict(angles="xy", scale_units="xy", scale=0.05)
         qpars.update(quiver_pars)
         quiv = (
@@ -1135,27 +820,13 @@ class FlowPlots2D(Output):
             else (
                 quiver_n,
                 qpars,
-                point_results[FV.WD].to_numpy(),
-                point_results[FV.WS].to_numpy(),
+                data[..., wdi],
+                data[..., wsi],
             )
         )
-        del point_results
-
-        # find data min max:
-        vmin = vmin if vmin is not None else np.nanmin(data)
-        vmax = vmax if vmax is not None else np.nanmax(data)
-        if normalize_var is not None:
-            vmin /= normalize_var
-            vmax /= normalize_var
-
-        # normalize x and z:
-        if normalize_y is not None:
-            y_pos /= normalize_y
-        if normalize_z is not None:
-            z_pos /= normalize_z
 
         # loop over states:
-        for si, s in enumerate(self.fres[FC.STATE].to_numpy()):
+        for si, s in enumerate(states):
             ttl = f"State {s}" if title is None else title
             ttl += f", x direction = {x_direction}°"
             ttl += f", x =  {int(np.round(x_pos))} m"
@@ -1165,24 +836,21 @@ class FlowPlots2D(Output):
                 fig=fig,
                 figsize=figsize,
                 ax=ax,
-                data=data,
+                data=data[..., vi],
                 si=si,
                 s=s,
-                normalize_var=normalize_var,
                 levels=levels,
                 x_pos=y_pos,
                 y_pos=z_pos,
-                vmin=vmin,
-                vmax=vmax,
                 cmap=cmap,
                 xlabel=ylabel,
                 ylabel=zlabel,
                 title=ttl,
                 add_bar=add_bar,
                 vlabel=vlabel,
+                quiv=quiv,
                 ret_state=ret_state,
                 ret_im=ret_im,
-                quiv=quiv,
                 invert_axis="x",
                 animated=animated,
             )