foxes 0.6.2__py3-none-any.whl → 0.7.0.2__py3-none-any.whl

foxes/VERSION

@@ -1 +1 @@
-0.6.2
+0.7.0.2

foxes/algorithms/downwind/downwind.py

@@ -18,14 +18,16 @@ class Downwind(Algorithm):
     ----------
     states: foxes.core.States
         The ambient states
-    wake_models: list of foxes.core.WakeModel
-        The wake models, applied to all turbines
+    wake_models: dict
+        The wake models. Key: wake model name,
+        value: foxes.core.WakeModel
     rotor_model: foxes.core.RotorModel
         The rotor model, for all turbines
     wake_frame: foxes.core.WakeFrame
         The wake frame
-    partial_wakes_model: foxes.core.PartialWakesModel
-        The partial wakes model
+    partial_wakes: dict
+        The partial wakes mapping. Key: wake model name,
+        value: foxes.core.PartialWakesModel
     farm_controller: foxes.core.FarmController
         The farm controller
     n_states: int
@@ -35,36 +37,38 @@ class Downwind(Algorithm):
 
     """
 
-    @classmethod
-    def get_model(cls, name):
-        """
-        Get the algorithm specific model
-
-        Parameters
-        ----------
-        name: str
-            The model name
-
-        Returns
-        -------
-        model: foxes.core.model
-            The model
-
-        """
-        return getattr(mdls, name)
+    DEFAULT_FARM_OUTPUTS = [
+        FV.X,
+        FV.Y,
+        FV.H,
+        FV.D,
+        FV.AMB_WD,
+        FV.AMB_REWS,
+        FV.AMB_TI,
+        FV.AMB_RHO,
+        FV.AMB_P,
+        FV.WD,
+        FV.REWS,
+        FV.YAW,
+        FV.TI,
+        FV.CT,
+        FV.P,
+        FV.ORDER,
+        FV.WEIGHT,
+    ]
 
     def __init__(
         self,
-        mbook,
         farm,
         states,
         wake_models,
         rotor_model="centre",
         wake_frame="rotor_wd",
-        partial_wakes_model="auto",
+        partial_wakes=None,
         farm_controller="basic_ctrl",
-        chunks={FC.STATE: 1000, FC.POINT: 10000},
+        chunks={FC.STATE: 1000, FC.POINT: 4000},
         wake_mirrors={},
+        mbook=None,
         dbook=None,
         verbosity=1,
     ):
@@ -73,8 +77,6 @@ class Downwind(Algorithm):
 
         Parameters
         ----------
-        mbook: foxes.ModelBook
-            The model book
         farm: foxes.WindFarm
             The wind farm
         states: foxes.core.States
@@ -88,9 +90,9 @@ class Downwind(Algorithm):
         wake_frame: str
             The wake frame. Will be looked up in the
             model book
-        partial_wakes_model: str
-            The partial wakes model. Will be
-            looked up in the model book
+        partial_wakes: dict, list or str, optional
+            The partial wakes mapping. Key: wake model name,
+            value: partial wake model name
         farm_controller: str
             The farm controller. Will be
             looked up in the model book
@@ -100,12 +102,17 @@ class Downwind(Algorithm):
         wake_mirrors: dict
             Switch on wake mirrors for wake models.
             Key: wake model name, value: list of heights
+        mbook: foxes.ModelBook, optional
+            The model book
         dbook: foxes.DataBook, optional
             The data book, or None for default
         verbosity: int
             The verbosity level, 0 means silent
 
         """
+        if mbook is None:
+            mbook = fm.ModelBook()
+
         super().__init__(mbook, farm, chunks, verbosity, dbook)
 
         self.states = states
@@ -115,13 +122,10 @@ class Downwind(Algorithm):
         self.rotor_model = self.mbook.rotor_models[rotor_model]
         self.rotor_model.name = rotor_model
 
-        self.partial_wakes_model = self.mbook.partial_wakes[partial_wakes_model]
-        self.partial_wakes_model.name = partial_wakes_model
-
         self.wake_frame = self.mbook.wake_frames[wake_frame]
         self.wake_frame.name = wake_frame
 
-        self.wake_models = []
+        self.wake_models = {}
         for w in wake_models:
             m = self.mbook.wake_models[w]
             m.name = w
@@ -135,14 +139,63 @@ class Downwind(Algorithm):
                             f"Wake model '{w}' is mirrored with heights {m.heights}, cannot apply WakeMirror with heights {hts}"
                         )
                 else:
-                    self.wake_models.append(fm.wake_models.WakeMirror(m, heights=hts))
+                    self.wake_models[w] = fm.wake_models.WakeMirror(m, heights=hts)
 
             else:
-                self.wake_models.append(m)
+                self.wake_models[w] = m
+
+        self.partial_wakes = {}
+        if partial_wakes is None:
+            partial_wakes = {}
+        if isinstance(partial_wakes, list) and len(partial_wakes) == 1:
+            partial_wakes = partial_wakes[0]
+        if isinstance(partial_wakes, str):
+            for w in wake_models:
+                try:
+                    pw = partial_wakes
+                except TypeError:
+                    pw = mbook.default_partial_wakes(self.wake_models[w])
+                self.partial_wakes[w] = self.mbook.partial_wakes[pw]
+                self.partial_wakes[w].name = pw
+        elif isinstance(partial_wakes, list):
+            for i, w in enumerate(wake_models):
+                if i >= len(partial_wakes):
+                    raise IndexError(
+                        f"Not enough partial wakes in list {partial_wakes}, expecting {len(wake_models)}"
+                    )
+                pw = partial_wakes[i]
+                self.partial_wakes[w] = self.mbook.partial_wakes[pw]
+                self.partial_wakes[w].name = pw
+        else:
+            for w in wake_models:
+                if w in partial_wakes:
+                    pw = partial_wakes[w]
+                else:
+                    pw = mbook.default_partial_wakes(self.wake_models[w])
+                self.partial_wakes[w] = self.mbook.partial_wakes[pw]
+                self.partial_wakes[w].name = pw
 
         self.farm_controller = self.mbook.farm_controllers[farm_controller]
         self.farm_controller.name = farm_controller
 
+    @classmethod
+    def get_model(cls, name):
+        """
+        Get the algorithm specific model
+
+        Parameters
+        ----------
+        name: str
+            The model name
+
+        Returns
+        -------
+        model: foxes.core.model
+            The model
+
+        """
+        return getattr(mdls, name)
+
     def _print_deco(self, func_name, n_points=None):
         """
         Helper function for printing model names
@@ -160,13 +213,16 @@ class Downwind(Algorithm):
             print(f"  states   : {self.states}")
             print(f"  rotor    : {self.rotor_model}")
             print(f"  controller: {self.farm_controller}")
-            print(f"  partialwks: {self.partial_wakes_model}")
             print(f"  wake frame: {self.wake_frame}")
             print(deco)
             print(f"  wakes:")
-            for i, w in enumerate(self.wake_models):
+            for i, w in enumerate(self.wake_models.values()):
                 print(f"    {i}) {w}")
             print(deco)
+            print(f"  partial wakes:")
+            for i, (w, p) in enumerate(self.partial_wakes.items()):
+                print(f"    {i}) {w}: {p}")
+            print(deco)
             print(f"  turbine models:")
             for i, m in enumerate(self.farm_controller.pre_rotor_models.models):
                 print(f"    {i}) {m} [pre-rotor]")
@@ -226,8 +282,9 @@ class Downwind(Algorithm):
             self.rotor_model,
             self.farm_controller,
             self.wake_frame,
-            self.partial_wakes_model,
-        ] + self.wake_models
+        ]
+        mdls += list(self.wake_models.values())
+        mdls += list(self.partial_wakes.values())
 
         return mdls
 
@@ -245,6 +302,7 @@ class Downwind(Algorithm):
 
     def _collect_farm_models(
         self,
+        outputs,
         calc_parameters,
         ambient,
     ):
@@ -253,73 +311,68 @@ class Downwind(Algorithm):
         """
         # prepare:
         calc_pars = []
-        t2f = fm.farm_models.Turbine2FarmModel
         mlist = FarmDataModelList(models=[])
         mlist.name = f"{self.name}_calc"
 
-        # 0) set XHYD:
-        m = fm.turbine_models.SetXYHD()
-        mlist.models.append(t2f(m))
-        calc_pars.append(calc_parameters.get(mlist.models[-1].name, {}))
-
-        # 1) run pre-rotor turbine models via farm controller:
+        # 0) run pre-rotor turbine models via farm controller:
         mlist.models.append(self.farm_controller)
         calc_pars.append(calc_parameters.get(mlist.models[-1].name, {}))
         calc_pars[-1]["pre_rotor"] = True
 
-        # 2) calculate yaw from wind direction at rotor centre:
-        mlist.models.append(fm.rotor_models.CentreRotor(calc_vars=[FV.WD, FV.YAW]))
-        mlist.models[-1].name = "calc_yaw_" + mlist.models[-1].name
+        # 1) set initial data:
+        mlist.models.append(self.get_model("InitFarmData")())
         calc_pars.append(calc_parameters.get(mlist.models[-1].name, {}))
 
-        # 3) calculate ambient rotor results:
+        # 2) calculate ambient rotor results:
         mlist.models.append(self.rotor_model)
         calc_pars.append(calc_parameters.get(mlist.models[-1].name, {}))
         calc_pars[-1].update(
             {"store_rpoints": True, "store_rweights": True, "store_amb_res": True}
         )
 
-        # 4) calculate turbine order:
-        mlist.models.append(self.get_model("CalcOrder")())
-        calc_pars.append(calc_parameters.get(mlist.models[-1].name, {}))
-
-        # 5) run post-rotor turbine models via farm controller:
+        # 3) run post-rotor turbine models via farm controller:
         mlist.models.append(self.farm_controller)
         calc_pars.append(calc_parameters.get(mlist.models[-1].name, {}))
         calc_pars[-1]["pre_rotor"] = False
 
-        # 6) copy results to ambient, requires self.farm_vars:
+        # 4) copy results to ambient, requires self.farm_vars:
         self.farm_vars = mlist.output_farm_vars(self)
         mlist.models.append(self.get_model("SetAmbFarmResults")())
         calc_pars.append(calc_parameters.get(mlist.models[-1].name, {}))
 
-        # 7) calculate wake effects:
+        # 5) calculate wake effects:
         if not ambient:
             mlist.models.append(self.get_model("FarmWakesCalculation")())
             calc_pars.append(calc_parameters.get(mlist.models[-1].name, {}))
 
+        # 6) reorder back to state-turbine dimensions:
+        if outputs != False:
+            mlist.models.append(self.get_model("ReorderFarmOutput")(outputs))
+            calc_pars.append(calc_parameters.get(mlist.models[-1].name, {}))
+
         return mlist, calc_pars
 
     def _calc_farm_vars(self, mlist):
         """Helper function that gathers the farm variables"""
         self.farm_vars = sorted(list(set([FV.WEIGHT] + mlist.output_farm_vars(self))))
 
-    def _run_farm_calc(self, mlist, *data, **kwargs):
+    def _run_farm_calc(self, mlist, *data, outputs=None, **kwargs):
         """Helper function for running the main farm calculation"""
         self.print(
             f"\nCalculating {self.n_states} states for {self.n_turbines} turbines"
         )
-        farm_results = mlist.run_calculation(
-            self, *data, out_vars=self.farm_vars, **kwargs
-        )
+        out_vars = self.farm_vars if outputs is None else outputs
+        farm_results = mlist.run_calculation(self, *data, out_vars=out_vars, **kwargs)
         farm_results[FC.TNAME] = ((FC.TURBINE,), self.farm.turbine_names)
-        if FV.ORDER in farm_results:
-            farm_results[FV.ORDER] = farm_results[FV.ORDER].astype(FC.ITYPE)
+        for v in [FV.ORDER, FV.ORDER_SSEL, FV.ORDER_INV]:
+            if v in farm_results:
+                farm_results[v] = farm_results[v].astype(FC.ITYPE)
 
         return farm_results
 
     def calc_farm(
         self,
+        outputs=None,
         calc_parameters={},
         persist=True,
         finalize=True,
@@ -335,6 +388,8 @@ class Downwind(Algorithm):
         calc_parameters: dict
             Parameters for model calculation.
             Key: model name str, value: parameter dict
+        outputs: list of str, optional
+            The output variables, or None for defaults
         persist: bool
             Switch for forcing dask to load all model data
             into memory
@@ -362,7 +417,9 @@ class Downwind(Algorithm):
         self._print_deco("calc_farm")
 
         # collect models:
-        mlist, calc_pars = self._collect_farm_models(calc_parameters, ambient)
+        if outputs == "default":
+            outputs = self.DEFAULT_FARM_OUTPUTS
+        mlist, calc_pars = self._collect_farm_models(outputs, calc_parameters, ambient)
 
         # initialize models:
         if not mlist.initialized:
@@ -370,12 +427,19 @@ class Downwind(Algorithm):
             self._calc_farm_vars(mlist)
         self._print_model_oder(mlist, calc_pars)
 
+        # update outputs:
+        if outputs is None:
+            outputs = self.farm_vars
+        else:
+            outputs = sorted(list(set(outputs).intersection(self.farm_vars)))
+
         # get input model data:
         models_data = self.get_models_data()
         if persist:
             models_data = models_data.persist()
         self.print("\nInput data:\n\n", models_data, "\n")
-        self.print(f"\nOutput farm variables:", ", ".join(self.farm_vars))
+        self.print(f"\nFarm variables:", ", ".join(self.farm_vars))
+        self.print(f"\nOutput variables:", ", ".join(outputs))
         self.print(f"\nChunks: {self.chunks}\n")
 
         # run main calculation:
@@ -383,6 +447,7 @@ class Downwind(Algorithm):
             mlist,
             models_data,
             parameters=calc_pars,
+            outputs=outputs,
             **kwargs,
         )
         del models_data
@@ -559,6 +624,7 @@ class Downwind(Algorithm):
         self.print(
             f"Calculating {len(ovars)} variables at {points.shape[1]} points in {self.n_states} states"
         )
+
         point_results = mlist.run_calculation(
             self,
             models_data,

foxes/algorithms/downwind/models/__init__.py

@@ -2,4 +2,5 @@ from .set_amb_farm_results import SetAmbFarmResults
 from .set_amb_point_results import SetAmbPointResults
 from .farm_wakes_calc import FarmWakesCalculation
 from .point_wakes_calc import PointWakesCalculation
-from .calc_order import CalcOrder
+from .init_farm_data import InitFarmData
+from .reorder_farm_output import ReorderFarmOutput

foxes/algorithms/downwind/models/farm_wakes_calc.py

@@ -1,7 +1,7 @@
 import numpy as np
+from copy import deepcopy
 
-import foxes.variables as FV
-from foxes.core import FarmDataModel
+from foxes.core import FarmDataModel, TData
 
 
 class FarmWakesCalculation(FarmDataModel):
@@ -12,12 +12,6 @@ class FarmWakesCalculation(FarmDataModel):
 
     """
 
-    def __init__(self):
-        """
-        Constructor.
-        """
-        super().__init__()
-
     def output_farm_vars(self, algo):
         """
         The variables which are being modified by the model.
@@ -38,33 +32,6 @@ class FarmWakesCalculation(FarmDataModel):
         ) + algo.farm_controller.output_farm_vars(algo)
         return list(dict.fromkeys(ovars))
 
-    def sub_models(self):
-        """
-        List of all sub-models
-
-        Returns
-        -------
-        smdls: list of foxes.core.Model
-            Names of all sub models
-
-        """
-        return [self.pwakes]
-
-    def initialize(self, algo, verbosity=0):
-        """
-        Initializes the model.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-        verbosity: int
-            The verbosity level, 0 = silent
-
-        """
-        self.pwakes = algo.partial_wakes_model
-        super().initialize(algo, verbosity)
-
     def calculate(self, algo, mdata, fdata):
         """ "
         The main model calculation.
@@ -88,33 +55,98 @@ class FarmWakesCalculation(FarmDataModel):
             Values: numpy.ndarray with shape (n_states, n_turbines)
 
         """
-        torder = fdata[FV.ORDER]
-        n_order = torder.shape[1]
-        n_states = mdata.n_states
-
-        def _evaluate(algo, mdata, fdata, pdata, wdeltas, o):
-            self.pwakes.evaluate_results(
-                algo, mdata, fdata, pdata, wdeltas, states_turbine=o
+        # collect ambient rotor results and weights:
+        rotor = algo.rotor_model
+        weights = rotor.from_data_or_store(rotor.RWEIGHTS, algo, mdata)
+        amb_res = rotor.from_data_or_store(rotor.AMBRES, algo, mdata)
+
+        # generate all wake evaluation points
+        # (n_states, n_order, n_rpoints)
+        pwake2tdata = {}
+        for wname, wmodel in algo.wake_models.items():
+            pwake = algo.partial_wakes[wname]
+            if pwake.name not in pwake2tdata:
+                tpoints, tweights = pwake.get_wake_points(algo, mdata, fdata)
+                pwake2tdata[pwake.name] = TData.from_tpoints(tpoints, tweights)
+
+        def _get_wdata(tdatap, wdeltas, s):
+            """Helper function for wake data extraction"""
+            tdata = tdatap.get_slice(s, keep=True)
+            wdelta = {v: d[s] for v, d in wdeltas.items()}
+            return tdata, wdelta
+
+        def _evaluate(tdata, amb_res, weights, wake_res, wdeltas, oi, wmodel, pwake):
+            """Helper function for data evaluation at turbines"""
+            wres = pwake.finalize_wakes(
+                algo, mdata, fdata, tdata, amb_res, weights, wdeltas, wmodel, oi
             )
 
-            trbs = np.zeros((n_states, algo.n_turbines), dtype=bool)
-            np.put_along_axis(trbs, o[:, None], True, axis=1)
+            hres = {v: d[:, oi, None] for v, d in wake_res.items()}
+            for v, d in wres.items():
+                if v in wake_res:
+                    hres[v] += d[:, None]
+
+            rotor.eval_rpoint_results(
+                algo, mdata, fdata, hres, weights, downwind_index=oi
+            )
 
             res = algo.farm_controller.calculate(
-                algo, mdata, fdata, pre_rotor=False, st_sel=trbs
+                algo, mdata, fdata, pre_rotor=False, downwind_index=oi
             )
             fdata.update(res)
 
-        wdeltas, pdata = self.pwakes.new_wake_deltas(algo, mdata, fdata)
-        for oi in range(n_order):
-            o = torder[:, oi]
-
-            if oi > 0:
-                _evaluate(algo, mdata, fdata, pdata, wdeltas, o)
-
-            if oi < n_order - 1:
-                self.pwakes.contribute_to_wake_deltas(
-                    algo, mdata, fdata, pdata, o, wdeltas
+        wake_res = deepcopy(amb_res)
+        n_turbines = mdata.n_turbines
+        run_up = None
+        run_down = None
+        for wname, wmodel in algo.wake_models.items():
+            pwake = algo.partial_wakes[wname]
+            tdatap = pwake2tdata[pwake.name]
+            wdeltas = pwake.new_wake_deltas(algo, mdata, fdata, tdatap, wmodel)
+
+            # downwind:
+            if wmodel.affects_downwind:
+                run_up = wname
+                for oi in range(n_turbines):
+                    if oi > 0:
+                        _evaluate(
+                            tdatap,
+                            amb_res,
+                            weights,
+                            wake_res,
+                            wdeltas,
+                            oi,
+                            wmodel,
+                            pwake,
+                        )
+
+                    if oi < n_turbines - 1:
+                        tdata, wdelta = _get_wdata(tdatap, wdeltas, np.s_[:, oi + 1 :])
+                        pwake.contribute(algo, mdata, fdata, tdata, oi, wdelta, wmodel)
+
+            # upwind:
+            else:
+                run_down = wname
+                for oi in range(n_turbines - 1, -1, -1):
+                    if oi < n_turbines - 1:
+                        _evaluate(
+                            tdatap,
+                            amb_res,
+                            weights,
+                            wake_res,
+                            wdeltas,
+                            oi,
+                            wmodel,
+                            pwake,
+                        )
+
+                    if oi > 0:
+                        tdata, wdelta = _get_wdata(tdatap, wdeltas, np.s_[:, :oi])
+                        pwake.contribute(algo, mdata, fdata, tdata, oi, wdelta, wmodel)
+
+            if run_up is not None and run_down is not None:
+                raise KeyError(
+                    f"Wake model '{run_up}' is an upwind model, wake model '{run_down}' is a downwind model: Require iterative algorithm"
                 )
 
         return {v: fdata[v] for v in self.output_farm_vars(algo)}