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

examples/yawed_wake/run.py

@@ -82,7 +82,9 @@ if __name__ == "__main__":
 
     # set turbines in yaw
     yawm = np.array([[args.yawm, args.yawm2]])
-    mbook.turbine_models["set_yawm"] = foxes.models.turbine_models.SetFarmVars()
+    mbook.turbine_models["set_yawm"] = foxes.models.turbine_models.SetFarmVars(
+        pre_rotor=True
+    )
     mbook.turbine_models["set_yawm"].add_var(FV.YAWM, yawm)
 
     # create states
@@ -112,93 +114,95 @@ if __name__ == "__main__":
         wake_deflection=args.deflection,
         partial_wakes=args.pwakes,
         mbook=mbook,
-        engine=args.engine,
+    )
+
+    with foxes.Engine.new(
+        engine_type=args.engine,
         n_procs=args.n_cpus,
         chunk_size_states=args.chunksize_states,
         chunk_size_points=args.chunksize_points,
-    )
+    ):
+        # calculate farm results
+        farm_results = algo.calc_farm()
+        print("\nResults data:\n", farm_results)
 
-    # calculate farm results
-    farm_results = algo.calc_farm()
-    print("\nResults data:\n", farm_results)
+        if not args.nofig:
+            # xy horizontal flow plot
+            print("\nHorizontal flow figure output:")
+            o = foxes.output.FlowPlots2D(algo, farm_results)
+            g = o.gen_states_fig_xy(
+                args.var, resolution=10, xmin=-500, xmax=3000, rotor_color="red"
+            )
+            fig = next(g)
+            plt.show()
+            plt.close(fig)
 
-    if not args.nofig:
-        # xy horizontal flow plot
-        print("\nHorizontal flow figure output:")
-        o = foxes.output.FlowPlots2D(algo, farm_results)
-        g = o.gen_states_fig_xy(
-            args.var, resolution=10, xmin=-500, xmax=3000, rotor_color="red"
-        )
-        fig = next(g)
-        plt.show()
-        plt.close(fig)
+            # yz flow plot
+            print("\nVertical flow figure output:")
+            o = foxes.output.FlowPlots2D(algo, farm_results)
+            g = o.gen_states_fig_yz(
+                args.var,
+                resolution=5,
+                x=750,
+                ymin=-200,
+                ymax=200,
+                zmin=0,
+                zmax=250,
+                rotor_color="red",
+                verbosity=0,
+            )
+            fig = next(g)
+            plt.show()
+            plt.close(fig)
 
-        # yz flow plot
-        print("\nVertical flow figure output:")
-        o = foxes.output.FlowPlots2D(algo, farm_results)
-        g = o.gen_states_fig_yz(
-            args.var,
-            resolution=5,
-            x=750,
-            ymin=-200,
-            ymax=200,
-            zmin=0,
-            zmax=250,
-            rotor_color="red",
-            verbosity=0,
-        )
-        fig = next(g)
-        plt.show()
-        plt.close(fig)
+        # add capacity and efficiency to farm results
+        o = foxes.output.FarmResultsEval(farm_results)
+        o.add_capacity(algo)
+        o.add_capacity(algo, ambient=True)
+        o.add_efficiency()
 
-    # add capacity and efficiency to farm results
-    o = foxes.output.FarmResultsEval(farm_results)
-    o.add_capacity(algo)
-    o.add_capacity(algo, ambient=True)
-    o.add_efficiency()
-
-    # state-turbine results
-    farm_df = farm_results.to_dataframe()
-    print("\nFarm results data:\n")
-    print(
-        farm_df[
-            [
-                FV.X,
-                FV.AMB_REWS,
-                FV.REWS,
-                FV.AMB_TI,
-                FV.TI,
-                FV.AMB_P,
-                FV.P,
-                FV.WD,
-                FV.YAW,
-                FV.YAWM,
+        # state-turbine results
+        farm_df = farm_results.to_dataframe()
+        print("\nFarm results data:\n")
+        print(
+            farm_df[
+                [
+                    FV.X,
+                    FV.AMB_REWS,
+                    FV.REWS,
+                    FV.AMB_TI,
+                    FV.TI,
+                    FV.AMB_P,
+                    FV.P,
+                    FV.WD,
+                    FV.YAW,
+                    FV.YAWM,
+                ]
             ]
-        ]
-    )
-    print()
+        )
+        print()
 
-    # results by turbine
-    turbine_results = o.reduce_states(
-        {
-            FV.AMB_P: "weights",
-            FV.P: "weights",
-            FV.AMB_CAP: "weights",
-            FV.CAP: "weights",
-        }
-    )
-    turbine_results[FV.AMB_YLD] = o.calc_turbine_yield(
-        algo=algo, annual=True, ambient=True
-    )
-    turbine_results[FV.YLD] = o.calc_turbine_yield(algo=algo, annual=True)
-    turbine_results[FV.EFF] = turbine_results[FV.P] / turbine_results[FV.AMB_P]
-    print("\nResults by turbine:\n")
-    print(turbine_results)
+        # results by turbine
+        turbine_results = o.reduce_states(
+            {
+                FV.AMB_P: "weights",
+                FV.P: "weights",
+                FV.AMB_CAP: "weights",
+                FV.CAP: "weights",
+            }
+        )
+        turbine_results[FV.AMB_YLD] = o.calc_turbine_yield(
+            algo=algo, annual=True, ambient=True
+        )
+        turbine_results[FV.YLD] = o.calc_turbine_yield(algo=algo, annual=True)
+        turbine_results[FV.EFF] = turbine_results[FV.P] / turbine_results[FV.AMB_P]
+        print("\nResults by turbine:\n")
+        print(turbine_results)
 
-    # power results
-    P0 = o.calc_mean_farm_power(ambient=True)
-    P = o.calc_mean_farm_power()
-    print(f"\nFarm power        : {P / 1000:.1f} MW")
-    print(f"Farm ambient power: {P0 / 1000:.1f} MW")
-    print(f"Farm efficiency   : {o.calc_farm_efficiency() * 100:.2f} %")
-    print(f"Annual farm yield : {turbine_results[FV.YLD].sum():.2f} GWh.")
+        # power results
+        P0 = o.calc_mean_farm_power(ambient=True)
+        P = o.calc_mean_farm_power()
+        print(f"\nFarm power        : {P / 1000:.1f} MW")
+        print(f"Farm ambient power: {P0 / 1000:.1f} MW")
+        print(f"Farm efficiency   : {o.calc_farm_efficiency() * 100:.2f} %")
+        print(f"Annual farm yield : {turbine_results[FV.YLD].sum():.2f} GWh.")

foxes/algorithms/downwind/downwind.py

@@ -477,7 +477,7 @@ class Downwind(Algorithm):
         # 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": True})
+        calc_pars[-1]["store"] = True
 
         # 3) run post-rotor turbine models via farm controller:
         mlist.models.append(self.farm_controller)
@@ -508,7 +508,7 @@ class Downwind(Algorithm):
     def _launch_parallel_farm_calc(
         self,
         mlist,
-        *data,
+        model_data,
         outputs=None,
         normalize=False,
         **kwargs,
@@ -520,8 +520,8 @@ class Downwind(Algorithm):
         ----------
         mlist: foxes.models.FarmDataModelList
             The model list
-        data: tuple of xarray.Dataset
-            The (mdata, fdata) inputs
+        model_data: xarray.Dataset
+            The initial model data
         outputs: list of str, optional
             The output variables, or None for defaults
         normalize: bool
@@ -538,7 +538,7 @@ class Downwind(Algorithm):
         """
         out_vars = self.farm_vars if outputs is None else outputs
         farm_results = get_engine().run_calculation(
-            self, mlist, *data, out_vars=out_vars, **kwargs
+            self, mlist, model_data, out_vars=out_vars, **kwargs
         )
 
         if normalize:

foxes/algorithms/downwind/models/init_farm_data.py

@@ -74,17 +74,17 @@ class InitFarmData(FarmDataModel):
         n_states = fdata.n_states
         n_turbines = algo.n_turbines
 
-        # define FV.TXYH as vector [X, Y, H]:
-        fdata[FV.TXYH] = np.full(
-            (n_states, n_turbines, 3), np.nan, dtype=config.dtype_double
+        # add and set X, Y, H, D:
+        fdata.add(
+            FV.TXYH,
+            np.zeros((n_states, n_turbines, 3), dtype=config.dtype_double),
+            (FC.STATE, FC.TURBINE, FC.XYH),
+        )
+        fdata.add(
+            FV.D,
+            np.zeros((n_states, n_turbines), dtype=config.dtype_double),
+            (FC.STATE, FC.TURBINE),
         )
-        fdata.dims[FV.TXYH] = (FC.STATE, FC.TURBINE, FC.XYH)
-        for i, v in enumerate([FV.X, FV.Y, FV.H]):
-            fdata[v] = fdata[FV.TXYH][..., i]
-            fdata.dims[v] = (FC.STATE, FC.TURBINE)
-
-        # set X, Y, H, D:
-        fdata[FV.D] = np.zeros((n_states, n_turbines), dtype=config.dtype_double)
         for ti, t in enumerate(algo.farm.turbines):
             if len(t.xy.shape) == 1:
                 fdata[FV.TXYH][:, ti, :2] = t.xy[None, :]
@@ -103,34 +103,64 @@ class InitFarmData(FarmDataModel):
                 D = algo.farm_controller.turbine_types[ti].D
             fdata[FV.D][:, ti] = D
 
-        # calc WD and YAW at rotor centres:
+        # calc WD at rotor centres:
         svrs = algo.states.output_point_vars(algo)
         tdata = TData.from_points(points=fdata[FV.TXYH], variables=svrs)
         sres = algo.states.calculate(algo, mdata, fdata, tdata)
-        fdata[FV.WD] = sres[FV.WD][:, :, 0]
+        fdata.add(
+            FV.WD,
+            sres[FV.WD][:, :, 0],
+            (FC.STATE, FC.TURBINE),
+        )
+        fdata.add(
+            FV.AMB_WD,
+            fdata[FV.WD].copy(),
+            (FC.STATE, FC.TURBINE),
+        )
         del tdata, sres, svrs
 
-        # calculate and inverse:
+        # calculate downwind order:
         order = algo.wake_frame.calc_order(algo, mdata, fdata)
         ssel = np.zeros_like(order)
         ssel[:] = np.arange(n_states)[:, None]
-        fdata[FV.ORDER] = order
-        fdata[FV.ORDER_SSEL] = ssel
-        fdata[FV.ORDER_INV] = np.zeros_like(order)
-        fdata[FV.ORDER_INV][ssel, order] = np.arange(n_turbines)[None, :]
 
         # apply downwind order to all data:
-        fdata[FV.TXYH] = fdata[FV.TXYH][ssel, order]
+        for data in [fdata, mdata]:
+            for k in data.keys():
+                if (
+                    k not in [FV.X, FV.Y, FV.H]
+                    and tuple(data.dims[k][:2]) == (FC.STATE, FC.TURBINE)
+                    and np.any(data[k] != data[k][0, 0, None, None])
+                ):
+                    data[k][:] = data[k][ssel, order]
+
+        # add derived data:
         for i, v in enumerate([FV.X, FV.Y, FV.H]):
-            fdata[v] = fdata[FV.TXYH][..., i]
-        for v in [FV.D, FV.WD]:
-            if np.any(fdata[v] != fdata[v][0, 0, None, None]):
-                fdata[v] = fdata[v][ssel, order]
-        fdata[FV.YAW] = fdata[FV.WD].copy()
-        for k in mdata.keys():
-            if tuple(mdata.dims[k][:2]) == (FC.STATE, FC.TURBINE) and np.any(
-                mdata[k] != mdata[k][0, 0, None, None]
-            ):
-                mdata[k] = mdata[k][ssel, order]
+            fdata.add(
+                v,
+                fdata[FV.TXYH][:, :, i],
+                (FC.STATE, FC.TURBINE),
+            )
+        fdata.add(
+            FV.YAW,
+            fdata[FV.WD].copy(),
+            (FC.STATE, FC.TURBINE),
+        )
+        fdata.add(
+            FV.ORDER,
+            order,
+            (FC.STATE, FC.TURBINE),
+        )
+        fdata.add(
+            FV.ORDER_SSEL,
+            ssel,
+            (FC.STATE, FC.TURBINE),
+        )
+        fdata.add(
+            FV.ORDER_INV,
+            np.zeros_like(order),
+            (FC.STATE, FC.TURBINE),
+        )
+        fdata[FV.ORDER_INV][ssel, order] = np.arange(n_turbines)[None, :]
 
         return {v: fdata[v] for v in self.output_farm_vars(algo)}

foxes/algorithms/downwind/models/set_amb_farm_results.py

@@ -65,5 +65,5 @@ class SetAmbFarmResults(FarmDataModel):
 
         """
         for v in self.vars:
-            fdata[FV.var2amb[v]] = fdata[v].copy()
+            fdata.add(FV.var2amb[v], fdata[v].copy(), fdata.dims[v])
         return {v: fdata[v] for v in self.output_farm_vars(algo)}

foxes/core/algorithm.py

@@ -63,8 +63,8 @@ class Algorithm(Model):
         self.__farm = farm
         self.__mbook = mbook
         self.__dbook = StaticData() if dbook is None else dbook
-        self.__idata_mem = Dict(name="idata_mem")
-        self.__chunk_store = Dict(name="chunk_store")
+        self.__idata_mem = Dict(_name="idata_mem")
+        self.__chunk_store = Dict(_name="chunk_store")
 
         if len(engine_pars):
             if "engine_type" in engine_pars:
@@ -558,7 +558,7 @@ class Algorithm(Model):
                     "n_states": n_states,
                     "n_targets": n_targets,
                 },
-                name=f"chunk_store_{i0}_{t0}",
+                _name=f"chunk_store_{i0}_{t0}",
             )
 
         self.chunk_store[key][name] = data.copy() if copy else data
@@ -638,11 +638,11 @@ class Algorithm(Model):
         """
         chunk_store = self.chunk_store
         if new_chunk_store is None:
-            self.__chunk_store = Dict(name="chunk_store")
+            self.__chunk_store = Dict(_name="chunk_store")
         elif isinstance(new_chunk_store, Dict):
             self.__chunk_store = new_chunk_store
         else:
-            self.__chunk_store = Dict(name="chunk_store")
+            self.__chunk_store = Dict(_name="chunk_store")
             self.__chunk_store.update(new_chunk_store)
         return chunk_store
 
@@ -912,6 +912,7 @@ class Algorithm(Model):
             isel=isel,
             **kwargs,
         )
+        self.reset_chunk_store(chunk_store)
 
         # reset to not running:
         self.unset_running(

foxes/core/data.py

@@ -53,7 +53,7 @@ class Data(Dict):
             The data container name
 
         """
-        super().__init__(name=name)
+        super().__init__(_name=name)
 
         self.update(data)
         self.dims = dims
@@ -109,12 +109,12 @@ class Data(Dict):
             or the corresponding index
 
         """
-        if FC.STATE not in self:
-            return None
-        elif counter:
+        if counter:
             if self.__states_i0 is None:
                 raise KeyError(f"Data '{self.name}': states_i0 requested but not set")
             return self.__states_i0
+        elif FC.STATE not in self:
+            return None
         else:
             return self[FC.STATE][0]
 
@@ -394,6 +394,74 @@ class FData(Data):
                         f"FData '{self.name}': Missing '{x}' in sizes, got {sorted(list(self.sizes.keys()))}"
                     )
 
+    @classmethod
+    def from_sizes(cls, n_states, n_turbines, *args, callback=None, **kwargs):
+        """
+        Create Data object from model data
+
+        Parameters
+        ----------
+        n_states: int
+            The number of states
+        n_turbines: int
+            The number of turbines
+        args: tuple, optional
+            Additional parameters for the constructor
+        callback: Function, optional
+            Function f(data, dims) that manipulates
+            the data and dims dicts before construction
+        kwargs: dict, optional
+            Additional parameters for the constructor
+
+        Returns
+        -------
+        data: Data
+            The data object
+
+        """
+        data = cls(*args, **kwargs)
+        data.sizes[FC.STATE] = n_states
+        data.sizes[FC.TURBINE] = n_turbines
+
+        if callback is not None:
+            callback(data, data.dims)
+
+        return data
+
+    @classmethod
+    def from_mdata(cls, mdata, *args, callback=None, **kwargs):
+        """
+        Create Data object from model data
+
+        Parameters
+        ----------
+        mdata: MData
+            The model data
+        args: tuple, optional
+            Additional parameters for the constructor
+        callback: Function, optional
+            Function f(data, dims) that manipulates
+            the data and dims dicts before construction
+        kwargs: dict, optional
+            Additional parameters for the constructor
+
+        Returns
+        -------
+        data: Data
+            The data object
+
+        """
+        data = cls(*args, **kwargs)
+        for v in [FC.STATE, FC.TURBINE]:
+            data[v] = mdata[v]
+            data.dims[v] = mdata.dims[v]
+            data.sizes[v] = mdata.sizes[v]
+
+        if callback is not None:
+            callback(data, data.dims)
+
+        return data
+
     @classmethod
     def from_dataset(cls, ds, *args, mdata=None, callback=None, **kwargs):
         """
@@ -427,6 +495,9 @@ class FData(Data):
                 if FC.STATE not in data:
                     data[FC.STATE] = mdata[FC.STATE]
                     dims[FC.STATE] = mdata.dims[FC.STATE]
+                if FC.TURBINE not in data:
+                    data[FC.TURBINE] = mdata[FC.TURBINE]
+                    dims[FC.TURBINE] = mdata.dims[FC.TURBINE]
                 if callback is not None:
                     callback(data, dims)
 

foxes/core/data_calc_model.py

@@ -45,8 +45,10 @@ class DataCalcModel(Model):
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        data: tuple of foxes.core.Data
-            The input data
+        data: tuple of foxes.core.Data, optional
+            The input data, typically either (mdata, fdata) in
+            the case of farm calculations, or (mdata, fdata, tdata)
+            for point data calculations
         parameters: dict, optional
             The calculation parameters
 

foxes/core/engine.py

@@ -6,7 +6,6 @@ from xarray import Dataset
 
 from .data import MData, FData, TData
 from foxes.utils import new_instance
-from foxes.config import config
 import foxes.constants as FC
 
 __global_engine_data__ = dict(
@@ -350,8 +349,9 @@ class Engine(ABC):
 
         Returns
         -------
-        data: list of foxes.core.Data
-            Either [mdata, fdata] or [mdata, fdata, tdata]
+        data: tuple of foxes.core.Data
+            The input data for the chunk calculation,
+            either (mdata, fdata) or (mdata, fdata, tdata)
 
         """
         # prepare:
@@ -370,51 +370,37 @@ class Engine(ABC):
         )
 
         # create fdata:
-        if point_data is None:
-
-            def cb(data, dims):
-                n_states = i1_states - i0_states
-                for o in set(out_vars).difference(data.keys()):
-                    data[o] = np.full(
-                        (n_states, algo.n_turbines), np.nan, dtype=config.dtype_double
-                    )
-                    dims[o] = (FC.STATE, FC.TURBINE)
-
+        if farm_data is not None:
+            fdata = FData.from_dataset(
+                farm_data,
+                mdata=mdata,
+                s_states=s_states,
+                callback=None,
+                states_i0=i0_states,
+                copy=True,
+            )
         else:
-            cb = None
-        fdata = FData.from_dataset(
-            farm_data,
-            mdata=mdata,
-            s_states=s_states,
-            callback=cb,
-            states_i0=i0_states,
-            copy=True,
-        )
+            fdata = FData.from_mdata(
+                mdata=mdata,
+                states_i0=i0_states,
+            )
 
         # create tdata:
-        tdata = None
-        if point_data is not None:
-
-            def cb(data, dims):
-                n_states = i1_states - i0_states
-                n_targets = i1_targets - i0_targets
-                for o in set(out_vars).difference(data.keys()):
-                    data[o] = np.full(
-                        (n_states, n_targets, 1), np.nan, dtype=config.dtype_double
-                    )
-                    dims[o] = (FC.STATE, FC.TARGET, FC.TPOINT)
-
-            tdata = TData.from_dataset(
+        tdata = (
+            TData.from_dataset(
                 point_data,
                 mdata=mdata,
                 s_states=s_states,
                 s_targets=s_targets,
-                callback=cb,
+                callback=None,
                 states_i0=i0_states,
                 copy=True,
             )
+            if point_data is not None
+            else None
+        )
 
-        return [d for d in [mdata, fdata, tdata] if d is not None]
+        return (mdata, fdata) if tdata is None else (mdata, fdata, tdata)
 
     def combine_results(
         self,
@@ -535,7 +521,14 @@ class Engine(ABC):
         )
 
     @abstractmethod
-    def run_calculation(self, algo, model, model_data, farm_data, point_data=None):
+    def run_calculation(
+        self,
+        algo,
+        model,
+        model_data=None,
+        farm_data=None,
+        point_data=None,
+    ):
         """
         Runs the model calculation
 
@@ -543,12 +536,12 @@ class Engine(ABC):
         ----------
         algo: foxes.core.Algorithm
             The algorithm object
-        model: foxes.core.DataCalcModel
+        model: foxes.core.DataCalcModel, optional
             The model that whose calculate function
             should be run
         model_data: xarray.Dataset
             The initial model data
-        farm_data: xarray.Dataset
+        farm_data: xarray.Dataset, optional
             The initial farm data
         point_data: xarray.Dataset, optional
             The initial point data