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

foxes/models/model_book.py

@@ -85,12 +85,13 @@ class ModelBook:
             Path to power/ct curve file, for creation
             of default turbine type model
         """
-        self.point_models = FDict(name="point_models")
+        self.point_models = FDict(_name="point_models")
         self.point_models["tke2ti"] = fm.point_models.TKE2TI()
         self.point_models["ustar2ti"] = fm.point_models.Ustar2TI()
 
-        self.rotor_models = FDict(name="rotor_models")
+        self.rotor_models = FDict(_name="rotor_models")
         self.rotor_models["centre"] = fm.rotor_models.CentreRotor()
+        self.rotor_models["direct_mdata"] = fm.rotor_models.DirectMDataInfusion()
 
         def _n2n(n2):
             n2 = float(n2)
@@ -132,7 +133,7 @@ class ModelBook:
             hints={"n": "(Number of vertical levels)"},
         )
 
-        self.turbine_types = FDict(name="turbine_types")
+        self.turbine_types = FDict(_name="turbine_types")
         self.turbine_types["null_type"] = fm.turbine_types.NullType()
         self.turbine_types["NREL5MW"] = fm.turbine_types.PCtFile(
             "NREL-5MW-D126-H90.csv", rho=1.225
@@ -150,7 +151,7 @@ class ModelBook:
             self.turbine_types["Pct"] = fm.turbine_types.PCtFile(Pct_file)
 
         self.turbine_models = FDict(
-            name="turbine_models",
+            _name="turbine_models",
             kTI=fm.turbine_models.kTI(),
             kTI_amb=fm.turbine_models.kTI(ti_var=FV.AMB_TI),
             thrust2ct=fm.turbine_models.Thrust2Ct(),
@@ -203,7 +204,7 @@ class ModelBook:
         )
 
         self.farm_models = FDict(
-            name="farm_models",
+            _name="farm_models",
             **{
                 f"farm_{mname}": fm.farm_models.Turbine2FarmModel(m)
                 for mname, m in self.turbine_models.items()
@@ -211,12 +212,12 @@ class ModelBook:
         )
 
         self.farm_controllers = FDict(
-            name="farm_controllers",
+            _name="farm_controllers",
             basic_ctrl=fm.farm_controllers.BasicFarmController(),
         )
 
         self.partial_wakes = FDict(
-            name="partial_wakes",
+            _name="partial_wakes",
             rotor_points=fm.partial_wakes.RotorPoints(),
             top_hat=fm.partial_wakes.PartialTopHat(),
             centre=fm.partial_wakes.PartialCentre(),
@@ -236,7 +237,7 @@ class ModelBook:
         )
 
         self.wake_deflections = FDict(
-            name="wake_deflections",
+            _name="wake_deflections",
             no_deflection=fm.wake_deflections.NoDeflection(),
             Bastankhah2016=fm.wake_deflections.Bastankhah2016Deflection(),
             Jimenez=fm.wake_deflections.JimenezDeflection(rotate=True),
@@ -303,7 +304,7 @@ class ModelBook:
         )
 
         self.wake_frames = FDict(
-            name="wake_frames",
+            _name="wake_frames",
             rotor_wd=fm.wake_frames.RotorWD(),
             rotor_wd_farmo=fm.wake_frames.FarmOrder(),
         )
@@ -363,7 +364,7 @@ class ModelBook:
         )
 
         self.wake_superpositions = FDict(
-            name="wake_superpositions",
+            _name="wake_superpositions",
             ws_linear=fm.wake_superpositions.WSLinear(scale_amb=False),
             ws_linear_lim=fm.wake_superpositions.WSLinear(
                 scale_amb=False, lim_low=1e-4
@@ -407,11 +408,11 @@ class ModelBook:
             vector_amb=fm.wake_superpositions.WindVectorLinear(scale_amb=True),
         )
 
-        self.axial_induction = FDict(name="induction_models")
+        self.axial_induction = FDict(_name="induction_models")
         self.axial_induction["Betz"] = fm.axial_induction.BetzAxialInduction()
         self.axial_induction["Madsen"] = fm.axial_induction.MadsenAxialInduction()
 
-        self.wake_models = FDict(name="wake_models")
+        self.wake_models = FDict(_name="wake_models")
 
         self.wake_models.add_k_factory(
             fm.wake_models.wind.JensenWake,
@@ -616,7 +617,7 @@ class ModelBook:
             },
         )
 
-        self.ground_models = FDict(name="ground_models")
+        self.ground_models = FDict(_name="ground_models")
         self.ground_models["no_ground"] = fm.ground_models.NoGround()
         self.ground_models["ground_mirror"] = fm.ground_models.GroundMirror()
         self.ground_models.add_factory(
@@ -629,7 +630,7 @@ class ModelBook:
         )
 
         self.sources = FDict(
-            name="sources",
+            _name="sources",
             point_models=self.point_models,
             rotor_models=self.rotor_models,
             turbine_types=self.turbine_types,
@@ -645,7 +646,7 @@ class ModelBook:
             ground_models=self.ground_models,
         )
         self.base_classes = FDict(
-            name="base_classes",
+            _name="base_classes",
             point_models=PointDataModel,
             rotor_models=RotorModel,
             turbine_types=TurbineType,

foxes/models/rotor_models/__init__.py

@@ -5,3 +5,4 @@ Rotor models.
 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/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,20 +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

@@ -300,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]
 
@@ -330,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

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

@@ -11,3 +11,4 @@ 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