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

foxes/models/partial_wakes/segregated.py

@@ -87,7 +87,6 @@ class PartialSegregated(PartialWakesModel):
         mdata,
         fdata,
         tdata,
-        amb_res,
         rpoint_weights,
         wake_deltas,
         wmodel,
@@ -109,11 +108,6 @@ class PartialSegregated(PartialWakesModel):
             The farm data
         tdata: foxes.core.Data
             The target point data
-        amb_res: dict
-            The ambient results at the target points
-            of all rotors. Key: variable name, value
-            np.ndarray of shape:
-            (n_states, n_turbines, n_rotor_points)
         rpoint_weights: numpy.ndarray
             The rotor point weights, shape: (n_rotor_points,)
         wake_deltas: dict
@@ -138,25 +132,8 @@ class PartialSegregated(PartialWakesModel):
         gweights = tdata[FC.TWEIGHTS]
 
         wdel = {v: d[:, downwind_index, None].copy() for v, d in wake_deltas.items()}
-
-        if n_rotor_points == tdata.n_tpoints:
-            ares = {
-                v: d[:, downwind_index, None] if d.shape[1] > 1 else d[:, 0, None]
-                for v, d in amb_res.items()
-            }
-        else:
-            ares = {}
-            for v, d in amb_res.items():
-                ares[v] = np.zeros(
-                    (n_states, 1, tdata.n_tpoints), dtype=config.dtype_double
-                )
-                ares[v][:] = np.einsum(
-                    "sp,p->s",
-                    d[:, downwind_index] if d.shape[1] > 1 else d[:, 0],
-                    rpoint_weights,
-                )[:, None, None]
-
-        wmodel.finalize_wake_deltas(algo, mdata, fdata, ares, wdel)
+        htdata = tdata.get_slice([FC.TURBINE], np.s_[downwind_index])
+        wmodel.finalize_wake_deltas(algo, mdata, fdata, htdata, wdel)
 
         for v in wdel.keys():
             hdel = np.zeros((n_states, n_rotor_points), dtype=config.dtype_double)

foxes/models/partial_wakes/top_hat.py

@@ -126,8 +126,6 @@ class PartialTopHat(PartialCentre):
             The wake deltas. Key: variable name,
             value: numpy.ndarray with shape
             (n_states, n_targets, n_tpoints, ...)
-        wmodel: foxes.core.WakeModel
-            The wake model
 
         """
         self.check_wmodel(wmodel, error=True)
@@ -182,6 +180,33 @@ class PartialTopHat(PartialCentre):
 
                 weights = calc_area(D / 2, wr, R) / (np.pi * (D / 2) ** 2)
 
+                # run superposition models:
+                if wmodel.affects_ws and wmodel.has_uv:
+                    assert wmodel.has_vector_wind_superp, (
+                        f"{self.name}: Expecting vector wind superposition in wake model '{wmodel.name}', got '{wmodel.wind_superposition}'"
+                    )
+                    if FV.UV in clw:
+                        duv = clw.pop(FV.UV)
+                    else:
+                        clwe = {v: d[:, None] for v, d in clw.items()}
+                        wmodel.vec_superp.wdeltas_ws2uv(
+                            algo, fdata, tdata, downwind_index, clwe, st_sel
+                        )
+                        duv = np.einsum("sd,s->sd", clwe.pop(FV.UV)[:, 0], weights)
+                        del clwe, clw[FV.WS]
+                        if FV.WD in clw:
+                            del clw[FV.WD]
+                    wake_deltas[FV.UV] = wmodel.vec_superp.add_wake_vector(
+                        algo,
+                        mdata,
+                        fdata,
+                        tdata,
+                        downwind_index,
+                        st_sel,
+                        wake_deltas[FV.UV],
+                        duv[:, None],
+                    )
+
                 for v, d in clw.items():
                     try:
                         superp = wmodel.superp[v]

foxes/models/point_models/__init__.py

@@ -2,7 +2,7 @@
 Point models.
 """
 
-from .wake_deltas import WakeDeltas
-from .set_uniform_data import SetUniformData
-from .tke2ti import TKE2TI
-from .ustar2ti import Ustar2TI
+from .wake_deltas import WakeDeltas as WakeDeltas
+from .set_uniform_data import SetUniformData as SetUniformData
+from .tke2ti import TKE2TI as TKE2TI
+from .ustar2ti import Ustar2TI as Ustar2TI

foxes/models/rotor_models/__init__.py

@@ -2,6 +2,7 @@
 Rotor models.
 """
 
-from .centre import CentreRotor
-from .grid import GridRotor
-from .levels import LevelRotor
+from .centre import CentreRotor as CentreRotor
+from .grid import GridRotor as GridRotor
+from .levels import LevelRotor as LevelRotor
+from .direct_infusion import DirectMDataInfusion as DirectMDataInfusion

foxes/models/rotor_models/centre.py

@@ -199,4 +199,4 @@ class CentreRotor(RotorModel):
                 self._set_res(fdata, v, res, downwind_index)
                 del res
             if copy_to_ambient and v in FV.var2amb:
-                fdata[FV.var2amb[v]] = fdata[v].copy()
+                fdata.add(FV.var2amb[v], fdata[v].copy(), fdata.dims[v])

foxes/models/rotor_models/direct_infusion.py

@@ -0,0 +1,241 @@
+import numpy as np
+
+from foxes.core import TData
+import foxes.variables as FV
+import foxes.constants as FC
+
+from .centre import CentreRotor
+
+
+class DirectMDataInfusion(CentreRotor):
+    """
+    Direct data infusion of data stored under mdata.
+
+    Attributes
+    ----------
+    svars2mdvars: dict
+        A mapping of state variables to mdata variables.
+    mdata_vars: list of str
+        The mdata variables to be used for infusion. By default,
+        all mdata variables are searched.
+    turbine_coord: str, optional
+        The mdata coordinate that represents turbine names. By default,
+        the second coordinate is used as a candidate if the mdata variable
+        has three dimensions.
+
+    :group: models.turbine_types
+
+    """
+
+    def __init__(
+        self,
+        svars2mdvars=None,
+        mdata_vars=None,
+        turbine_coord=None,
+        **kwargs,
+    ):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        svars2mdvars: dict, optional
+            A mapping of state variables to mdata variables.
+        mdata_vars: list of str, optional
+            The mdata variables to be used for infusion. By default,
+            all mdata variables are searched.
+        turbine_coord: str, optional
+            The mdata coordinate that represents turbine names. By default,
+            the second coordinate is used as a candidate if the mdata variable
+            has three dimensions.
+        kwargs: dict, optional
+            Additional parameters for RotorModel class
+
+        """
+        super().__init__(**kwargs)
+        self.svars2mdvars = svars2mdvars
+        self.mdata_vars = mdata_vars
+        self.turbine_coord = turbine_coord
+
+    def output_farm_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
+
+        """
+        if self.svars2mdvars is None:
+            self.svars2mdvars = {v: v for v in algo.states.output_point_vars(algo)}
+
+        if self.calc_vars is None:
+            vrs = list(self.svars2mdvars.keys())
+            assert FV.WEIGHT not in vrs, (
+                f"Rotor '{self.name}': svars2mdvars keys {vrs}  contain '{FV.WEIGHT}', please remove"
+            )
+
+            if FV.WS in vrs:
+                self.calc_vars = [FV.REWS] + [v for v in vrs if v != FV.WS]
+            else:
+                self.calc_vars = vrs
+
+            if algo.farm_controller.needs_rews2() and FV.REWS2 not in self.calc_vars:
+                self.calc_vars.append(FV.REWS2)
+            if algo.farm_controller.needs_rews3() and FV.REWS3 not in self.calc_vars:
+                self.calc_vars.append(FV.REWS3)
+
+            self.calc_vars = sorted(self.calc_vars)
+
+        if FV.WEIGHT not in self.calc_vars:
+            self.calc_vars.append(FV.WEIGHT)
+            if FV.WEIGHT not in self.svars2mdvars:
+                self.svars2mdvars[FV.WEIGHT] = FV.WEIGHT
+
+        return self.calc_vars
+
+    def calculate(
+        self,
+        algo,
+        mdata,
+        fdata,
+        rpoints=None,
+        rpoint_weights=None,
+        store=False,
+        downwind_index=None,
+    ):
+        """
+        Calculate ambient rotor effective results.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        mdata: foxes.core.MData
+            The model data
+        fdata: foxes.core.FData
+            The farm data
+        rpoints: numpy.ndarray, optional
+            The rotor points, or None for automatic for
+            this rotor. Shape: (n_states, n_turbines, n_rpoints, 3)
+        rpoint_weights: numpy.ndarray, optional
+            The rotor point weights, or None for automatic
+            for this rotor. Shape: (n_rpoints,)
+        store: bool, optional
+            Flag for storing ambient rotor point results
+        downwind_index: int, optional
+            Only compute for index in the downwind order
+
+        Returns
+        -------
+        results: dict
+            results dict. Keys: Variable name str. Values:
+            numpy.ndarray with results, shape: (n_states, n_turbines)
+
+        """
+        self.ensure_output_vars(algo, fdata)
+
+        if rpoints is None:
+            rpoints = mdata.get(
+                FC.ROTOR_POINTS, self.get_rotor_points(algo, mdata, fdata)
+            )
+        if downwind_index is not None:
+            rpoints = rpoints[:, downwind_index, None]
+        if rpoint_weights is None:
+            rpoint_weights = mdata.get_item(FC.TWEIGHTS, self.rotor_point_weights())
+
+        tdata = TData.from_tpoints(rpoints, rpoint_weights)
+        sres = {}
+        mdvs = self.mdata_vars if self.mdata_vars is not None else list(mdata.keys())
+        for v, w in self.svars2mdvars.items():
+            tdata.add(
+                v,
+                data=np.full_like(rpoints[..., 0], np.nan),
+                dims=(FC.STATE, FC.TARGET, FC.TPOINT),
+            )
+
+            # check fixed variables
+            if hasattr(algo.states, "fixed_vars") and v in algo.states.fixed_vars:
+                tdata[v][:] = algo.states.fixed_vars[v]
+                sres[v] = tdata[v]
+                continue
+
+            # search in mdata variables
+            tcoord = self.turbine_coord
+            for mdv in mdvs:
+                assert mdv in mdata and mdv in mdata.dims, (
+                    f"Rotor '{self.name}': mdata variable '{mdv}' not found in mdata {list(mdata.keys())} with dims {list(mdata.dims.keys())}"
+                )
+                mdat = mdata[mdv]
+                dims = mdata.dims[mdv]
+
+                # skip coordinates in the search:
+                if dims == (mdv,):
+                    continue
+
+                # find variable index in last data array dimension
+                vc = dims[-1]
+                assert vc in mdata and vc in mdata.dims and mdata.dims[vc] == (vc,), (
+                    f"Rotor '{self.name}': mdata coordinate '{vc}' not in mdata or wrong dimensions {mdata.dims}, expected '{(vc,)}'"
+                )
+                vrs = list(mdata[vc])
+                if w in vrs:
+                    i = vrs.index(w)
+                    mdat = mdat[..., i]
+                    dims = dims[:-1]
+
+                    # pure state dependent variable
+                    if dims == (FC.STATE,):
+                        tdata[v][:] = mdat[:, None, None]
+
+                    # state and turbine dependent variable
+                    elif len(dims) == 2 and dims[0] == FC.STATE:
+                        assert mdat.shape[1] == mdata.n_turbines, (
+                            f"Rotor '{self.name}': mdata variable '{mdv}' has dimensions {dims} and unexpected shape {mdat.shape} for variable '{w}', expected ({mdata.n_states}, {mdata.n_turbines}) for this wind farm with {mdata.n_turbines} turbines"
+                        )
+                        if tcoord is None:
+                            tcoord = dims[1]
+                        assert dims[1] == tcoord, (
+                            f"Rotor '{self.name}': mdata variable '{mdv}' has unexpected dimensions {dims} for variable '{w}', expected ({FC.STATE}, {tcoord})"
+                        )
+
+                        tdata[v][:] = mdat[:, :, None]
+
+                    else:
+                        if tcoord is None:
+                            tcoord = "<turbine>"
+                        raise ValueError(
+                            f"Rotor '{self.name}': mdata variable '{mdv}' has unexpected dimensions {dims} for variable '{w}' at position {i}, expected ({FC.STATE},) or ({FC.STATE}, {tcoord})"
+                        )
+
+                    sres[v] = tdata[v]
+                    break
+
+            if v not in sres:
+                raise ValueError(
+                    f"Rotor '{self.name}': mdata variable '{w}' not found in any of the mdata variables {mdvs}"
+                )
+
+        if store:
+            algo.add_to_chunk_store(FC.ROTOR_POINTS, rpoints, mdata=mdata)
+            algo.add_to_chunk_store(FC.ROTOR_WEIGHTS, rpoint_weights, mdata=mdata)
+            algo.add_to_chunk_store(FC.AMB_ROTOR_RES, sres, mdata=mdata)
+            algo.add_to_chunk_store(FC.WEIGHT_RES, tdata[FV.WEIGHT], mdata=mdata)
+
+        self.eval_rpoint_results(
+            algo,
+            mdata,
+            fdata,
+            tdata,
+            rpoint_weights,
+            downwind_index,
+            copy_to_ambient=True,
+        )
+
+        return {v: fdata[v] for v in self.output_farm_vars(algo)}

foxes/models/turbine_models/__init__.py

@@ -2,14 +2,14 @@
 Turbine models.
 """
 
-from .kTI_model import kTI
-from .set_farm_vars import SetFarmVars
-from .thrust2ct import Thrust2Ct
-from .power_mask import PowerMask
-from .sector_management import SectorManagement
-from .table_factors import TableFactors
-from .yaw2yawm import YAW2YAWM
-from .yawm2yaw import YAWM2YAW
-from .calculator import Calculator
-from .rotor_centre_calc import RotorCentreCalc
-from .lookup_table import LookupTable
+from .kTI_model import kTI as kTI
+from .set_farm_vars import SetFarmVars as SetFarmVars
+from .thrust2ct import Thrust2Ct as Thrust2Ct
+from .power_mask import PowerMask as PowerMask
+from .sector_management import SectorManagement as SectorManagement
+from .table_factors import TableFactors as TableFactors
+from .yaw2yawm import YAW2YAWM as YAW2YAWM
+from .yawm2yaw import YAWM2YAW as YAWM2YAW
+from .calculator import Calculator as Calculator
+from .rotor_centre_calc import RotorCentreCalc as RotorCentreCalc
+from .lookup_table import LookupTable as LookupTable

foxes/models/turbine_models/calculator.py

@@ -12,11 +12,17 @@ class Calculator(TurbineModel):
     out_vars: list of str
         The output variables
     func: Function
-        The function: f(in0, in1, ..., stsel) -> (out0, out1, ...)
+        The function: f(in0, in1, ..., algo, mdata, fdata, st_sel) -> (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).
 
+        Beware that the turbine ordering in fdata is in downwind order,
+        hence external data X of shape (n_states, n_turbines) in farm order
+        needs to be reordered by X[ssel, order] with
+        ssel = fdata[FV.ORDER_SSEL], order = fdata[FV.ORDER]
+        before using it in combination with fdata variables.
+
     :group: models.turbine_models
 
     """
@@ -32,10 +38,16 @@ class Calculator(TurbineModel):
         out_vars: list of str
             The output variables
         func: Function
-            The function: f(in0, in1, ..., stsel) -> (out0, out1, ...)
+            The function: f(in0, in1, ..., algo, mdata, fdata, st_sel) -> (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).
+
+            Beware that the turbine ordering in fdata is in downwind order,
+            hence external data X of shape (n_states, n_turbines) in farm order
+            needs to be reordered by X[ssel, order] with
+            ssel = fdata[FV.ORDER_SSEL], order = fdata[FV.ORDER]
+            before using it in combination with fdata variables.
         kwargs: dict, optional
             Additional arguments for TurbineModel
 
@@ -92,7 +104,8 @@ class Calculator(TurbineModel):
             Values: numpy.ndarray with shape (n_states, n_turbines)
 
         """
+        self.ensure_output_vars(algo, fdata)
         ins = [fdata[v] if v in fdata else mdata[v] for v in self.in_vars]
-        outs = self.func(*ins, st_sel=st_sel)
+        outs = self.func(*ins, algo=algo, mdata=mdata, fdata=fdata, st_sel=st_sel)
 
         return {v: outs[vi] for vi, v in enumerate(self.out_vars)}

foxes/models/turbine_models/kTI_model.py

@@ -102,6 +102,7 @@ class kTI(TurbineModel):
             Values: numpy.ndarray with shape (n_states, n_turbines)
 
         """
+        self.ensure_output_vars(algo, fdata)
 
         kti = self.get_data(
             FV.KTI,

foxes/models/turbine_models/lookup_table.py

@@ -189,6 +189,8 @@ class LookupTable(TurbineModel):
             Values: numpy.ndarray with shape (n_states, n_turbines)
 
         """
+        self.ensure_output_vars(algo, fdata)
+
         data = {
             v: self.get_data(
                 v,

foxes/models/turbine_models/power_mask.py

@@ -151,6 +151,7 @@ class PowerMask(TurbineModel):
 
         """
         # prepare:
+        self.ensure_output_vars(algo, fdata)
         P = fdata[FV.P]
         max_P = fdata[FV.MAX_P]
         P_rated = self._P_rated[None, :]

foxes/models/turbine_models/rotor_centre_calc.py

@@ -107,6 +107,8 @@ class RotorCentreCalc(TurbineModel):
             Values: numpy.ndarray with shape (n_states, n_turbines)
 
         """
+        self.ensure_output_vars(algo, fdata)
+
         # prepare target point data:
         tdata = TData.from_points(
             fdata[FV.TXYH],

foxes/models/turbine_models/sector_management.py

@@ -190,6 +190,7 @@ class SectorManagement(TurbineModel):
 
         """
         # prepare:
+        self.ensure_output_vars(algo, fdata)
         n_trbs = len(self._trbs)
         if n_trbs == fdata.n_turbines and np.all(
             self._trbs == np.arange(fdata.n_turbines)

foxes/models/turbine_models/set_farm_vars.py

@@ -268,21 +268,15 @@ class SetFarmVars(TurbineModel):
             Values: numpy.ndarray with shape (n_states, n_turbines)
 
         """
+        self.ensure_output_vars(algo, fdata)
+
         i0 = mdata.states_i0(counter=True)
         if not self.once or i0 not in self.__once_done:
-
-            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)][ssel, order]
+                data = mdata[self.var(v)]
                 hsel = ~np.isnan(data)
                 tsel = bsel & hsel
 

foxes/models/turbine_models/table_factors.py

@@ -143,6 +143,8 @@ class TableFactors(TurbineModel):
             Values: numpy.ndarray with shape (n_states, n_turbines)
 
         """
+        self.ensure_output_vars(algo, fdata)
+
         n_sel = np.sum(st_sel)
         qts = np.zeros((n_sel, 2), dtype=config.dtype_double)
         qts[:, 0] = fdata[self.row_var][st_sel]

foxes/models/turbine_models/thrust2ct.py

@@ -82,6 +82,7 @@ class Thrust2Ct(TurbineModel):
             Values: numpy.ndarray with shape (n_states, n_turbines)
 
         """
+        self.ensure_output_vars(algo, fdata)
         ct = fdata[FV.CT]
 
         T = fdata[self.thrust_var][st_sel]

foxes/models/turbine_models/yaw2yawm.py

@@ -55,6 +55,8 @@ class YAW2YAWM(TurbineModel):
             Values: numpy.ndarray with shape (n_states, n_turbines)
 
         """
+        self.ensure_output_vars(algo, fdata)
+
         yaw = fdata[FV.YAW][st_sel]
         wd = fdata[FV.WD][st_sel]
 

foxes/models/turbine_models/yawm2yaw.py

@@ -56,6 +56,8 @@ class YAWM2YAW(TurbineModel):
             Values: numpy.ndarray with shape (n_states, n_turbines)
 
         """
+        self.ensure_output_vars(algo, fdata)
+
         yawm = fdata[FV.YAWM][st_sel]
         wd = fdata[FV.WD][st_sel]
 

foxes/models/turbine_types/PCt_file.py

@@ -1,6 +1,5 @@
 import numpy as np
 import pandas as pd
-from pathlib import Path
 
 from foxes.core import TurbineType
 from foxes.utils import PandasFileHelper
@@ -232,7 +231,6 @@ class PCtFile(TurbineType):
 
         """
         if modify_ct or modify_P:
-
             ws = self.data_ws
             ct = self.data_ct
             P = self.data_P
@@ -302,6 +300,7 @@ class PCtFile(TurbineType):
             Values: numpy.ndarray with shape (n_states, n_turbines)
 
         """
+        self.ensure_output_vars(algo, fdata)
         rews2 = fdata[self.WSCT][st_sel]
         rews3 = fdata[self.WSP][st_sel]
 
@@ -332,10 +331,7 @@ class PCtFile(TurbineType):
                 rews3 *= (cosm**self.p_P) ** (1.0 / 3.0)
             del yawm, cosm
 
-        out = {
-            FV.P: fdata[FV.P],
-            FV.CT: fdata[FV.CT],
-        }
+        out = {FV.P: fdata[FV.P], FV.CT: fdata[FV.CT]}
 
         out[FV.P][st_sel] = np.interp(
             rews3, self.data_ws, self.data_P, left=0.0, right=0.0

foxes/models/turbine_types/PCt_from_two.py

@@ -263,7 +263,6 @@ class PCtFromTwo(TurbineType):
 
         """
         if modify_ct:
-
             ws = self._data_ws_ct
             ct = self._data_ct
 
@@ -291,7 +290,6 @@ class PCtFromTwo(TurbineType):
                 self._data_ct = np.concatenate([new_ct[:-1], ct], axis=0)
 
         if modify_P:
-
             ws = self._data_ws_P
             P = self._data_P
 
@@ -347,6 +345,7 @@ class PCtFromTwo(TurbineType):
             Values: numpy.ndarray with shape (n_states, n_turbines)
 
         """
+        self.ensure_output_vars(algo, fdata)
         rews2 = fdata[self.WSCT][st_sel]
         rews3 = fdata[self.WSP][st_sel]
 

foxes/models/turbine_types/__init__.py

@@ -2,12 +2,13 @@
 Turbine type models.
 """
 
-from .PCt_file import PCtFile
-from .PCt_from_two import PCtFromTwo
-from .CpCt_file import CpCtFile
-from .CpCt_from_two import CpCtFromTwo
-from .null_type import NullType
-from .wsrho2PCt_from_two import WsRho2PCtFromTwo
-from .wsti2PCt_from_two import WsTI2PCtFromTwo
-from .lookup import FromLookupTable
-from .TBL_file import TBLFile
+from .PCt_file import PCtFile as PCtFile
+from .PCt_from_two import PCtFromTwo as PCtFromTwo
+from .CpCt_file import CpCtFile as CpCtFile
+from .CpCt_from_two import CpCtFromTwo as CpCtFromTwo
+from .null_type import NullType as NullType
+from .wsrho2PCt_from_two import WsRho2PCtFromTwo as WsRho2PCtFromTwo
+from .wsti2PCt_from_two import WsTI2PCtFromTwo as WsTI2PCtFromTwo
+from .lookup import FromLookupTable as FromLookupTable
+from .TBL_file import TBLFile as TBLFile
+from .calculator_type import CalculatorType as CalculatorType