foxes 0.6.1__py3-none-any.whl → 0.7__py3-none-any.whl

foxes/models/turbine_models/lookup_table.py

@@ -157,7 +157,7 @@ class LookupTable(TurbineModel):
         return super().load_data(algo, verbosity)
 
     def calculate(self, algo, mdata, fdata, st_sel):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,
@@ -167,13 +167,13 @@ class LookupTable(TurbineModel):
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
+        mdata: foxes.core.MData
             The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
-        st_sel: numpy.ndarray of bool
+        st_sel: slice or numpy.ndarray of bool
             The state-turbine selection,
-            shape: (n_states, n_turbines)
+            for shape: (n_states, n_turbines)
 
         Returns
         -------
@@ -182,15 +182,28 @@ class LookupTable(TurbineModel):
             Values: numpy.ndarray with shape (n_states, n_turbines)
 
         """
+        data = {
+            v: self.get_data(
+                self.input_vars[0],
+                FC.STATE_TURBINE,
+                lookup="fs",
+                fdata=fdata,
+                upcast=True,
+            )[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
+        }
         indata = {
             v: xr.DataArray(
-                self.get_data(
-                    v, FC.STATE_TURBINE, lookup="fs", fdata=fdata, upcast=True
-                )[st_sel],
-                dims=["_z"],
+                data[v],
+                dims=dims[v],
             )
             for v in self.input_vars
         }
+        del data, dims
 
         odata = self._data.interp(**indata, **self._xargs)
 

foxes/models/turbine_models/power_mask.py

@@ -24,12 +24,16 @@ class PowerMask(TurbineModel):
         The wind speed variable for power lookup
     factor_P: float
         The power unit factor, e.g. 1000 for kW
+    P_lim: float
+        Threshold power delta for boosts
+    induction: foxes.core.AxialInductionModel
+        The induction model
 
     :group: models.turbine_models
 
     """
 
-    def __init__(self, var_ws_P=FV.REWS3, factor_P=1.0e3):
+    def __init__(self, var_ws_P=FV.REWS3, factor_P=1.0e3, P_lim=100, induction="Betz"):
         """
         Constructor.
 
@@ -39,12 +43,25 @@ class PowerMask(TurbineModel):
             The wind speed variable for power lookup
         factor_P: float
             The power unit factor, e.g. 1000 for kW
+        P_lim: float
+            Threshold power delta for boosts
+        induction: foxes.core.AxialInductionModel or str
+            The induction model
 
         """
         super().__init__()
 
         self.var_ws_P = var_ws_P
         self.factor_P = factor_P
+        self.P_lim = P_lim
+        self.induction = induction
+
+    def __repr__(self):
+        iname = (
+            self.induction if isinstance(self.induction, str) else self.induction.name
+        )
+        a = f"var_ws_P={self.var_ws_P}, P_lim={self.P_lim}, induction={iname}"
+        return f"{type(self).__name__}({a})"
 
     def output_farm_vars(self, algo):
         """
@@ -63,6 +80,18 @@ class PowerMask(TurbineModel):
         """
         return [FV.P, FV.CT]
 
+    def sub_models(self):
+        """
+        List of all sub-models
+
+        Returns
+        -------
+        smdls: list of foxes.core.Model
+            All sub models
+
+        """
+        return [self.induction]
+
     def initialize(self, algo, verbosity=0):
         """
         Initializes the model.
@@ -75,6 +104,8 @@ class PowerMask(TurbineModel):
             The verbosity level, 0 = silent
 
         """
+        if isinstance(self.induction, str):
+            self.induction = algo.mbook.axial_induction[self.induction]
         super().initialize(algo, verbosity)
 
         self._P_rated = []
@@ -87,35 +118,68 @@ class PowerMask(TurbineModel):
             self._P_rated.append(Pnom)
         self._P_rated = np.array(self._P_rated, dtype=FC.DTYPE)
 
-    @classmethod
-    def update_P_ct(cls, data, max_P, rated_P, factor_P, var_ws=FV.REWS3, P_lim=100):
+    def calculate(self, algo, mdata, fdata, st_sel):
+        """
+        The main model calculation.
+
+        This function is executed on a single chunk of data,
+        all computations should be based on numpy arrays.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        mdata: foxes.core.MData
+            The model data
+        fdata: foxes.core.FData
+            The farm data
+        st_sel: slice or numpy.ndarray of bool
+            The state-turbine selection,
+            for shape: (n_states, n_turbines)
+
+        Returns
+        -------
+        results: dict
+            The resulting data, keys: output variable str.
+            Values: numpy.ndarray with shape (n_states, n_turbines)
+
+        """
+        # prepare:
+        P = fdata[FV.P]
+        max_P = fdata[FV.MAX_P]
+        P_rated = self._P_rated[None, :]
+
         # select power entries for which this is active:
-        P = data[FV.P]
-        sel = ~np.isnan(max_P) & (
-            ((max_P < rated_P) & (P > max_P))
-            | ((max_P > rated_P) & (P > rated_P - P_lim))
+        sel = np.zeros((fdata.n_states, fdata.n_turbines), dtype=bool)
+        sel[st_sel] = True
+        sel = (
+            sel
+            & ~np.isnan(max_P)
+            & (
+                ((max_P < P_rated) & (P > max_P))
+                | ((max_P > P_rated) & (P > P_rated - self.P_lim))
+            )
         )
         if np.any(sel):
             # apply selection:
             max_P = max_P[sel]
-            ws = data[var_ws][sel]
-            rho = data[FV.RHO][sel]
-            r = data[FV.D][sel] / 2
+            ws = fdata[self.var_ws_P][sel]
+            rho = fdata[FV.RHO][sel]
+            r = fdata[FV.D][sel] / 2
             P = P[sel]
-            ct = data[FV.CT][sel]
-            ct[ct > 1.0] = 1.0
+            ct = fdata[FV.CT][sel]
 
             # calculate power efficiency e of turbine
             # e is the ratio of the cp derived from the power curve
             # and the theoretical cp from the turbine induction
-            cp = P / (0.5 * ws**3 * rho * np.pi * r**2) * factor_P
-            a = 0.5 * (1 - np.sqrt(1 - ct))
+            cp = P / (0.5 * ws**3 * rho * np.pi * r**2) * self.factor_P
+            a = self.induction.ct2a(ct)
             cp_a = 4 * a**3 - 8 * a**2 + 4 * a
             e = cp / cp_a
             del cp, a, cp_a, ct, P
 
             # calculating new cp for changed power
-            cp = max_P / (0.5 * ws**3 * rho * np.pi * r**2) * factor_P
+            cp = max_P / (0.5 * ws**3 * rho * np.pi * r**2) * self.factor_P
 
             # find roots:
             N = len(cp)
@@ -130,43 +194,9 @@ class PowerMask(TurbineModel):
             del a0, a1, a2, a3, rts
 
             # set results:
-            P = data[FV.P]
-            ct = data[FV.CT]
+            P = fdata[FV.P]
+            ct = fdata[FV.CT]
             P[sel] = max_P
             ct[sel] = 4 * a * (1 - a)
 
-    def calculate(self, algo, mdata, fdata, st_sel):
-        """ "
-        The main model calculation.
-
-        This function is executed on a single chunk of data,
-        all computations should be based on numpy arrays.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-        mdata: foxes.core.Data
-            The model data
-        fdata: foxes.core.Data
-            The farm data
-        st_sel: numpy.ndarray of bool
-            The state-turbine selection,
-            shape: (n_states, n_turbines)
-
-        Returns
-        -------
-        results: dict
-            The resulting data, keys: output variable str.
-            Values: numpy.ndarray with shape (n_states, n_turbines)
-
-        """
-
-        # prepare:
-        max_P = fdata[FV.MAX_P]
-        rated_P = self._P_rated[None, :]
-
-        # calculate:
-        self.update_P_ct(fdata, max_P, rated_P, self.factor_P, var_ws=self.var_ws_P)
-
         return {FV.P: fdata[FV.P], FV.CT: fdata[FV.CT]}

foxes/models/turbine_models/rotor_centre_calc.py

@@ -82,7 +82,7 @@ class RotorCentreCalc(TurbineModel):
         return list(self.calc_vars.keys())
 
     def calculate(self, algo, mdata, fdata, st_sel):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,
@@ -92,13 +92,13 @@ class RotorCentreCalc(TurbineModel):
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
+        mdata: foxes.core.MData
             The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
-        st_sel: numpy.ndarray of bool
+        st_sel: slice or numpy.ndarray of bool
             The state-turbine selection,
-            shape: (n_states, n_turbines)
+            for shape: (n_states, n_turbines)
 
         Returns
         -------
@@ -107,29 +107,26 @@ class RotorCentreCalc(TurbineModel):
             Values: numpy.ndarray with shape (n_states, n_turbines)
 
         """
-        # prepare point data:
-        pdata = {FC.POINTS: fdata[FV.TXYH]}
-        dims = {FC.POINTS: (FC.STATE, FC.POINT, FC.XYH)}
-        for v in self.calc_vars.values():
-            pdata[v] = np.zeros_like(pdata[FC.POINTS][:, :, 0])
-            dims[v] = (FC.STATE, FC.POINT)
-        pdata = Data(
-            name=f"{self.name}_pdata",
-            data=pdata,
-            dims=dims,
-            loop_dims=[FC.STATE, FC.POINT],
+        # prepare target point data:
+        tdata = Data.from_points(
+            fdata[FV.TXYH],
+            data={
+                v: np.zeros_like(fdata[FV.X][:, :, None])
+                for v in self.calc_vars.values()
+            },
+            dims={v: (FC.STATE, FC.TARGET, FC.TPOINT) for v in self.calc_vars.values()},
+            name=f"{self.name}_tdata",
         )
-        del dims
 
         # run ambient calculation:
-        res = algo.states.calculate(algo, mdata, fdata, pdata)
+        res = algo.states.calculate(algo, mdata, fdata, tdata)
         for v, a in FV.var2amb.items():
             if v in res:
                 res[a] = res[v].copy()
-        pdata.update(res)
+        tdata.update(res)
 
         # run wake calculation:
-        res = self._wcalc.calculate(algo, mdata, fdata, pdata)
+        res = self._wcalc.calculate(algo, mdata, fdata, tdata)
 
         # extract results:
         out = {v: fdata[v] for v in self.calc_vars.keys()}

foxes/models/turbine_models/sector_management.py

@@ -162,7 +162,7 @@ class SectorManagement(TurbineModel):
         return self._tvars
 
     def calculate(self, algo, mdata, fdata, st_sel):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,
@@ -172,13 +172,13 @@ class SectorManagement(TurbineModel):
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
+        mdata: foxes.core.MData
             The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
-        st_sel: numpy.ndarray of bool
+        st_sel: slice or numpy.ndarray of bool
             The state-turbine selection,
-            shape: (n_states, n_turbines)
+            for shape: (n_states, n_turbines)
 
         Returns
         -------
@@ -187,7 +187,6 @@ class SectorManagement(TurbineModel):
             Values: numpy.ndarray with shape (n_states, n_turbines)
 
         """
-
         # prepare:
         n_trbs = len(self._trbs)
         if n_trbs == fdata.n_turbines and np.all(

foxes/models/turbine_models/set_farm_vars.py

@@ -2,6 +2,7 @@ import numpy as np
 
 from foxes.core import TurbineModel
 import foxes.constants as FC
+import foxes.variables as FV
 
 
 class SetFarmVars(TurbineModel):
@@ -118,7 +119,7 @@ class SetFarmVars(TurbineModel):
         return idata
 
     def calculate(self, algo, mdata, fdata, st_sel):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,
@@ -128,13 +129,13 @@ class SetFarmVars(TurbineModel):
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
+        mdata: foxes.core.MData
             The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
-        st_sel: numpy.ndarray of bool
+        st_sel: slice or numpy.ndarray of bool
             The state-turbine selection,
-            shape: (n_states, n_turbines)
+            for shape: (n_states, n_turbines)
 
         Returns
         -------
@@ -143,23 +144,51 @@ class SetFarmVars(TurbineModel):
             Values: numpy.ndarray with shape (n_states, n_turbines)
 
         """
-        n_states = fdata.n_states
-        n_turbines = fdata.n_turbines
-        allt = np.all(st_sel)
+        if self.pre_rotor:
+            order = np.s_[:]
+            ssel = np.s_[:]
+        else:
+            order = fdata[FV.ORDER]
+            ssel = fdata[FV.ORDER_SSEL]
+
+        bsel = np.zeros((fdata.n_states, fdata.n_turbines), dtype=bool)
+        bsel[st_sel] = True
 
         for v in self.vars:
-            data = mdata[self.var(v)]
+            data = mdata[self.var(v)][ssel, order]
             hsel = ~np.isnan(data)
-            hallt = np.all(hsel)
-
-            if allt and hallt:
-                fdata[v][:] = data
-
-            else:
-                if v not in fdata:
-                    fdata[v] = np.full((n_states, n_turbines), np.nan, dtype=FC.DTYPE)
-
-                tsel = st_sel & hsel
-                fdata[v][tsel] = data[tsel]
+            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_models/table_factors.py

@@ -117,7 +117,7 @@ class TableFactors(TurbineModel):
         self._data = self._data.to_numpy(FC.DTYPE)
 
     def calculate(self, algo, mdata, fdata, st_sel):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,
@@ -127,13 +127,13 @@ class TableFactors(TurbineModel):
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
+        mdata: foxes.core.MData
             The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
-        st_sel: numpy.ndarray of bool
+        st_sel: slice or numpy.ndarray of bool
             The state-turbine selection,
-            shape: (n_states, n_turbines)
+            for shape: (n_states, n_turbines)
 
         Returns
         -------

foxes/models/turbine_models/thrust2ct.py

@@ -35,6 +35,10 @@ class Thrust2Ct(TurbineModel):
         self.thrust_var = thrust_var
         self.WSCT = var_ws_ct
 
+    def __repr__(self):
+        a = f"thrust_var={self.thrust_var}, var_ws_ct={self.WSCT}"
+        return f"{type(self).__name__}({a})"
+
     def output_farm_vars(self, algo):
         """
         The variables which are being modified by the model.
@@ -53,7 +57,7 @@ class Thrust2Ct(TurbineModel):
         return [FV.CT]
 
     def calculate(self, algo, mdata, fdata, st_sel):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,
@@ -63,13 +67,13 @@ class Thrust2Ct(TurbineModel):
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
+        mdata: foxes.core.MData
             The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
-        st_sel: numpy.ndarray of bool
+        st_sel: slice or numpy.ndarray of bool
             The state-turbine selection,
-            shape: (n_states, n_turbines)
+            for shape: (n_states, n_turbines)
 
         Returns
         -------

foxes/models/turbine_models/yaw2yawm.py

@@ -1,5 +1,3 @@
-import numpy as np
-
 from foxes.core import TurbineModel
 import foxes.variables as FV
 import foxes.constants as FC
@@ -33,7 +31,7 @@ class YAW2YAWM(TurbineModel):
         return [FV.YAWM]
 
     def calculate(self, algo, mdata, fdata, st_sel):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,
@@ -43,13 +41,13 @@ class YAW2YAWM(TurbineModel):
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
+        mdata: foxes.core.MData
             The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
-        st_sel: numpy.ndarray of bool
+        st_sel: slice or numpy.ndarray of bool
             The state-turbine selection,
-            shape: (n_states, n_turbines)
+            for shape: (n_states, n_turbines)
 
         Returns
         -------
@@ -58,12 +56,8 @@ class YAW2YAWM(TurbineModel):
             Values: numpy.ndarray with shape (n_states, n_turbines)
 
         """
-        yaw = self.get_data(
-            FV.YAW, FC.STATE_TURBINE, lookup="f", fdata=fdata, upcast=True
-        )[st_sel]
-        wd = self.get_data(
-            FV.WD, FC.STATE_TURBINE, lookup="f", fdata=fdata, upcast=True
-        )[st_sel]
+        yaw = fdata[FV.YAW][st_sel]
+        wd = fdata[FV.WD][st_sel]
 
         yawm = fdata[FV.YAWM]
         yawm[st_sel] = delta_wd(wd, yaw)

foxes/models/turbine_models/yawm2yaw.py

@@ -32,7 +32,7 @@ class YAWM2YAW(TurbineModel):
         return [FV.YAW]
 
     def calculate(self, algo, mdata, fdata, st_sel):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,
@@ -42,13 +42,13 @@ class YAWM2YAW(TurbineModel):
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
+        mdata: foxes.core.MData
             The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
-        st_sel: numpy.ndarray of bool
+        st_sel: slice or numpy.ndarray of bool
             The state-turbine selection,
-            shape: (n_states, n_turbines)
+            for shape: (n_states, n_turbines)
 
         Returns
         -------
@@ -57,12 +57,8 @@ class YAWM2YAW(TurbineModel):
             Values: numpy.ndarray with shape (n_states, n_turbines)
 
         """
-        yawm = self.get_data(
-            FV.YAWM, FC.STATE_TURBINE, lookup="f", fdata=fdata, upcast=True
-        )[st_sel]
-        wd = self.get_data(
-            FV.WD, FC.STATE_TURBINE, lookup="f", fdata=fdata, upcast=True
-        )[st_sel]
+        yawm = fdata[FV.YAWM][st_sel]
+        wd = fdata[FV.WD][st_sel]
 
         yaw = fdata[FV.YAW]
         yaw[st_sel] = np.mod(wd + yawm, 360.0)