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

foxes/models/partial_wakes/axiwake.py

@@ -95,7 +95,7 @@ class PartialAxiwake(PartialCentre):
             The target point data
         downwind_index: int
             The index of the wake causing turbine
-            in the downwnd order
+            in the downwind order
         wake_deltas: dict
             The wake deltas. Key: variable name,
             value: numpy.ndarray with shape
@@ -127,7 +127,7 @@ class PartialAxiwake(PartialCentre):
         wcoos = algo.wake_frame.get_wake_coos(algo, mdata, fdata, tdata, downwind_index)
 
         # prepare x and r coordinates:
-        x = np.round(wcoos[..., 0, 0], 12)
+        x = wcoos[..., 0, 0]
         n = wcoos[..., 0, 1:3]
         R = np.linalg.norm(n, axis=-1)
         r = np.zeros((n_states, n_targets, self.n), dtype=FC.DTYPE)
@@ -145,7 +145,7 @@ class PartialAxiwake(PartialCentre):
             n[:, :, 0][~sel] = 1
 
         # case wake centre outside rotor disk:
-        sel = (x > 0) & (R > D / 2)
+        sel = (x > 1e-8) & (R > D / 2)
         if np.any(sel):
             n_sel = np.sum(sel)
             Rsel = np.zeros((n_sel, self.n + 1), dtype=FC.DTYPE)

foxes/models/partial_wakes/rotor_points.py

@@ -1,4 +1,5 @@
 from foxes.core import PartialWakesModel
+import foxes.constants as FC
 
 
 class RotorPoints(PartialWakesModel):
@@ -33,10 +34,9 @@ class RotorPoints(PartialWakesModel):
             The target point weights, shape: (n_tpoints,)
 
         """
-        rotor = algo.rotor_model
         return (
-            rotor.from_data_or_store(rotor.RPOINTS, algo, mdata),
-            rotor.from_data_or_store(rotor.RWEIGHTS, algo, mdata),
+            algo.get_from_chunk_store(FC.ROTOR_POINTS, mdata=mdata),
+            algo.get_from_chunk_store(FC.ROTOR_WEIGHTS, mdata=mdata),
         )
 
     def finalize_wakes(

foxes/models/partial_wakes/top_hat.py

@@ -121,7 +121,7 @@ class PartialTopHat(PartialCentre):
             The target point data
         downwind_index: int
             The index of the wake causing turbine
-            in the downwnd order
+            in the downwind order
         wake_deltas: dict
             The wake deltas. Key: variable name,
             value: numpy.ndarray with shape
@@ -148,7 +148,7 @@ class PartialTopHat(PartialCentre):
             upcast=True,
         )
 
-        sel0 = (ct > 0) & (x > 0)
+        sel0 = (ct > 1e-8) & (x > 1e-8)
         if np.any(sel0):
             R = np.linalg.norm(yz, axis=-1)
             del yz

foxes/models/point_models/set_uniform_data.py

@@ -119,7 +119,7 @@ class SetUniformData(PointDataModel):
         return self.ovars
 
     def calculate(self, algo, mdata, fdata, pdata):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,

foxes/models/point_models/tke2ti.py

@@ -30,7 +30,7 @@ class TKE2TI(PointDataModel):
         return [FV.TI]
 
     def calculate(self, algo, mdata, fdata, pdata):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,

foxes/models/point_models/wake_deltas.py

@@ -52,7 +52,7 @@ class WakeDeltas(PointDataModel):
         return [f"DELTA_{v}" for v in self.vars]
 
     def calculate(self, algo, mdata, fdata, pdata):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,

foxes/models/rotor_models/centre.py

@@ -132,6 +132,10 @@ class CentreRotor(RotorModel):
         n_states = mdata.n_states
         n_turbines = algo.n_turbines
 
+        for v in [FV.REWS2, FV.REWS3]:
+            if v in fdata and v not in self.calc_vars:
+                self.calc_vars.append(v)
+
         uvp = None
         uv = None
         if (

foxes/models/rotor_models/grid.py

@@ -16,8 +16,8 @@ class GridRotor(RotorModel):
         maximal number of points is N = n * n
     reduce: bool
         Flag for reduction to points actually representing
-        an area with overlap with the circe, recalculating
-        the self.weights accordingly
+        an area with overlap with the circle, recalculating
+        the self.__weights accordingly
     nint: int
         Integration steps per element
 
@@ -25,7 +25,7 @@ class GridRotor(RotorModel):
 
     """
 
-    def __init__(self, n, calc_vars, reduce=True, nint=200):
+    def __init__(self, n, reduce=True, nint=200, **kwargs):
         """
         Constructor.
 
@@ -34,20 +34,19 @@ class GridRotor(RotorModel):
         n: int
             The number of points along one direction,
             maximal number of points is N = n * n
-        calc_vars: list of str
-            The variables that are calculated by the model
-            (Their ambients are added automatically)
         reduce: bool
             Flag for reduction to points actually representing
-            an area with overlap with the circe, recalculating
-            the self.weights accordingly
+            an area with overlap with the circle, recalculating
+            the self.__weights accordingly
         nint: int
             Integration steps per element
         name: str, optional
             The model name
+        kwargs: dict, optional
+            Addition parameters for the base model
 
         """
-        super().__init__(calc_vars)
+        super().__init__(**kwargs)
 
         self.n = n
         self.reduce = reduce
@@ -76,12 +75,12 @@ class GridRotor(RotorModel):
         x = [-1.0 + (i + 0.5) * delta for i in range(self.n)]
         x, y = np.meshgrid(x, x, indexing="ij")
 
-        self.dpoints = np.zeros([N, 3], dtype=FC.DTYPE)
-        self.dpoints[:, 1] = x.reshape(N)
-        self.dpoints[:, 2] = y.reshape(N)
+        self.__dpoints = np.zeros([N, 3], dtype=FC.DTYPE)
+        self.__dpoints[:, 1] = x.reshape(N)
+        self.__dpoints[:, 2] = y.reshape(N)
 
         if self.reduce:
-            self.weights = np.zeros((self.n, self.n), dtype=FC.DTYPE)
+            self.__weights = np.zeros((self.n, self.n), dtype=FC.DTYPE)
             for i in range(0, self.n):
                 for j in range(0, self.n):
                     d = delta / self.nint
@@ -95,18 +94,18 @@ class GridRotor(RotorModel):
                     pts[:, :, 0], pts[:, :, 1] = np.meshgrid(hx, hy, indexing="ij")
 
                     d = np.linalg.norm(pts, axis=2)
-                    self.weights[i, j] = np.sum(d <= 1.0) / self.nint**2
+                    self.__weights[i, j] = np.sum(d <= 1.0) / self.nint**2
 
-            self.weights = self.weights.reshape(N)
-            sel = self.weights > 0.0
-            self.dpoints = self.dpoints[sel]
-            self.weights = self.weights[sel]
-            self.weights /= np.sum(self.weights)
+            self.__weights = self.__weights.reshape(N)
+            sel = self.__weights > 0.0
+            self.__dpoints = self.__dpoints[sel]
+            self.__weights = self.__weights[sel]
+            self.__weights /= np.sum(self.__weights)
 
         else:
-            self.dpoints[:, 1] = x.reshape(N)
-            self.dpoints[:, 2] = y.reshape(N)
-            self.weights = np.ones(N, dtype=FC.DTYPE) / N
+            self.__dpoints[:, 1] = x.reshape(N)
+            self.__dpoints[:, 2] = y.reshape(N)
+            self.__weights = np.ones(N, dtype=FC.DTYPE) / N
 
     def n_rotor_points(self):
         """
@@ -118,7 +117,7 @@ class GridRotor(RotorModel):
             The number of rotor points
 
         """
-        return len(self.weights)
+        return len(self.__weights)
 
     def design_points(self):
         """
@@ -137,7 +136,7 @@ class GridRotor(RotorModel):
             The design points, shape: (n_points, 3)
 
         """
-        return self.dpoints
+        return self.__dpoints
 
     def rotor_point_weights(self):
         """
@@ -150,4 +149,4 @@ class GridRotor(RotorModel):
             add to one, shape: (n_rpoints,)
 
         """
-        return self.weights
+        return self.__weights

foxes/models/rotor_models/levels.py

@@ -24,7 +24,7 @@ class LevelRotor(RotorModel):
 
     """
 
-    def __init__(self, n, calc_vars, reduce=True, nint=200):
+    def __init__(self, n, reduce=True, nint=200, **kwargs):
         """
         Constructor.
 
@@ -32,9 +32,6 @@ class LevelRotor(RotorModel):
         ----------
         n: int
             The number of points along the vertical direction
-        calc_vars: list of str
-            The variables that are calculated by the model
-            (Their ambients are added automatically)
         reduce: bool
             Flag for calculating the weight of every element according
             to the rotor diameter at the respective height level
@@ -42,9 +39,11 @@ class LevelRotor(RotorModel):
             Integration steps per element
         name: str, optional
             The model name
+        kwargs: dict, optional
+            Addition parameters for the base model
 
         """
-        super().__init__(calc_vars)
+        super().__init__(**kwargs)
 
         self.n = n
         self.reduce = reduce

foxes/models/turbine_models/calculator.py

@@ -1,5 +1,3 @@
-import numpy as np
-
 from foxes.core import TurbineModel
 
 
@@ -10,11 +8,11 @@ class Calculator(TurbineModel):
     Attributes
     ----------
     in_vars: list of str
-        The input farm vairables
+        The input farm variables
     out_vars: list of str
         The output variables
     func: Function
-        The function: f(in0, in1, ..., stsel) -> (out0, ou1, ...)
+        The function: f(in0, in1, ..., stsel) -> (out0, out1, ...)
         where inX and outY are numpy.ndarrays and
         st_sel is the state-turbine selection slice or array.
         All arrays have shape (n_states, n_turbines).
@@ -30,11 +28,11 @@ class Calculator(TurbineModel):
         Parameters
         ----------
         in_vars: list of str
-            The input farm vairables
+            The input farm variables
         out_vars: list of str
             The output variables
         func: Function
-            The function: f(in0, in1, ..., stsel) -> (out0, ou1, ...)
+            The function: f(in0, in1, ..., stsel) -> (out0, out1, ...)
             where inX and outY are numpy.ndarrays and
             st_sel is the state-turbine selection slice or array.
             All arrays have shape (n_states, n_turbines).

foxes/models/turbine_models/kTI_model.py

@@ -101,15 +101,31 @@ class kTI(TurbineModel):
             Values: numpy.ndarray with shape (n_states, n_turbines)
 
         """
+
         kti = self.get_data(
-            FV.KTI, FC.STATE_TURBINE, lookup="sf", fdata=fdata, upcast=True
-        )[st_sel]
+            FV.KTI,
+            FC.STATE_TURBINE,
+            lookup="sf",
+            fdata=fdata,
+            upcast=False,
+            selection=st_sel,
+        )
         kb = self.get_data(
-            FV.KB, FC.STATE_TURBINE, lookup="sf", fdata=fdata, upcast=True
-        )[st_sel]
+            FV.KB,
+            FC.STATE_TURBINE,
+            lookup="sf",
+            fdata=fdata,
+            upcast=False,
+            selection=st_sel,
+        )
         ti = self.get_data(
-            self.ti_var, FC.STATE_TURBINE, lookup="sf", fdata=fdata, upcast=True
-        )[st_sel]
+            self.ti_var,
+            FC.STATE_TURBINE,
+            lookup="f",
+            fdata=fdata,
+            upcast=False,
+            selection=st_sel,
+        )
 
         k = fdata.get(
             self.k_var, np.zeros((fdata.n_states, fdata.n_turbines), dtype=FC.DTYPE)

foxes/models/turbine_models/lookup_table.py

@@ -36,6 +36,7 @@ class LookupTable(TurbineModel):
         varmap={},
         pd_file_read_pars={},
         xr_interp_args={},
+        interpn_args={},
         **kwargs,
     ):
         """
@@ -56,6 +57,8 @@ class LookupTable(TurbineModel):
             Parameters for pandas file reading
         xr_interp_args: dict
             Parameters for xarray interpolation method
+        interpn_args: dict
+            Parameters for scipy intern or interp1d
         kwargs: dict, optional
             Additional parameters, added as default
             values if not in data
@@ -70,6 +73,7 @@ class LookupTable(TurbineModel):
 
         self._rpars = pd_file_read_pars
         self._xargs = xr_interp_args
+        self._iargs = interpn_args
         self._data = None
 
         for v, d in kwargs.items():
@@ -184,14 +188,16 @@ class LookupTable(TurbineModel):
         """
         data = {
             v: self.get_data(
-                self.input_vars[0],
+                v,
                 FC.STATE_TURBINE,
                 lookup="fs",
                 fdata=fdata,
-                upcast=True,
-            )[st_sel]
+                upcast=False,
+                selection=st_sel,
+            )
             for v in self.input_vars
         }
+
         dims = {
             v: ("_z") if len(data[v].shape) == 1 else ("_z", "_u")
             for v in self.input_vars
@@ -205,7 +211,27 @@ class LookupTable(TurbineModel):
         }
         del data, dims
 
-        odata = self._data.interp(**indata, **self._xargs)
+        iargs = dict(bounds_error=True)
+        iargs.update(self._iargs)
+        try:
+            odata = self._data.interp(**indata, kwargs=iargs, **self._xargs)
+        except ValueError as e:
+            print("\nBOUNDS ERROR", self.name)
+            print("Variables:", list(indata.keys()))
+            print(
+                "DATA min/max:",
+                [float(np.min(self._data[v].to_numpy())) for v in indata.keys()],
+                [float(np.max(self._data[v].to_numpy())) for v in indata.keys()],
+            )
+            print(
+                "EVAL min/max:",
+                [float(np.min(d.to_numpy())) for d in indata.values()],
+                [float(np.max(d.to_numpy())) for d in indata.values()],
+            )
+            print(
+                "\nMaybe you want to try the options 'bounds_error=False, fill_value=None'? This will extrapolate the data.\n"
+            )
+            raise e
 
         out = {}
         for v in self.output_vars:

foxes/models/turbine_models/rotor_centre_calc.py

@@ -1,6 +1,6 @@
 import numpy as np
 
-from foxes.core import TurbineModel, Data
+from foxes.core import TurbineModel, TData
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -108,7 +108,7 @@ class RotorCentreCalc(TurbineModel):
 
         """
         # prepare target point data:
-        tdata = Data.from_points(
+        tdata = TData.from_points(
             fdata[FV.TXYH],
             data={
                 v: np.zeros_like(fdata[FV.X][:, :, None])
@@ -131,6 +131,7 @@ class RotorCentreCalc(TurbineModel):
         # extract results:
         out = {v: fdata[v] for v in self.calc_vars.keys()}
         for v in out.keys():
-            out[v][st_sel] = res[self.calc_vars[v]][st_sel]
+            w = self.calc_vars[v]
+            out[v][st_sel] = res[w][st_sel][..., 0]
 
         return out

foxes/models/turbine_models/set_farm_vars.py

@@ -44,15 +44,23 @@ class SetFarmVars(TurbineModel):
             The data, shape: (n_states, n_turbines)
 
         """
+        if self.initialized:
+            raise ValueError(
+                f"Model '{self.name}': Cannot add_var after initialization"
+            )
+        if self.running:
+            raise ValueError(f"Model '{self.name}': Cannot add_var while running")
         self.vars.append(var)
-        self._vdata.append(np.asarray(data, dtype=FC.DTYPE))
+        self.__vdata.append(np.asarray(data, dtype=FC.DTYPE))
 
     def reset(self):
         """
         Remove all variables.
         """
+        if self.running:
+            raise ValueError(f"Model '{self.name}': Cannot reset while running")
         self.vars = []
-        self._vdata = []
+        self.__vdata = []
 
     def output_farm_vars(self, algo):
         """
@@ -98,7 +106,7 @@ class SetFarmVars(TurbineModel):
 
         for i, v in enumerate(self.vars):
             data = np.full((algo.n_states, algo.n_turbines), np.nan, dtype=FC.DTYPE)
-            vdata = self._vdata[i]
+            vdata = self.__vdata[i]
 
             # handle special case of call during vectorized optimization:
             if (
@@ -110,14 +118,105 @@ class SetFarmVars(TurbineModel):
                 n_ost = algo.states.states.size()
                 n_trb = algo.n_turbines
                 vdata = np.zeros((n_pop, n_ost, n_trb), dtype=FC.DTYPE)
-                vdata[:] = self._vdata[i][None, :]
+                vdata[:] = self.__vdata[i][None, :]
                 vdata = vdata.reshape(n_pop * n_ost, n_trb)
 
             data[:] = vdata
             idata["data_vars"][self.var(v)] = ((FC.STATE, FC.TURBINE), data)
 
+            # special case of turbine positions:
+            if v in [FV.X, FV.Y]:
+                i = [FV.X, FV.Y].index(v)
+                for ti in range(algo.n_turbines):
+                    t = algo.farm.turbines[ti]
+                    if len(t.xy.shape) == 1:
+                        xy = np.zeros((algo.n_states, 2), dtype=FC.DTYPE)
+                        xy[:] = t.xy[None, :]
+                        t.xy = xy
+                    t.xy[:, i] = np.where(
+                        np.isnan(data[:, ti]), t.xy[:, i], data[:, ti]
+                    )
+
+            # special case of rotor diameter and hub height:
+            if v in [FV.D, FV.H]:
+                for ti in range(algo.n_turbines):
+                    t = algo.farm.turbines[ti]
+                    x = np.zeros(algo.n_states, dtype=FC.DTYPE)
+                    if v == FV.D:
+                        x[:] = t.D
+                        t.D = x
+                    else:
+                        x[:] = t.H
+                        t.H = x
+                    x[:] = np.where(np.isnan(data[:, ti]), x, data[:, ti])
+
         return idata
 
+    def set_running(
+        self,
+        algo,
+        data_stash,
+        sel=None,
+        isel=None,
+        verbosity=0,
+    ):
+        """
+        Sets this model status to running, and moves
+        all large data to stash.
+
+        The stashed data will be returned by the
+        unset_running() function after running calculations.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        data_stash: dict
+            Large data stash, this function adds data here.
+            Key: model name. Value: dict, large model data
+        sel: dict, optional
+            The subset selection dictionary
+        isel: dict, optional
+            The index subset selection dictionary
+        verbosity: int
+            The verbosity level, 0 = silent
+
+        """
+        super().set_running(algo, data_stash, sel, isel, verbosity)
+
+        data_stash[self.name]["vdata"] = self.__vdata
+        del self.__vdata
+
+    def unset_running(
+        self,
+        algo,
+        data_stash,
+        sel=None,
+        isel=None,
+        verbosity=0,
+    ):
+        """
+        Sets this model status to not running, recovering large data
+        from stash
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        data_stash: dict
+            Large data stash, this function adds data here.
+            Key: model name. Value: dict, large model data
+        sel: dict, optional
+            The subset selection dictionary
+        isel: dict, optional
+            The index subset selection dictionary
+        verbosity: int
+            The verbosity level, 0 = silent
+
+        """
+        super().unset_running(algo, data_stash, sel, isel, verbosity)
+        self.__vdata = data_stash[self.name].pop("vdata")
+
     def calculate(self, algo, mdata, fdata, st_sel):
         """
         The main model calculation.
@@ -159,36 +258,6 @@ class SetFarmVars(TurbineModel):
             hsel = ~np.isnan(data)
             tsel = bsel & hsel
 
-            # special case of turbine positions:
-            if v in [FV.X, FV.Y]:
-                i = [FV.X, FV.Y].index(v)
-                for ti in np.where(tsel)[1]:
-                    t = algo.farm.turbines[ti]
-                    if len(t.xy.shape) == 1:
-                        xy = np.zeros((algo.n_states, 2), dtype=FC.DTYPE)
-                        xy[:] = t.xy[None, :]
-                        t.xy = xy
-                    i0 = fdata.states_i0()
-                    hsel = tsel[:, ti]
-                    ssel = i0 + np.where(hsel)[0]
-                    t.xy[ssel, i] = data[hsel, ti]
-
-            # special case of rotor diameter and hub height:
-            if v in [FV.D, FV.H]:
-                for ti in np.where(tsel)[1]:
-                    t = algo.farm.turbines[ti]
-                    x = np.zeros(algo.n_states, dtype=FC.DTYPE)
-                    if v == FV.D:
-                        x[:] = t.D
-                        t.D = x
-                    else:
-                        x[:] = t.H
-                        t.H = x
-                    i0 = fdata.states_i0()
-                    hsel = tsel[:, ti]
-                    ssel = i0 + np.where(hsel)[0]
-                    x[ssel] = data[hsel, ti]
-
             fdata[v][tsel] = data[tsel]
 
         return {v: fdata[v] for v in self.vars}

foxes/models/turbine_types/PCt_file.py

@@ -25,7 +25,7 @@ class PCtFile(TurbineType):
     col_ct: str
         The ct column
     rho: float
-        The air densitiy for which the data is valid
+        The air density for which the data is valid
         or None for no correction
     WSCT: str
         The wind speed variable for ct lookup
@@ -66,7 +66,7 @@ class PCtFile(TurbineType):
         col_ct: str
             The ct column
         rho: float, optional
-            The air densitiy for which the data is valid
+            The air density for which the data is valid
             or None for no correction
         p_ct: float
             The exponent for yaw dependency of ct
@@ -106,6 +106,30 @@ class PCtFile(TurbineType):
         a += f", var_ws_ct={self.WSCT}, var_ws_P={self.WSP}"
         return f"{type(self).__name__}({a})"
 
+    def needs_rews2(self):
+        """
+        Returns flag for requiring REWS2 variable
+
+        Returns
+        -------
+        flag: bool
+            True if REWS2 is required
+
+        """
+        return self.WSCT == FV.REWS2 or self.WSP == FV.REWS2
+
+    def needs_rews3(self):
+        """
+        Returns flag for requiring REWS3 variable
+
+        Returns
+        -------
+        flag: bool
+            True if REWS3 is required
+
+        """
+        return self.WSCT == FV.REWS3 or self.WSP == FV.REWS3
+
     def output_farm_vars(self, algo):
         """
         The variables which are being modified by the model.
@@ -252,7 +276,7 @@ class PCtFile(TurbineType):
             super().modify_cutin(modify_ct, modify_P)
 
     def calculate(self, algo, mdata, fdata, st_sel):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,