foxes 1.2__py3-none-any.whl → 1.2.1__py3-none-any.whl

examples/abl_states/run.py

@@ -137,17 +137,17 @@ if __name__ == "__main__":
     # results by turbine
     turbine_results = o.reduce_states(
         {
-            FV.AMB_P: "mean",
-            FV.P: "mean",
-            FV.AMB_CAP: "mean",
-            FV.CAP: "mean",
-            FV.EFF: "mean",
+            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)
 

examples/induction/run.py

@@ -130,17 +130,17 @@ if __name__ == "__main__":
     # results by turbine
     turbine_results = o.reduce_states(
         {
-            FV.AMB_P: "mean",
-            FV.P: "mean",
-            FV.AMB_CAP: "mean",
-            FV.CAP: "mean",
-            FV.EFF: "mean",
+            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)
 

examples/random_timeseries/run.py

@@ -101,21 +101,21 @@ if __name__ == "__main__":
     ):
 
         if not args.nofig:
-            # fig, axs= plt.subplots(2, 1, figsize=(12,6))
-            # foxes.output.FarmLayoutOutput(farm).get_figure(ax=axs[0])
+            fig = plt.figure(figsize=(14.5, 7))
+            ax1 = fig.add_subplot(121)
+            ax2 = fig.add_subplot(122, polar=True)
+            foxes.output.FarmLayoutOutput(farm).get_figure(fig=fig, ax=ax1)
 
             o = foxes.output.StatesRosePlotOutput(states, point=[0.0, 0.0, 100.0])
-            fig = o.get_figure(
+            o.get_figure(
                 16,
                 FV.AMB_WS,
                 [0, 3.5, 6, 10, 15, 20],
-                figsize=(14.5, 7),
-                rect=[0.01, 0.05, 0.45, 0.85],
+                fig=fig,
+                ax=ax2,
+                freq_delta=2,
             )
 
-            ax = plt.Axes(fig, rect=[0.3, 0.1, 0.8, 0.8])
-            fig.add_axes(ax)
-            foxes.output.FarmLayoutOutput(farm).get_figure(fig=fig, ax=ax)
             plt.show()
             plt.close(fig)
 
@@ -187,17 +187,17 @@ if __name__ == "__main__":
         # results by turbine
         turbine_results = o.reduce_states(
             {
-                FV.AMB_P: "mean",
-                FV.P: "mean",
-                FV.AMB_CAP: "mean",
-                FV.CAP: "mean",
-                FV.EFF: "mean",
+                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)
 

examples/scan_row/run.py

@@ -76,8 +76,13 @@ if __name__ == "__main__":
     D = ttype.D
     H = ttype.H
 
-    states = foxes.input.states.ScanWS(
-        ws_list=np.linspace(args.ws0, args.ws1, n_s), wd=270.0, ti=0.08, rho=1.225
+    states = foxes.input.states.ScanStates(
+        {
+            FV.WS: np.linspace(args.ws0, args.ws1, n_s),
+            FV.WD: [270],
+            FV.TI: [0.08],
+            FV.RHO: [1.225],
+        }
     )
 
     farm = foxes.WindFarm()
@@ -139,17 +144,17 @@ if __name__ == "__main__":
     # results by turbine
     turbine_results = o.reduce_states(
         {
-            FV.AMB_P: "mean",
-            FV.P: "mean",
-            FV.AMB_CAP: "mean",
-            FV.CAP: "mean",
-            FV.EFF: "mean",
+            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)
 

examples/sector_management/run.py

@@ -138,25 +138,29 @@ if __name__ == "__main__":
     print(fr)
 
     if not args.nofig:
+        fig = plt.figure(figsize=(12, 4))
+        ax1 = fig.add_subplot(121, polar=True)
+        ax2 = fig.add_subplot(122, polar=True)
+
         o = foxes.output.RosePlotOutput(farm_results)
-        fig = o.get_figure(
+        o.get_figure(
             16,
             FV.P,
-            [100, 1000, 2000, 4000, 5001, 7000],
+            [0, 100, 1000, 2000, 4000, 5001, 7000],
             turbine=0,
             title="Power turbine 0",
-            figsize=(12, 6),
-            rect=[0.05, 0.1, 0.4, 0.8],
+            fig=fig,
+            ax=ax1,
         )
 
         o = foxes.output.RosePlotOutput(farm_results)
-        fig = o.get_figure(
+        o.get_figure(
             16,
             FV.P,
-            [100, 1000, 2000, 4000, 5001, 7000],
+            [0, 100, 1000, 2000, 4000, 5001, 7000],
             turbine=1,
             title="Power turbine 1",
             fig=fig,
-            rect=[0.35, 0.1, 0.8, 0.8],
+            ax=ax2,
         )
         plt.show()

examples/single_state/run.py

@@ -155,17 +155,17 @@ if __name__ == "__main__":
     # results by turbine
     turbine_results = o.reduce_states(
         {
-            FV.AMB_P: "mean",
-            FV.P: "mean",
-            FV.AMB_CAP: "mean",
-            FV.CAP: "mean",
-            FV.EFF: "mean",
+            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)
 

examples/tab_file/run.py

@@ -89,7 +89,7 @@ if __name__ == "__main__":
     ):
         if not args.nofig:
             o = foxes.output.StatesRosePlotOutput(states, point=[0.0, 0.0, 100.0])
-            fig = o.get_figure(12, FV.AMB_WS, [0, 3.5, 6, 10, 15, 20])
+            o.get_figure(12, FV.AMB_WS, [0, 3.5, 6, 10, 15, 20])
             plt.show()
 
         farm = foxes.WindFarm()

examples/timeseries/run.py

@@ -160,17 +160,17 @@ if __name__ == "__main__":
     # results by turbine
     turbine_results = o.reduce_states(
         {
-            FV.AMB_P: "mean",
-            FV.P: "mean",
-            FV.AMB_CAP: "mean",
-            FV.CAP: "mean",
-            FV.EFF: "mean",
+            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)
 

examples/timeseries_slurm/run.py

@@ -162,17 +162,17 @@ if __name__ == "__main__":
         # results by turbine
         turbine_results = o.reduce_states(
             {
-                FV.AMB_P: "mean",
-                FV.P: "mean",
-                FV.AMB_CAP: "mean",
-                FV.CAP: "mean",
-                FV.EFF: "mean",
+                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)
 

examples/wind_rose/run.py

@@ -113,7 +113,7 @@ if __name__ == "__main__":
 
     if not args.nofig:
         o = foxes.output.StatesRosePlotOutput(states, point=[0.0, 0.0, 100.0])
-        fig = o.get_figure(16, FV.AMB_WS, [0, 3.5, 6, 10, 15, 20])
+        o.get_figure(16, FV.AMB_WS, [0, 3.5, 6, 10, 15, 20], add_inf=True)
         plt.show()
 
     time0 = time.time()

examples/yawed_wake/run.py

@@ -173,17 +173,17 @@ if __name__ == "__main__":
     # results by turbine
     turbine_results = o.reduce_states(
         {
-            FV.AMB_P: "mean",
-            FV.P: "mean",
-            FV.AMB_CAP: "mean",
-            FV.CAP: "mean",
-            FV.EFF: "mean",
+            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)
 

foxes/algorithms/downwind/downwind.py

@@ -311,14 +311,24 @@ class Downwind(Algorithm):
         """
         return getattr(mdls, name)
 
-    def _print_deco(self, func_name, n_points=None):
+    def print_deco(self, func_name=None, n_points=None):
         """
         Helper function for printing model names
+
+        Parameters
+        ----------
+        func_name: str, optional
+            Name of the calling function
+        n_points: int, optional
+            The number of points
+
         """
         if self.verbosity > 0:
-            deco = "-" * 50
+            deco = "-" * 60
             print(f"\n{deco}")
-            print(f"  Running {self.name}: {func_name}")
+            print(f"  Algorithm: {type(self).__name__}")
+            if func_name is not None:
+                print(f"  Running {self.name}: {func_name}")
             print(deco)
             print(f"  n_states : {self.n_states}")
             print(f"  n_turbines: {self.n_turbines}")
@@ -538,7 +548,7 @@ class Downwind(Algorithm):
             self.initialize()
 
         # welcome:
-        self._print_deco("calc_farm")
+        self.print_deco("calc_farm")
 
         # collect models:
         if outputs == "default":
@@ -747,7 +757,7 @@ class Downwind(Algorithm):
 
         # welcome:
         points = np.asarray(points)
-        self._print_deco("calc_points", n_points=points.shape[1])
+        self.print_deco("calc_points", n_points=points.shape[1])
 
         # collect models and initialize:
         mlist, calc_pars = self._collect_point_models(

foxes/algorithms/sequential/sequential.py

@@ -136,7 +136,7 @@ class Sequential(Iterative):
         if not self.iterating:
             if not self.initialized:
                 self.initialize()
-            self._print_deco("calc_farm")
+            self.print_deco("calc_farm")
 
             self._inds = self.states0.index()
             self._weights = self.states0.weights(self)

foxes/core/algorithm.py

@@ -4,7 +4,7 @@ from abc import abstractmethod
 
 from .model import Model
 from foxes.data import StaticData
-from foxes.utils import Dict, all_subclasses
+from foxes.utils import Dict, new_instance
 from foxes.config import config
 import foxes.constants as FC
 
@@ -177,6 +177,28 @@ class Algorithm(Model):
         if self.verbosity >= vlim:
             print(*args, **kwargs)
 
+    def print_deco(self, func_name=None, n_points=None):
+        """
+        Helper function for printing model names
+
+        Parameters
+        ----------
+        func_name: str, optional
+            Name of the calling function
+        n_points: int, optional
+            The number of points
+
+        """
+        if self.verbosity > 0:
+            deco = "-" * 60
+            print(f"\n{deco}")
+            print(f"  Algorithm: {type(self).__name__}")
+            if func_name is not None:
+                print(f"  Running {self.name}: {func_name}")
+            print(deco)
+            print(f"  n_states : {self.n_states}")
+            print(f"  n_turbines: {self.n_turbines}")
+
     def initialize(self):
         """
         Initializes the algorithm.
@@ -926,22 +948,4 @@ class Algorithm(Model):
             Additional parameters for the constructor
 
         """
-
-        if algo_type is None:
-            return None
-
-        allc = all_subclasses(cls)
-        found = algo_type in [scls.__name__ for scls in allc]
-
-        if found:
-            for scls in allc:
-                if scls.__name__ == algo_type:
-                    return scls(*args, **kwargs)
-
-        else:
-            estr = (
-                "Algorithm type '{}' is not defined, available types are \n {}".format(
-                    algo_type, sorted([i.__name__ for i in allc])
-                )
-            )
-            raise KeyError(estr)
+        return new_instance(cls, algo_type, *args, **kwargs)

foxes/core/axial_induction_model.py

@@ -1,5 +1,6 @@
 from abc import abstractmethod
 
+from foxes.utils import new_instance
 from .model import Model
 
 
@@ -28,3 +29,20 @@ class AxialInductionModel(Model):
 
         """
         pass
+
+    @classmethod
+    def new(cls, induction_type, *args, **kwargs):
+        """
+        Run-time axial induction model factory.
+
+        Parameters
+        ----------
+        induction_type: str
+            The selected derived class name
+        args: tuple, optional
+            Additional parameters for the constructor
+        kwargs: dict, optional
+            Additional parameters for the constructor
+
+        """
+        return new_instance(cls, induction_type, *args, **kwargs)

foxes/core/engine.py

@@ -5,7 +5,7 @@ from tqdm import tqdm
 from xarray import Dataset
 
 from foxes.core import MData, FData, TData
-from foxes.utils import all_subclasses
+from foxes.utils import new_instance
 from foxes.config import config
 import foxes.constants as FC
 
@@ -563,19 +563,7 @@ class Engine(ABC):
             single="SingleChunkEngine",
         ).get(engine_type, engine_type)
 
-        allc = all_subclasses(cls)
-        found = engine_type in [scls.__name__ for scls in allc]
-
-        if found:
-            for scls in allc:
-                if scls.__name__ == engine_type:
-                    return scls(*args, **kwargs)
-
-        else:
-            estr = "engine type '{}' is not defined, available types are \n {}".format(
-                engine_type, sorted([i.__name__ for i in allc])
-            )
-            raise KeyError(estr)
+        return new_instance(cls, engine_type, *args, **kwargs)
 
 
 def get_engine(error=True, default=True):

foxes/core/farm_controller.py

@@ -2,6 +2,7 @@ import numpy as np
 
 from foxes.config import config
 import foxes.constants as FC
+from foxes.utils import new_instance
 
 from .farm_data_model import FarmDataModelList, FarmDataModel
 from .turbine_model import TurbineModel
@@ -395,3 +396,20 @@ class FarmController(FarmDataModel):
         """
         super().finalize(algo, verbosity)
         self.turbine_model_names = None
+
+    @classmethod
+    def new(cls, controller_type, *args, **kwargs):
+        """
+        Run-time farm controller factory.
+
+        Parameters
+        ----------
+        controller_type: str
+            The selected derived class name
+        args: tuple, optional
+            Additional parameters for the constructor
+        kwargs: dict, optional
+            Additional parameters for the constructor
+
+        """
+        return new_instance(cls, controller_type, *args, **kwargs)

foxes/core/ground_model.py

@@ -1,3 +1,5 @@
+from foxes.utils import new_instance
+
 from .model import Model
 
 
@@ -252,3 +254,20 @@ class GroundModel(Model):
 
         """
         wmodel.finalize_wake_deltas(algo, mdata, fdata, amb_results, wake_deltas)
+
+    @classmethod
+    def new(cls, ground_type, *args, **kwargs):
+        """
+        Run-time ground model factory.
+
+        Parameters
+        ----------
+        ground_type: str
+            The selected derived class name
+        args: tuple, optional
+            Additional parameters for the constructor
+        kwargs: dict, optional
+            Additional parameters for the constructor
+
+        """
+        return new_instance(cls, ground_type, *args, **kwargs)

foxes/core/partial_wakes_model.py

@@ -1,6 +1,6 @@
 from abc import abstractmethod
 
-from foxes.utils import all_subclasses
+from foxes.utils import new_instance
 
 from .model import Model
 
@@ -189,30 +189,18 @@ class PartialWakesModel(Model):
         pass
 
     @classmethod
-    def new(cls, pwake_type, **kwargs):
+    def new(cls, pwakes_type, *args, **kwargs):
         """
-        Run-time partial wakes factory.
+        Run-time partial wakes model factory.
 
         Parameters
         ----------
-        pwake_type: str
+        pwakes_type: str
             The selected derived class name
+        args: tuple, optional
+            Additional parameters for the constructor
+        kwargs: dict, optional
+            Additional parameters for the constructor
 
         """
-
-        if pwake_type is None:
-            return None
-
-        allc = all_subclasses(cls)
-        found = pwake_type in [scls.__name__ for scls in allc]
-
-        if found:
-            for scls in allc:
-                if scls.__name__ == pwake_type:
-                    return scls(**kwargs)
-
-        else:
-            estr = "Partial wakes model type '{}' is not defined, available types are \n {}".format(
-                pwake_type, sorted([i.__name__ for i in allc])
-            )
-            raise KeyError(estr)
+        return new_instance(cls, pwakes_type, *args, **kwargs)

foxes/core/point_data_model.py

@@ -2,6 +2,7 @@ import numpy as np
 from abc import abstractmethod
 
 from foxes.config import config
+from foxes.utils import new_instance
 import foxes.constants as FC
 
 from .data_calc_model import DataCalcModel
@@ -263,3 +264,20 @@ class PointDataModelList(PointDataModel):
             tdata.update(res)
 
         return {v: tdata[v] for v in self.output_point_vars(algo)}
+
+    @classmethod
+    def new(cls, model_type, *args, **kwargs):
+        """
+        Run-time point model factory.
+
+        Parameters
+        ----------
+        model_type: str
+            The selected derived class name
+        args: tuple, optional
+            Additional parameters for the constructor
+        kwargs: dict, optional
+            Additional parameters for the constructor
+
+        """
+        return new_instance(cls, model_type, *args, **kwargs)

foxes/core/rotor_model.py

@@ -2,7 +2,7 @@ import numpy as np
 from abc import abstractmethod
 
 from foxes.config import config
-from foxes.utils import wd2uv, uv2wd, all_subclasses
+from foxes.utils import wd2uv, uv2wd, new_instance
 
 import foxes.variables as FV
 import foxes.constants as FC
@@ -417,20 +417,4 @@ class RotorModel(FarmDataModel):
             Additional parameters for constructor
 
         """
-
-        if rmodel_type is None:
-            return None
-
-        allc = all_subclasses(cls)
-        found = rmodel_type in [scls.__name__ for scls in allc]
-
-        if found:
-            for scls in allc:
-                if scls.__name__ == rmodel_type:
-                    return scls(*args, **kwargs)
-
-        else:
-            estr = "Rotor model type '{}' is not defined, available types are \n {}".format(
-                rmodel_type, sorted([i.__name__ for i in allc])
-            )
-            raise KeyError(estr)
+        return new_instance(cls, rmodel_type, *args, **kwargs)

foxes/core/states.py

@@ -1,7 +1,7 @@
 from abc import abstractmethod
 
 from .point_data_model import PointDataModel, PointDataModelList
-from foxes.utils import all_subclasses
+from foxes.utils import new_instance
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -163,22 +163,7 @@ class States(PointDataModel):
             Additional parameters for constructor
 
         """
-
-        if states_type is None:
-            return None
-
-        allc = all_subclasses(cls)
-        found = states_type in [scls.__name__ for scls in allc]
-
-        if found:
-            for scls in allc:
-                if scls.__name__ == states_type:
-                    return scls(*args, **kwargs)
-        else:
-            estr = "States type '{}' is not defined, available types are \n {}".format(
-                states_type, sorted([i.__name__ for i in allc])
-            )
-            raise KeyError(estr)
+        return new_instance(cls, states_type, *args, **kwargs)
 
 
 class ExtendedStates(States):