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

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

@@ -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

foxes/output/state_turbine_table.py

@@ -1,22 +1,24 @@
 from xarray import Dataset
 
 from foxes.utils import write_nc
-import foxes.constants as FC 
+import foxes.constants as FC
 
 from .output import Output
 
+
 class StateTurbineTable(Output):
     """
     Creates tables of state-turbine type data
-    
+
     Attributes
     ----------
     farm_results: xarray.Dataset
         The farm results
-    
+
     :group: output
-    
+
     """
+
     def __init__(self, farm_results):
         """
         Constructor.
@@ -28,17 +30,17 @@ class StateTurbineTable(Output):
 
         """
         self.farm_results = farm_results
-    
+
     def get_dataset(
-        self, 
-        variables, 
-        name_map={}, 
-        to_file=None, 
+        self,
+        variables,
+        name_map={},
+        to_file=None,
         **kwargs,
-        ):
+    ):
         """
         Creates a dataset object
-        
+
         Parameters
         ----------
         variables: list of str
@@ -49,12 +51,12 @@ class StateTurbineTable(Output):
             The output file path, if writing is desired
         kwargs: dict, optional
             Additional parameters for write_nc
-        
+
         Returns
         -------
         table: xarray.Dataset
             The state-turbine data table
-            
+
         """
         state = name_map.get(FC.STATE, FC.STATE)
         turbine = name_map.get(FC.TURBINE, FC.TURBINE)
@@ -65,14 +67,12 @@ class StateTurbineTable(Output):
                 turbine: self.farm_results[FC.TURBINE].to_numpy(),
             },
             data_vars={
-                name_map.get(v, v): (
-                    (state, turbine), self.farm_results[v].to_numpy())
+                name_map.get(v, v): ((state, turbine), self.farm_results[v].to_numpy())
                 for v in variables
-            }
+            },
         )
-        
+
         if to_file is not None:
             write_nc(ds=ds, fpath=to_file, **kwargs)
-        
+
         return ds
-    

foxes/utils/__init__.py

@@ -17,8 +17,8 @@ from .regularize import sqrt_reg
 from .windrose_plot import TabWindroseAxes
 from .tab_files import read_tab_file
 from .random_xy import random_xy_square
+from .dev_utils import print_mem
 
 from . import two_circles
 from . import abl
-from . import runners
 from . import geom2d

foxes/utils/dev_utils.py

@@ -0,0 +1,42 @@
+from .load import import_module
+
+
+def print_mem(obj, min_csize=0, max_csize=None, pre_str="OBJECT SIZE"):
+    """
+    Prints the memory consumption of a model and its components
+
+    Parmeters
+    ---------
+    obj: object
+        The object to be analyzed
+    min_csize: int
+        The minimal size of a component for being shown
+    max_csize: int, optional
+        The maximal allowed size of a component
+    pre_str: str
+        String to be printed before
+
+    :group: utils
+
+    """
+    objsize = import_module("objsize")
+    n = obj.name if hasattr(obj, "name") else ""
+    print(pre_str, type(obj).__name__, n, objsize.get_deep_size(obj))
+    for k in dir(obj):
+        o = None
+        try:
+            if (
+                hasattr(obj, k)
+                and not callable(getattr(obj, k))
+                and (len(k) < 3 or k[:2] != "__")
+            ):
+                o = getattr(obj, k)
+        except ValueError:
+            pass
+
+        if o is not None:
+            s = objsize.get_deep_size(getattr(obj, k))
+            if s >= min_csize:
+                print("   ", k, s)
+                if max_csize is not None and s > max_csize:
+                    raise ValueError(f"Component {k} exceeds maximal size {max_csize}")