foxes 1.5.1__tar.gz → 1.6.1__tar.gz

{foxes-1.5.1/foxes.egg-info → foxes-1.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: foxes
-Version: 1.5.1
+Version: 1.6.1
 Summary: Farm Optimization and eXtended yield Evaluation Software
 Author: Jonas Schulte
 Maintainer: Jonas Schulte
@@ -41,23 +41,24 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Development Status :: 4 - Beta
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: cycler>=0.10
-Requires-Dist: h5netcdf>=1.0
 Requires-Dist: matplotlib>=3.8
 Requires-Dist: numpy>=1.26
 Requires-Dist: pandas>=2.0
-Requires-Dist: pyyaml>=4.0
 Requires-Dist: scipy>=1.12
-Requires-Dist: tqdm>=2.0
 Requires-Dist: xarray>=2023
+Requires-Dist: netcdf4>=1.0
+Requires-Dist: pyyaml>=4.0
+Requires-Dist: tqdm>=2.0
+Requires-Dist: utm>=0.5
 Provides-Extra: opt
-Requires-Dist: foxes-opt>=0.5; extra == "opt"
+Requires-Dist: foxes-opt>=0.6; extra == "opt"
 Provides-Extra: dask
 Requires-Dist: dask>=2022.0; extra == "dask"
 Requires-Dist: distributed>=2022.0; extra == "dask"
@@ -139,7 +140,7 @@ Evaluation Software"`
 
 ## Requirements
 
-The supported Python versions are `Python 3.9`...`3.13`.
+The supported Python versions are `Python 3.9`...`3.14`.
 
 ## Installation
 

{foxes-1.5.1 → foxes-1.6.1}/README.md

@@ -56,7 +56,7 @@ Evaluation Software"`
 
 ## Requirements
 
-The supported Python versions are `Python 3.9`...`3.13`.
+The supported Python versions are `Python 3.9`...`3.14`.
 
 ## Installation
 

foxes-1.6.1/examples/parameter_study/run.py

@@ -0,0 +1,115 @@
+import time
+import argparse
+import numpy as np
+from xarray import Dataset
+
+import foxes
+import foxes.variables as FV
+import foxes.constants as FC
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "-l",
+        "--layout",
+        help="The wind farm layout file (path or static)",
+        default="test_farm_67.csv",
+    )
+    parser.add_argument("-r", "--rotor", help="The rotor model", default="centre")
+    parser.add_argument(
+        "-p", "--pwakes", help="The partial wakes models", default=None, nargs="+"
+    )
+    parser.add_argument(
+        "-w",
+        "--wakes",
+        help="The wake models",
+        default=["Bastankhah2016_linear"],
+        nargs="+",
+    )
+    parser.add_argument(
+        "-m", "--tmodels", help="The turbine models", default=[], nargs="+"
+    )
+    parser.add_argument("-e", "--engine", help="The engine", default=None)
+    parser.add_argument(
+        "-n", "--n_cpus", help="The number of cpus", default=None, type=int
+    )
+    parser.add_argument(
+        "-c",
+        "--chunksize_states",
+        help="The chunk size for states",
+        default=None,
+        type=int,
+    )
+    parser.add_argument(
+        "-C",
+        "--chunksize_points",
+        help="The chunk size for points",
+        default=None,
+        type=int,
+    )
+    parser.add_argument(
+        "-nf", "--nofig", help="Do not show figures", action="store_true"
+    )
+    args = parser.parse_args()
+
+    states = foxes.input.states.Timeseries(
+        data_source="timeseries_3000.csv.gz",
+        output_vars=[FV.WS, FV.WD, FV.TI, FV.RHO],
+    )
+
+    farm = foxes.WindFarm()
+    foxes.input.farm_layout.add_grid(
+        farm,
+        xy_base=np.array([500.0, 500.0]),
+        step_vectors=np.array([[500.0, 0], [0, 700.0]]),
+        steps=(5, 5),
+        turbine_models=args.tmodels + ["NREL5MW"],
+    )
+
+    k_values = np.linspace(0.01, 0.1, 10)
+    n_pop = len(k_values)
+    pop_data = np.zeros((n_pop, farm.n_turbines))
+    pop_data[:] = k_values[:, None]
+    pop_data = Dataset(
+        {
+            FV.K: (("i", FC.TURBINE), pop_data),
+        }
+    )
+    print("\nInput population data:\n\n", pop_data)
+    print(f"\n{FV.K} values: {pop_data[FV.K].values[:, 0]}\n")
+
+    algo = foxes.algorithms.Downwind(
+        farm,
+        states,
+        wake_models=args.wakes,
+        rotor_model=args.rotor,
+        wake_frame="rotor_wd",
+        partial_wakes=args.pwakes,
+        population_params=dict(
+            data_source=pop_data,
+            index_coord="i",
+            turbine_coord=FC.TURBINE,
+        ),
+    )
+
+    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,
+    ):
+        time0 = time.time()
+        farm_results = algo.calc_farm()
+        time1 = time.time()
+        print("Calc time =", time1 - time0, "\n")
+
+    pop_results = algo.population_model.farm2pop_results(algo, farm_results)
+    print("\nPopulation results:\n\n", pop_results)
+    print(f"\n{FV.K} values: {pop_results[FV.K].values[:, 0, 0]}")
+
+    P_mean = (
+        (pop_results[FV.P] * pop_results[FV.WEIGHT])
+        .sum(dim=FC.STATE)
+        .sum(dim=FC.TURBINE)
+    )
+    print("\nFarm P_mean:", P_mean.values)

{foxes-1.5.1 → foxes-1.6.1}/examples/power_mask/run.py

@@ -153,7 +153,6 @@ if __name__ == "__main__":
         ]
 
         # run calculation with power mask:
-
         farm_results = algo.calc_farm(outputs=outputs)
 
         fr = farm_results.to_dataframe()
@@ -167,10 +166,9 @@ if __name__ == "__main__":
         o1 = foxes.output.StateTurbineMap(farm_results)
 
         # run calculation without power mask:
-
-        mbook.finalize(algo)
-        models.remove("set_Pmax")
-        models.remove("PMask")
+        for t in farm.turbines:
+            t.models.remove("set_Pmax")
+            t.models.remove("PMask")
 
         farm_results = algo.calc_farm(outputs=outputs)
 
@@ -186,7 +184,7 @@ if __name__ == "__main__":
             o0 = foxes.output.StateTurbineMap(farm_results)
 
             # show power:
-            fig, axs = plt.subplots(1, 3, figsize=(15, 5))
+            fig, axs = plt.subplots(1, 3, figsize=(11, 5))
             o0.plot_map(
                 FV.P,
                 ax=axs[0],
@@ -218,7 +216,7 @@ if __name__ == "__main__":
             plt.close(fig)
 
             # show ct:
-            fig, axs = plt.subplots(1, 3, figsize=(15, 5))
+            fig, axs = plt.subplots(1, 3, figsize=(11, 5))
             o0.plot_map(
                 FV.CT,
                 ax=axs[0],

{foxes-1.5.1 → foxes-1.6.1}/examples/timeseries/run.py

@@ -116,6 +116,7 @@ if __name__ == "__main__":
         n_procs=args.n_cpus,
         chunk_size_states=args.chunksize_states,
         chunk_size_points=args.chunksize_points,
+        verbosity=1,
     ):
         time0 = time.time()
         farm_results = algo.calc_farm()

{foxes-1.5.1 → foxes-1.6.1}/examples/yawed_wake/run.py

@@ -131,7 +131,12 @@ if __name__ == "__main__":
             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"
+                args.var,
+                resolution=10,
+                xmin=-500,
+                xmax=3000,
+                rotor_color="red",
+                cmap="BuPu" if args.var == FV.WD else None,
             )
             fig = next(g)
             plt.show()
@@ -149,6 +154,7 @@ if __name__ == "__main__":
                 zmin=0,
                 zmax=250,
                 rotor_color="red",
+                cmap="BuPu" if args.var == FV.WD else None,
                 verbosity=0,
             )
             fig = next(g)

{foxes-1.5.1 → foxes-1.6.1}/foxes/algorithms/downwind/downwind.py

@@ -1,4 +1,5 @@
 import numpy as np
+from xarray import Dataset
 
 from foxes.core import Algorithm, FarmDataModelList, get_engine
 from foxes.core import PointDataModel, PointDataModelList, FarmController
@@ -77,6 +78,7 @@ class Downwind(Algorithm):
         ground_models=None,
         farm_controller="basic_ctrl",
         mbook=None,
+        population_params=None,
         **kwargs,
     ):
         """
@@ -110,6 +112,9 @@ class Downwind(Algorithm):
             looked up in the model book
         mbook: foxes.ModelBook, optional
             The model book
+        population_params: dict, optional
+            The population parameters. If provided, this will be
+            used to create the population model.
         kwargs: dict, optional
             Additional parameters for the base class
 
@@ -119,7 +124,22 @@ class Downwind(Algorithm):
 
         super().__init__(mbook, farm, **kwargs)
 
-        self.__states = states
+        self._SETPOP = None
+        if population_params is None:
+            self.__states = states
+        else:
+            self._SETPOP = "set_pop_data"
+            assert self._SETPOP not in mbook.turbine_models, (
+                f"Algorithm '{self.name}': Model name '{self._SETPOP}' for population data model is reserved"
+            )
+            self._pop_model = self.get_model("PopulationModel")(**population_params)
+            mbook.turbine_models[self._SETPOP] = self._pop_model
+            self.__states = self.get_model("PopulationStates")(
+                states, n_pop=self._pop_model.n_pop
+            )
+            for t in self.farm.turbines:
+                if self._SETPOP not in t.models:
+                    t.insert_model(0, self._SETPOP)
         self.n_states = None
 
         self.__rotor_model = self.mbook.rotor_models.get_item(rotor_model)
@@ -313,6 +333,72 @@ class Downwind(Algorithm):
         """
         return self.__farm_controller
 
+    @property
+    def population_model(self):
+        """
+        The population model
+
+        Returns
+        -------
+        m: foxes.core.PopulationModel
+            The population model, or None if not used
+
+        """
+        if self._SETPOP is None:
+            return None
+        return self._pop_model
+
+    def select_population_member(self, pop_farm_results, pop_index):
+        """
+        Select a specific population member from the population model results.
+
+        Parameters
+        ----------
+        pop_farm_results: xarray.Dataset
+            The farm results including population index dimension
+        pop_index: int or numpy.ndarray
+            The population index to select. Either a single index
+            for all states, or an array of shape (n_states,)
+
+        Returns
+        -------
+        farm_results: xarray.Dataset
+            The farm results for the selected population member.
+
+        """
+        if self._SETPOP is None:
+            raise ValueError(f"Algorithm '{self.name}': No population model defined")
+        ini = self.initialized
+        if ini:
+            self.finalize()
+        self.states = self.states.states
+        for t in self.farm.turbines:
+            if self._SETPOP in t.models:
+                del t.models[t.models.index(self._SETPOP)]
+        if ini:
+            self.initialize()
+
+        POP = self.population_model.index_coord
+        assert POP in pop_farm_results.sizes, (
+            f"Algorithm '{self.name}': Population index coordinate '{POP}' not found in provided farm results"
+        )
+        if isinstance(pop_index, np.ndarray):
+            return Dataset(
+                {
+                    v: (
+                        (FC.STATE, FC.TURBINE),
+                        np.take_along_axis(d.values, pop_index[None, :, None], axis=0)[
+                            0
+                        ],
+                    )
+                    if d.dims == (POP, FC.STATE, FC.TURBINE)
+                    else d
+                    for v, d in pop_farm_results.data_vars.items()
+                }
+            )
+        else:
+            return pop_farm_results.sel({POP: pop_index})
+
     @classmethod
     def get_model(cls, name):
         """
@@ -417,7 +503,7 @@ class Downwind(Algorithm):
         """
         if not self.states.initialized:
             self.states.initialize(self, self.verbosity)
-            self.n_states = self.states.size()
+        self.n_states = self.states.size()
 
     def sub_models(self):
         """
@@ -550,8 +636,9 @@ class Downwind(Algorithm):
         self,
         outputs=None,
         calc_parameters={},
-        finalize=True,
         ambient=False,
+        finalize=True,
+        clear_mem=False,
         **kwargs,
     ):
         """
@@ -564,10 +651,12 @@ class Downwind(Algorithm):
             Key: model name str, value: parameter dict
         outputs: list of str, optional
             The output variables, or None for defaults
-        finalize: bool
-            Flag for finalization after calculation
         ambient: bool
             Flag for ambient instead of waked calculation
+        finalize: bool
+            Flag for finalization after calculation
+        clear_mem: bool
+            Clear idata memory after starting the run
         kwargs: dict, optional
             Additional parameters for run_calculation
 
@@ -614,23 +703,25 @@ class Downwind(Algorithm):
             model_data,
             parameters=calc_pars,
             outputs=outputs,
+            clear_mem=clear_mem,
             **kwargs,
         )
-        farm_results[FC.TNAME] = ((FC.TURBINE,), self.farm.turbine_names)
-        for v in [FV.ORDER, FV.ORDER_SSEL, FV.ORDER_INV]:
-            if v in farm_results:
-                farm_results[v] = farm_results[v].astype(config.dtype_int)
+        if farm_results is not None:
+            farm_results[FC.TNAME] = ((FC.TURBINE,), self.farm.turbine_names)
+            for v in [FV.ORDER, FV.ORDER_SSEL, FV.ORDER_INV]:
+                if v in farm_results:
+                    farm_results[v] = farm_results[v].astype(config.dtype_int)
         del model_data
 
         # finalize models:
-        if finalize:
+        if clear_mem or finalize:
             self.print("\n")
             mlist.finalize(self, self.verbosity - 1)
-            self.finalize()
+            self.finalize(clear_mem=clear_mem)
         else:
             self.del_model_data(mlist)
 
-        if ambient:
+        if ambient and farm_results:
             dvars = [v for v in farm_results.data_vars.keys() if v in FV.var2amb]
             farm_results = farm_results.drop_vars(dvars)
 

{foxes-1.5.1 → foxes-1.6.1}/foxes/algorithms/downwind/models/__init__.py

@@ -4,3 +4,6 @@ from .farm_wakes_calc import FarmWakesCalculation as FarmWakesCalculation
 from .point_wakes_calc import PointWakesCalculation as PointWakesCalculation
 from .init_farm_data import InitFarmData as InitFarmData
 from .reorder_farm_output import ReorderFarmOutput as ReorderFarmOutput
+
+from .population import PopulationStates as PopulationStates
+from .population import PopulationModel as PopulationModel