foxes 1.3__py3-none-any.whl → 1.4__py3-none-any.whl

foxes/input/states/__init__.py

@@ -2,18 +2,28 @@
 Atmospheric input states.
 """
 
-from .single import SingleStateStates
-from .scan import ScanStates
-from .states_table import StatesTable, Timeseries, TabStates
-from .field_data_nc import FieldDataNC
-from .multi_height import MultiHeightStates, MultiHeightTimeseries
-from .multi_height import MultiHeightNCStates, MultiHeightNCTimeseries
+from .single import SingleStateStates as SingleStateStates
+from .scan import ScanStates as ScanStates
+from .field_data_nc import FieldDataNC as FieldDataNC
+from .wrg_states import WRGStates as WRGStates
+from .weibull_sectors import WeibullSectors as WeibullSectors
+
+from .states_table import StatesTable as StatesTable
+from .states_table import Timeseries as Timeseries
+from .states_table import TabStates as TabStates
+
+from .multi_height import MultiHeightStates as MultiHeightStates
+from .multi_height import MultiHeightTimeseries as MultiHeightTimeseries
+from .multi_height import MultiHeightNCStates as MultiHeightNCStates
+from .multi_height import MultiHeightNCTimeseries as MultiHeightNCTimeseries
+
+from .one_point_flow import OnePointFlowStates as OnePointFlowStates
+from .one_point_flow import OnePointFlowTimeseries as OnePointFlowTimeseries
+from .one_point_flow import (
+    OnePointFlowMultiHeightTimeseries as OnePointFlowMultiHeightTimeseries,
+)
 from .one_point_flow import (
-    OnePointFlowStates,
-    OnePointFlowTimeseries,
-    OnePointFlowMultiHeightTimeseries,
-    OnePointFlowMultiHeightNCTimeseries,
+    OnePointFlowMultiHeightNCTimeseries as OnePointFlowMultiHeightNCTimeseries,
 )
-from .wrg_states import WRGStates
 
-from . import create
+from . import create as create

foxes/input/states/create/__init__.py

@@ -1,2 +1,3 @@
-from .random_abl_states import create_random_abl_states, write_random_abl_states
-from .random_timeseries import random_timseries_data
+from .random_abl_states import create_random_abl_states as create_random_abl_states
+from .random_abl_states import write_random_abl_states as write_random_abl_states
+from .random_timeseries import random_timseries_data as random_timseries_data

foxes/input/states/field_data_nc.py

@@ -303,7 +303,7 @@ class FieldDataNC(States):
                 d = data[..., i]
                 nn = np.sum(np.isnan(d))
                 print(
-                    f"  {v}: {np.nanmin(d)} --> {np.nanmax(d)}, nans: {nn} ({100*nn/len(d.flat):.2f}%)"
+                    f"  {v}: {np.nanmin(d)} --> {np.nanmax(d)}, nans: {nn} ({100 * nn / len(d.flat):.2f}%)"
                 )
 
         return sts, h, y, x, data, weights
@@ -352,7 +352,6 @@ class FieldDataNC(States):
         # pre-load file reading:
         coords = [self.states_coord, self.h_coord, self.y_coord, self.x_coord]
         if not isinstance(self.data_source, xr.Dataset):
-
             # check variables:
             for v in self.ovars:
                 if v == FV.WEIGHT and self.weight_ncvar is None:
@@ -422,7 +421,6 @@ class FieldDataNC(States):
             )
 
             if self.load_mode in ["preload", "lazy"]:
-
                 if self.load_mode == "lazy":
                     try:
                         self.__data_source = [ds.chunk() for ds in self.__data_source]
@@ -460,6 +458,11 @@ class FieldDataNC(States):
                     self.__inds, format=self.time_format
                 ).to_numpy()
 
+        # given data is already Dataset:
+        else:
+            self.__inds = self.data_source[self.states_coord].to_numpy()
+            self._N = len(self.__inds)
+
         # ensure WD and WS get the first two slots of data:
         self._dkys = {}
         if FV.WS in self.ovars:
@@ -601,23 +604,6 @@ class FieldDataNC(States):
             raise ValueError(f"States '{self.name}': Cannot access index while running")
         return self.__inds
 
-    def output_point_vars(self, algo):
-        """
-        The variables which are being modified by the model.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-
-        Returns
-        -------
-        output_vars: list of str
-            The output variable names
-
-        """
-        return self.ovars
-
     def calculate(self, algo, mdata, fdata, tdata):
         """
         The main model calculation.
@@ -706,9 +692,9 @@ class FieldDataNC(States):
                         i0 += b - a
                     j0 = j1
 
-            assert (
-                i0 == i1
-            ), f"States '{self.name}': Missing states for load_mode '{self.load_mode}': (i0, i1) = {(i0, i1)}"
+            assert i0 == i1, (
+                f"States '{self.name}': Missing states for load_mode '{self.load_mode}': (i0, i1) = {(i0, i1)}"
+            )
 
             data = xr.concat(data, dim=self.states_coord)
             __, h, y, x, data, weights = self._get_data(data, coords, verbosity=0)
@@ -830,7 +816,7 @@ class FieldDataNC(States):
             if v != FV.WEIGHT and v not in out:
                 if v in self._dkys:
                     out[v] = data[..., self._dkys[v]]
-                else:
+                elif v in self.fixed_vars:
                     out[v] = np.full(
                         (n_states, n_pts), self.fixed_vars[v], dtype=config.dtype_double
                     )

foxes/input/states/multi_height.py

@@ -36,7 +36,7 @@ class MultiHeightStates(States):
     fixed_vars: dict, optional
         Fixed uniform variable values, instead of
         reading from data
-    pd_read_pars: dict, optional
+    read_pars: dict, optional
         pandas file reading parameters
     states_sel: slice or range or list of int
         States subset selection
@@ -58,7 +58,7 @@ class MultiHeightStates(States):
         heights,
         var2col={},
         fixed_vars={},
-        pd_read_pars={},
+        read_pars={},
         states_sel=None,
         states_loc=None,
         **ipars,
@@ -79,7 +79,7 @@ class MultiHeightStates(States):
         fixed_vars: dict, optional
             Fixed uniform variable values, instead of
             reading from data
-        pd_read_pars: dict, optional
+        read_pars: dict, optional
             pandas file reading parameters
         states_sel: slice or range or list of int, optional
             States subset selection
@@ -93,7 +93,7 @@ class MultiHeightStates(States):
 
         self.ovars = list(output_vars)
         self.heights = np.array(heights, dtype=config.dtype_double)
-        self.rpars = pd_read_pars
+        self.rpars = read_pars
         self.var2col = var2col
         self.fixed_vars = fixed_vars
         self.ipars = ipars
@@ -572,7 +572,7 @@ class MultiHeightNCStates(MultiHeightStates):
             data_source,
             *args,
             heights=[],
-            pd_read_pars=None,
+            read_pars=None,
             **kwargs,
         )
         self.state_coord = state_coord
@@ -631,7 +631,10 @@ class MultiHeightNCStates(MultiHeightStates):
         self._inds = data.coords[self.state_coord].to_numpy()
 
         if self._format_times_func == "default":
-            format_times_func = lambda t: t.astype("datetime64[ns]")
+
+            def format_times_func(t):
+                """little helper function to convert times to datetime64"""
+                return t.astype("datetime64[ns]")
         else:
             format_times_func = self._format_times_func
         if format_times_func is not None:

foxes/input/states/one_point_flow.py

@@ -260,7 +260,6 @@ class OnePointFlowStates(States):
             self.timelines_data = data.pop("data")
 
     def calc_states_indices(self, algo, mdata, points, hi, ref_xy):
-
         n_states, n_points = points.shape[:2]
         dxy = self.timelines_data["dxy"].to_numpy()[hi]
 
@@ -301,7 +300,6 @@ class OnePointFlowStates(States):
         sel = np.isnan(coeffs)
         tshift = 0
         while np.any(sel):
-
             trs = trace_si[sel]
             hdxy = -dxy[trs]
             trace_p[sel] += hdxy
@@ -326,7 +324,6 @@ class OnePointFlowStates(States):
             sel &= trace_si < algo.n_states
             tshift = 1
             while np.any(sel):
-
                 trs = trace_si[sel]
                 hdxy = dxy[trs]
                 trace_p[sel] += hdxy
@@ -420,7 +417,6 @@ class OnePointFlowStates(States):
 
         # interpolate to heights:
         if n_heights > 1:
-
             ar_states = np.arange(n_states)
             ar_points = np.arange(n_points)
 

foxes/input/states/single.py

@@ -75,7 +75,7 @@ class SingleStateStates(States):
             and not len(profiles)
         ):
             raise KeyError(
-                f"Expecting at least one parameter: ws, wd, ti, rho, profiles"
+                "Expecting at least one parameter: ws, wd, ti, rho, profiles"
             )
 
     def sub_models(self):

foxes/input/states/states_table.py

@@ -51,7 +51,7 @@ class StatesTable(States):
         var2col={},
         fixed_vars={},
         profiles={},
-        pd_read_pars={},
+        read_pars={},
         states_sel=None,
         states_loc=None,
     ):
@@ -72,7 +72,7 @@ class StatesTable(States):
         profiles: dict
             Key: output variable name str, Value: str or dict
             or `foxes.core.VerticalProfile`
-        pd_read_pars: dict
+        read_pars: dict
             pandas file reading parameters
         states_sel: slice or range or list of int, optional
             States subset selection
@@ -83,7 +83,7 @@ class StatesTable(States):
         super().__init__()
 
         self.ovars = list(output_vars)
-        self.rpars = pd_read_pars
+        self.rpars = read_pars
         self.var2col = var2col
         self.fixed_vars = fixed_vars
         self.profdicts = profiles
@@ -153,7 +153,6 @@ class StatesTable(States):
 
         """
         self._profiles = {}
-        self._tvars = set(self.ovars)
         for v, d in self.profdicts.items():
             if isinstance(d, str):
                 self._profiles[v] = VerticalProfile.new(d)
@@ -166,9 +165,7 @@ class StatesTable(States):
                 raise TypeError(
                     f"States '{self.name}': Wrong profile type '{type(d).__name__}' for variable '{v}'. Expecting VerticalProfile, str or dict"
                 )
-            self._tvars.update(self._profiles[v].input_vars())
-        self._tvars -= set(self.fixed_vars.keys())
-        self._tvars = list(self._tvars)
+
         super().initialize(algo, verbosity)
 
     def sub_models(self):
@@ -245,6 +242,12 @@ class StatesTable(States):
                 f"Weight variable '{col_w}' defined in var2col, but not found in states table columns {data.columns}"
             )
 
+        self._tvars = set(self.ovars)
+        for v in self.profdicts.keys():
+            self._tvars.update(self._profiles[v].input_vars())
+        self._tvars -= set(self.fixed_vars.keys())
+        self._tvars = list(self._tvars)
+
         tcols = []
         for v in self._tvars:
             c = self.var2col.get(v, v)

foxes/input/states/weibull_sectors.py

@@ -0,0 +1,225 @@
+import numpy as np
+import pandas as pd
+from os import PathLike
+from xarray import Dataset, open_dataset
+
+from foxes.data import STATES
+from foxes.utils import PandasFileHelper, weibull_weights
+from foxes.config import config, get_input_path
+import foxes.variables as FV
+import foxes.constants as FC
+
+from .states_table import StatesTable
+
+
+class WeibullSectors(StatesTable):
+    """
+    States with wind speed from Weibull parameters
+    from a NetCDF file
+
+    Attributes
+    ----------
+    ws_bins: numpy.ndarray
+        The wind speed bins, including
+        lower and upper bounds, shape: (n_ws_bins+1,)
+    var2ncvar: dict
+        Mapping from variable names to variable names
+        in the nc file
+    sel: dict
+        Subset selection via xr.Dataset.sel()
+    isel: dict
+        Subset selection via xr.Dataset.isel()
+    RDICT: dict
+        Default xarray file reading parameters
+
+    :group: input.states
+
+    """
+
+    RDICT = {}
+
+    def __init__(
+        self,
+        data_source,
+        output_vars,
+        ws_bins=None,
+        var2ncvar={},
+        sel=None,
+        isel=None,
+        **kwargs,
+    ):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        data_source: str or xarray.Dataset or pandas.DataFrame
+            Either path to NetCDF or csv file or data
+        output_vars: list of str
+            The output variables
+        ws_bins: list of float, optional
+            The wind speed bins, including
+            lower and upper bounds
+        var2ncvar: dict
+            Mapping from variable names to variable names
+            in the nc file
+        sel: dict, optional
+            Subset selection via xr.Dataset.sel()
+        isel: dict, optional
+            Subset selection via xr.Dataset.isel()
+        kwargs: dict, optional
+            Additional arguments for the base class
+
+        """
+        super().__init__(data_source, output_vars, var2col={}, **kwargs)
+        self.ws_bins = None if ws_bins is None else np.asarray(ws_bins)
+        self.var2ncvar = var2ncvar
+        self.sel = sel if sel is not None else {}
+        self.isel = isel if isel is not None else {}
+
+        if FV.WS not in self.ovars:
+            raise ValueError(
+                f"States '{self.name}': Expecting output variable '{FV.WS}', got {self.ovars}"
+            )
+        for v in [FV.WEIBULL_A, FV.WEIBULL_k, FV.WEIGHT]:
+            if v in self.ovars:
+                raise ValueError(
+                    f"States '{self.name}': Cannot have '{v}' as output variable"
+                )
+
+        self._original_data_source = None
+
+    def __repr__(self):
+        return f"{type(self).__name__}(ws_bins={self._n_ws})"
+
+    def load_data(self, algo, verbosity=0):
+        """
+        Load and/or create all model data that is subject to chunking.
+
+        Such data should not be stored under self, for memory reasons. The
+        data returned here will automatically be chunked and then provided
+        as part of the mdata object during calculations.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        verbosity: int
+            The verbosity level, 0 = silent
+
+        Returns
+        -------
+        idata: dict
+            The dict has exactly two entries: `data_vars`,
+            a dict with entries `name_str -> (dim_tuple, data_ndarray)`;
+            and `coords`, a dict with entries `dim_name_str -> dim_array`
+
+        """
+
+        if self._original_data_source is not None:
+            self._data_source = self._original_data_source
+            self._original_data_source = None
+
+        if isinstance(self.data_source, (str, PathLike)):
+            fpath = get_input_path(self.data_source)
+            if not fpath.is_file():
+                if verbosity > 0:
+                    print(
+                        f"States '{self.name}': Reading static data '{fpath}' from context '{STATES}'"
+                    )
+                fpath = algo.dbook.get_file_path(STATES, fpath.name, check_raw=False)
+                if verbosity > 0:
+                    print(f"Path: {fpath}")
+            elif verbosity:
+                print(f"States '{self.name}': Reading file {fpath}")
+            rpars = dict(self.RDICT, **self.rpars)
+            if fpath.suffix == ".nc":
+                data = open_dataset(fpath, engine=config.nc_engine, **rpars)
+            else:
+                data = PandasFileHelper().read_file(fpath, **rpars).to_xarray()
+            self._original_data_source = data
+
+        elif isinstance(self.data_source, Dataset):
+            data = self.data_source
+
+        elif isinstance(self.data_source, pd.DataFrame):
+            data = self.data_source.to_xarray()
+
+        if self.isel is not None and len(self.isel):
+            data = data.isel(**self.isel)
+        if self.sel is not None and len(self.sel):
+            data = data.sel(**self.sel)
+
+        wsn = self.var2ncvar.get(FV.WS, FV.WS)
+        if self.ws_bins is not None:
+            wsb = self.ws_bins
+        elif wsn in data:
+            wsb = data[wsn].to_numpy()
+        else:
+            raise ValueError(
+                f"States '{self.name}': Expecting ws_bins argument, since '{wsn}' not found in data"
+            )
+        wss = 0.5 * (wsb[:-1] + wsb[1:])
+        wsd = wsb[1:] - wsb[:-1]
+        n_ws = len(wss)
+        self._n_ws = n_ws
+        del wsb
+
+        secn = None
+        n_secs = None
+        if self._original_data_source is None:
+            self._original_data_source = self.data_source
+        self._data_source = {}
+        for v in [FV.WEIBULL_A, FV.WEIBULL_k, FV.WEIGHT] + self.ovars:
+            if v != FV.WS and v not in self.fixed_vars:
+                c = self.var2ncvar.get(v, v)
+                if c not in data:
+                    raise KeyError(
+                        f"States '{self.name}': Missing variable '{c}' in data, found {list(data.data_vars.keys())}"
+                    )
+                d = data[c]
+                if len(d.dims) == 0:
+                    self.fixed_vars[v] = float(d.to_numpy())
+                    continue
+                elif len(d.dims) != 1:
+                    raise ValueError(
+                        f"States '{self.name}': Expecting single dimension for variable '{c}', got {d.dims}"
+                    )
+                elif secn is None:
+                    secn = d.dims[0]
+                    n_secs = data.sizes[secn]
+                elif d.dims[0] != secn:
+                    raise ValueError(
+                        f"States '{self.name}': Expecting dimension '{secn}' for variable '{c}', got {d.dims}"
+                    )
+                self._data_source[v] = np.zeros(
+                    (n_secs, n_ws), dtype=config.dtype_double
+                )
+                self._data_source[v][:] = d.to_numpy()[:, None]
+        self._data_source[FV.WS] = np.zeros((n_secs, n_ws), dtype=config.dtype_double)
+        self._data_source[FV.WS][:] = wss[None, :]
+        del wss
+
+        self._data_source[FV.WEIGHT] *= weibull_weights(
+            ws=self._data_source[FV.WS],
+            ws_deltas=wsd[None, :],
+            A=self._data_source.pop(FV.WEIBULL_A),
+            k=self._data_source.pop(FV.WEIBULL_k),
+        )
+
+        # remove wd 360 from the end, if wd 0 is given:
+        if FV.WD in self._data_source:
+            if np.all(self._data_source[FV.WD][0] == 0.0) and np.all(
+                self._data_source[FV.WD][-1] == 360.0
+            ):
+                for v in self._data_source.keys():
+                    self._data_source[v] = self._data_source[v][:-1]
+                n_secs -= 1
+
+        N = n_secs * n_ws
+        for v in self._data_source.keys():
+            self._data_source[v] = self._data_source[v].reshape(N)
+        self._data_source = pd.DataFrame(data=self._data_source, index=np.arange(N))
+        self._data_source.index.name = FC.STATE
+
+        return super().load_data(algo, verbosity)

foxes/input/states/wrg_states.py

@@ -3,7 +3,7 @@ from scipy.interpolate import interpn
 
 from foxes.core.states import States
 from foxes.config import config, get_input_path
-from foxes.utils.wrg_utils import ReaderWRG
+from foxes.utils import ReaderWRG, weibull_weights
 from foxes.data import STATES
 import foxes.variables as FV
 import foxes.constants as FC
@@ -132,7 +132,7 @@ class WRGStates(States):
         self._y = p0[1] + np.arange(ny) * res
         self._y = self._y[sy]
         if len(self._x) < 2 or len(self._y) < 2:
-            raise ValueError(f"No overlap between data bounds and farm bounds")
+            raise ValueError("No overlap between data bounds and farm bounds")
         p0[0] = np.min(self._x)
         p0[1] = np.min(self._y)
         p1[0] = np.max(self._x)
@@ -293,9 +293,11 @@ class WRGStates(States):
             dims=(FC.STATE, FC.TARGET, FC.TPOINT),
         )
 
-        wsA = out[FV.WS] / A
-        tdata[FV.WEIGHT] *= wsd[:, None, None] * (
-            k / A * wsA ** (k - 1) * np.exp(-(wsA**k))
+        tdata[FV.WEIGHT] *= weibull_weights(
+            ws=out[FV.WS],
+            ws_deltas=wsd[:, None, None],
+            A=A,
+            k=k,
         )
 
         return out

foxes/input/yaml/__init__.py

@@ -1,3 +1,9 @@
-from .dict import read_dict, run_dict, run_outputs, run_obj_function, get_output_obj
-from .yaml import foxes_yaml
-from .windio.windio import read_windio, foxes_windio
+from .dict import read_dict as read_dict
+from .dict import run_dict as run_dict
+from .dict import run_outputs as run_outputs
+from .dict import run_obj_function as run_obj_function
+from .dict import get_output_obj as get_output_obj
+
+from .yaml import foxes_yaml as foxes_yaml
+from .windio.windio import read_windio as read_windio
+from .windio.windio import foxes_windio as foxes_windio

foxes/input/yaml/dict.py

@@ -75,13 +75,13 @@ def read_dict(
             print(*args, **kwargs)
 
     # set working directory:
-    l = 0
+    ld = 0
     for c, d in zip(
         [FC.WORK_DIR, FC.INPUT_DIR, FC.OUTPUT_DIR], [work_dir, input_dir, output_dir]
     ):
         if d is not None:
             config[c] = d
-            l = max(l, len(str(d)))
+            ld = max(ld, len(str(d)))
     _print("\n--------------------- Reading foxes parameter dict ---------------------")
     _print("Working directory  :", config.work_dir)
     _print("Input directory    :", config.input_dir)
@@ -95,9 +95,9 @@ def read_dict(
         else:
             states = algo.states
     else:
-        assert (
-            algo is None
-        ), f"Cannot handle both the algo and the states argument, please drop one"
+        assert algo is None, (
+            "Cannot handle both the algo and the states argument, please drop one"
+        )
 
     # create model book:
     if mbook is None:
@@ -119,9 +119,9 @@ def read_dict(
         else:
             mbook = algo.mbook
     else:
-        assert (
-            algo is None
-        ), f"Cannot handle both the algo and the mbook argument, please drop one"
+        assert algo is None, (
+            "Cannot handle both the algo and the mbook argument, please drop one"
+        )
 
     # create farm:
     if farm is None:
@@ -129,8 +129,8 @@ def read_dict(
             _print("Creating wind farm")
             fdict = idict.get_item("wind_farm")
             lyts = [
-                Dict(l, name=f"{fdict.name}.layout{i}")
-                for i, l in enumerate(fdict.pop_item("layouts"))
+                Dict(lo, name=f"{fdict.name}.layout{i}")
+                for i, lo in enumerate(fdict.pop_item("layouts"))
             ]
             farm = WindFarm(**fdict)
             for lyt in lyts:
@@ -141,9 +141,9 @@ def read_dict(
         else:
             farm = algo.farm
     else:
-        assert (
-            algo is None
-        ), f"Cannot handle both the algo and the farm argument, please drop one"
+        assert algo is None, (
+            "Cannot handle both the algo and the farm argument, please drop one"
+        )
 
     # create engine:
     engine = None
@@ -321,12 +321,12 @@ def run_obj_function(
 
         def _set_label(rlabels, k, r):
             if k not in ["", "none", "None", "_", "__"]:
-                assert (
-                    k[0] == "$"
-                ), f"Output {i} of type '{ocls}', function '{fname}': result labels must start with '$', got '{k}'"
-                assert (
-                    "[" not in k and "]" not in k and "," not in k
-                ), f"Output {i} of type '{ocls}', function '{fname}': result labels cannot contain '[' or ']' or comma, got '{k}'"
+                assert k[0] == "$", (
+                    f"Output {i} of type '{ocls}', function '{fname}': result labels must start with '$', got '{k}'"
+                )
+                assert "[" not in k and "]" not in k and "," not in k, (
+                    f"Output {i} of type '{ocls}', function '{fname}': result labels cannot contain '[' or ']' or comma, got '{k}'"
+                )
                 _print(f"    result label {k}: {type(r).__name__}")
                 rlabels[k] = r
 

foxes/input/yaml/windio/__init__.py

@@ -1,5 +1,10 @@
-from .windio import foxes_windio, read_windio
-from .read_site import read_site
-from .read_fields import read_wind_resource_field
-from .read_farm import read_layout, read_turbine_types, read_farm
-from .read_attributes import read_attributes
+from .windio import foxes_windio as foxes_windio
+from .windio import read_windio as read_windio
+
+from .read_farm import read_layout as read_layout
+from .read_farm import read_turbine_types as read_turbine_types
+from .read_farm import read_farm as read_farm
+
+from .read_site import read_site as read_site
+from .read_fields import read_wind_resource_field as read_wind_resource_field
+from .read_attributes import read_attributes as read_attributes

foxes/input/yaml/windio/read_attributes.py

@@ -202,7 +202,7 @@ def _read_rotor_averaging(rotor_averaging, algo_dict, verbosity):
     elif background_averaging in ["none", "None", None]:
         algo_dict["rotor_model"] = None
     elif background_averaging == "grid":
-        algo_dict["rotor_model"] = f"grid{nx*ny}"
+        algo_dict["rotor_model"] = f"grid{nx * ny}"
     else:
         algo_dict["rotor_model"] = background_averaging
 
@@ -215,7 +215,7 @@ def _read_rotor_averaging(rotor_averaging, algo_dict, verbosity):
             algo_dict["partial_wakes"] = "rotor_points"
         else:
             if grid == "grid":
-                algo_dict["partial_wakes"] = f"grid{nx*ny}"
+                algo_dict["partial_wakes"] = f"grid{nx * ny}"
             else:
                 algo_dict["partial_wakes"] = grid
     else: