foxes 0.5.0.2__py3-none-any.whl → 0.5.2__py3-none-any.whl

foxes/models/model_book.py

@@ -1,15 +1,20 @@
 import foxes.models as fm
 import foxes.variables as FV
 from foxes.utils import Dict
+
 from foxes.core import (
-    TurbineModel,
-    RotorModel,
-    FarmModel,
     PointDataModel,
+    FarmDataModel,
     FarmController,
+    RotorModel,
+    TurbineType,
+    TurbineModel,
+    PartialWakesModel,
+    WakeFrame,
+    WakeSuperposition,
+    WakeModel
 )
 
-
 class ModelBook:
     """
     Container for all kinds of models.
@@ -28,9 +33,6 @@ class ModelBook:
     turbine_models: foxes.utils.Dict
         The turbine models. Keys: model name str,
         values: foxes.core.TurbineModel
-    turbine_orders: foxes.utils.Dict
-        The turbine orders. Keys: model name str,
-        values: foxes.core.TurbineOrder
     farm_models: foxes.utils.Dict
         The farm models. Keys: model name str,
         values: foxes.core.FarmModel
@@ -51,6 +53,8 @@ class ModelBook:
         values: foxes.core.WakeModel
     sources: foxes.utils.Dict
         All sources dict
+    base_classes: foxes.utils.Dict
+        The base classes for all model types
 
     :group: foxes
 
@@ -193,47 +197,27 @@ class ModelBook:
 
         self.wake_superpositions = Dict(
             name="wake_superpositions",
-            linear=fm.wake_superpositions.LinearSuperposition(
-                scalings=f"source_turbine_{FV.REWS}"
-            ),
-            linear_lim=fm.wake_superpositions.LinearSuperposition(
-                scalings=f"source_turbine_{FV.REWS}",
-                lim_low={FV.WS: 1e-4},
-            ),
-            linear_amb=fm.wake_superpositions.LinearSuperposition(
-                scalings=f"source_turbine_{FV.AMB_REWS}"
-            ),
-            quadratic=fm.wake_superpositions.QuadraticSuperposition(
-                scalings=f"source_turbine_{FV.REWS}"
-            ),
-            quadratic_amb=fm.wake_superpositions.QuadraticSuperposition(
-                scalings=f"source_turbine_{FV.AMB_REWS}"
-            ),
-            max=fm.wake_superpositions.MaxSuperposition(
-                scalings=f"source_turbine_{FV.REWS}"
-            ),
-            max_amb=fm.wake_superpositions.MaxSuperposition(
-                scalings=f"source_turbine_{FV.AMB_REWS}"
-            ),
-            product=fm.wake_superpositions.ProductSuperposition(),
-            product_lim=fm.wake_superpositions.ProductSuperposition(
-                lim_low={FV.WS: 1e-4},
-            ),
-            ti_linear=fm.wake_superpositions.TISuperposition(
-                ti_superp="linear", superp_to_amb="quadratic"
-            ),
-            ti_quadratic=fm.wake_superpositions.TISuperposition(
-                ti_superp="quadratic", superp_to_amb="quadratic"
-            ),
-            ti_cubic=fm.wake_superpositions.TISuperposition(
-                ti_superp="power_3", superp_to_amb="quadratic"
-            ),
-            ti_quartic=fm.wake_superpositions.TISuperposition(
-                ti_superp="power_4", superp_to_amb="quadratic"
-            ),
-            ti_max=fm.wake_superpositions.TISuperposition(
-                ti_superp="max", superp_to_amb="quadratic"
-            ),
+            ws_linear=fm.wake_superpositions.WSLinear(scale_amb=False),
+            ws_linear_lim=fm.wake_superpositions.WSLinear(scale_amb=False, lim_low=1e-4),
+            ws_linear_amb=fm.wake_superpositions.WSLinear(scale_amb=True),
+            ws_linear_amb_lim=fm.wake_superpositions.WSLinear(scale_amb=True, lim_low=1e-4),
+            ws_quadratic=fm.wake_superpositions.WSQuadratic(scale_amb=False),
+            ws_quadratic_lim=fm.wake_superpositions.WSQuadratic(scale_amb=False, lim_low=1e-4),
+            ws_quadratic_amb=fm.wake_superpositions.WSQuadratic(scale_amb=True),
+            ws_quadratic_amb_lim=fm.wake_superpositions.WSQuadratic(scale_amb=True, lim_low=1e-4),
+            ws_cubic=fm.wake_superpositions.WSPow(pow=3, scale_amb=False),
+            ws_cubic_amb=fm.wake_superpositions.WSPow(pow=3, scale_amb=True),
+            ws_quartic=fm.wake_superpositions.WSPow(pow=4, scale_amb=False),
+            ws_quartic_amb=fm.wake_superpositions.WSPow(pow=4, scale_amb=True),
+            ws_max=fm.wake_superpositions.WSMax(scale_amb=False),
+            ws_max_amb=fm.wake_superpositions.WSMax(scale_amb=True),
+            ws_product=fm.wake_superpositions.WSProduct(),
+            ws_product_lim=fm.wake_superpositions.WSProduct(lim_low=1e-4),
+            ti_linear=fm.wake_superpositions.TILinear(superp_to_amb="quadratic"),
+            ti_quadratic=fm.wake_superpositions.TIQuadratic(superp_to_amb="quadratic"),
+            ti_cubic=fm.wake_superpositions.TIPow(pow=3, superp_to_amb="quadratic"),
+            ti_quartic=fm.wake_superpositions.TIPow(pow=4, superp_to_amb="quadratic"),
+            ti_max=fm.wake_superpositions.TIMax(superp_to_amb="quadratic"),
         )
 
         self.wake_models = Dict(name="wake_models")
@@ -241,69 +225,80 @@ class ModelBook:
             "linear",
             "linear_lim",
             "linear_amb",
+            "linear_amb_lim",
             "quadratic",
+            "wquadratic_lim",
             "quadratic_amb",
-            "max",
+            "quadratic_amb_lim",
+            "cubic",
+            "cubic_amb",
+            "quartic",
+            "quartic_amb",
+            "wmax",
             "max_amb",
             "product",
             "product_lim",
         ]
         for s in slist:
             self.wake_models[f"Jensen_{s}"] = fm.wake_models.wind.JensenWake(
-                superposition=s
+                superposition=f"ws_{s}"
             )
             self.wake_models[f"Jensen_{s}_k002"] = fm.wake_models.wind.JensenWake(
-                k=0.02, superposition=s
+                k=0.02, superposition=f"ws_{s}"
             )
             self.wake_models[f"Jensen_{s}_k004"] = fm.wake_models.wind.JensenWake(
-                k=0.04, superposition=s
+                k=0.04, superposition=f"ws_{s}"
             )
             self.wake_models[f"Jensen_{s}_k007"] = fm.wake_models.wind.JensenWake(
-                k=0.07, superposition=s
+                k=0.07, superposition=f"ws_{s}"
             )
             self.wake_models[f"Jensen_{s}_k0075"] = fm.wake_models.wind.JensenWake(
-                k=0.075, superposition=s
+                k=0.075, superposition=f"ws_{s}"
             )
 
-            self.wake_models[f"Bastankhah_{s}"] = fm.wake_models.wind.BastankhahWake(
-                superposition=s
+            self.wake_models[f"Bastankhah2014_{s}"] = fm.wake_models.wind.Bastankhah2014(
+                superposition=f"ws_{s}", sbeta_factor=0.2
             )
             self.wake_models[
-                f"Bastankhah_{s}_k002"
-            ] = fm.wake_models.wind.BastankhahWake(k=0.02, superposition=s)
+                f"Bastankhah2014_{s}_k002"
+            ] = fm.wake_models.wind.Bastankhah2014(
+                k=0.02, sbeta_factor=0.2, superposition=f"ws_{s}"
+            )
             self.wake_models[
-                f"Bastankhah_{s}_k004"
-            ] = fm.wake_models.wind.BastankhahWake(k=0.04, superposition=s)
+                f"Bastankhah2014_{s}_k004"
+            ] = fm.wake_models.wind.Bastankhah2014(
+                k=0.04, sbeta_factor=0.2, superposition=f"ws_{s}"
+            )
 
-            self.wake_models[f"Bastankhah0_{s}"] = fm.wake_models.wind.BastankhahWake(
-                superposition=s, sbeta_factor=0.2
+            self.wake_models[f"Bastankhah025_{s}"] = fm.wake_models.wind.Bastankhah2014(
+                superposition=f"ws_{s}", sbeta_factor=0.25
             )
             self.wake_models[
-                f"Bastankhah0_{s}_k002"
-            ] = fm.wake_models.wind.BastankhahWake(
-                k=0.02, superposition=s, sbeta_factor=0.2
+                f"Bastankhah025_{s}_k002"
+            ] = fm.wake_models.wind.Bastankhah2014(
+                k=0.02, superposition=f"ws_{s}", sbeta_factor=0.25
             )
             self.wake_models[
-                f"Bastankhah0_{s}_k004"
-            ] = fm.wake_models.wind.BastankhahWake(
-                k=0.04, superposition=s, sbeta_factor=0.2
+                f"Bastankhah025_{s}_k004"
+            ] = fm.wake_models.wind.Bastankhah2014(
+                k=0.04, superposition=f"ws_{s}", sbeta_factor=0.25
             )
 
-            self.wake_models[f"PorteAgel_{s}"] = fm.wake_models.wind.PorteAgelWake(
-                superposition=s
+            self.wake_models[f"Bastankhah2016_{s}"] = fm.wake_models.wind.Bastankhah2016(
+                superposition=f"ws_{s}"
             )
-            self.wake_models[f"PorteAgel_{s}_k002"] = fm.wake_models.wind.PorteAgelWake(
-                superposition=s, k=0.02
+            self.wake_models[f"Bastankhah2016_{s}_k002"] = fm.wake_models.wind.Bastankhah2016(
+                superposition=f"ws_{s}", k=0.02
             )
-            self.wake_models[f"PorteAgel_{s}_k004"] = fm.wake_models.wind.PorteAgelWake(
-                superposition=s, k=0.04
+            self.wake_models[f"Bastankhah2016_{s}_k004"] = fm.wake_models.wind.Bastankhah2016(
+                superposition=f"ws_{s}", k=0.04
             )
 
             self.wake_models[f"TurbOPark_{s}_A002"] = fm.wake_models.wind.TurbOParkWake(
-                A=0.02, superposition=s
+                A=0.02, superposition=f"ws_{s}"
             )
             self.wake_models[f"TurbOPark_{s}_A004"] = fm.wake_models.wind.TurbOParkWake(
-                A=0.04, superposition=s
+                A=0.04, superposition=f"ws_{s}"
             )
 
             As = [0.02, 0.04]
@@ -314,29 +309,29 @@ class ModelBook:
                     d = str(dx).replace(".", "") if dx < 1 else int(dx)
                     self.wake_models[
                         f"TurbOParkIX_{s}_A{a}_dx{d}"
-                    ] = fm.wake_models.wind.TurbOParkWakeIX(A=A, superposition=s, dx=dx)
+                    ] = fm.wake_models.wind.TurbOParkWakeIX(A=A, superposition=f"ws_{s}", dx=dx)
 
-        slist = ["ti_linear", "ti_quadratic", "ti_cubic", "ti_quartic", "ti_max"]
+        slist = ["linear", "quadratic", "cubic", "quartic", "max"]
         for s in slist:
             self.wake_models[
-                f"CrespoHernandez_{s[3:]}"
-            ] = fm.wake_models.ti.CrespoHernandezTIWake(superposition=s)
+                f"CrespoHernandez_{s}"
+            ] = fm.wake_models.ti.CrespoHernandezTIWake(superposition=f"ti_{s}")
             self.wake_models[
-                f"CrespoHernandez_ambti_{s[3:]}"
-            ] = fm.wake_models.ti.CrespoHernandezTIWake(superposition=s, use_ambti=True)
+                f"CrespoHernandez_ambti_{s}"
+            ] = fm.wake_models.ti.CrespoHernandezTIWake(superposition=f"ti_{s}", use_ambti=True)
             self.wake_models[
-                f"CrespoHernandez_{s[3:]}_k002"
-            ] = fm.wake_models.ti.CrespoHernandezTIWake(k=0.02, superposition=s)
+                f"CrespoHernandez_{s}_k002"
+            ] = fm.wake_models.ti.CrespoHernandezTIWake(k=0.02, superposition=f"ti_{s}")
 
-            self.wake_models[f"IECTI2005_{s[3:]}"] = fm.wake_models.ti.IECTIWake(
-                superposition=s, iec_type="2005"
+            self.wake_models[f"IECTI2005_{s}"] = fm.wake_models.ti.IECTIWake(
+                superposition=f"ti_{s}", iec_type="2005"
             )
 
-            self.wake_models[f"IECTI2019_{s[3:]}"] = fm.wake_models.ti.IECTIWake(
-                superposition=s, iec_type="2019"
+            self.wake_models[f"IECTI2019_{s}"] = fm.wake_models.ti.IECTIWake(
+                superposition=f"ti_{s}", iec_type="2019"
             )
 
-        self.wake_models[f"RHB"] = fm.wake_models.induction.RHB()
+        self.wake_models[f"RHB"] = fm.wake_models.induction.RankineHalfBody()
 
         self.sources = Dict(
             name="sources",
@@ -351,6 +346,19 @@ class ModelBook:
             wake_superpositions=self.wake_superpositions,
             wake_models=self.wake_models,
         )
+        self.base_classes = Dict(
+            name="base_classes",
+            point_models=PointDataModel,
+            rotor_models=RotorModel,
+            turbine_types=TurbineType,
+            turbine_models=TurbineModel,
+            farm_models=FarmDataModel,
+            farm_controllers=FarmController,
+            partial_wakes=PartialWakesModel,
+            wake_frames=WakeFrame,
+            wake_superpositions=WakeSuperposition,
+            wake_models=WakeModel,
+        )
 
         for s in self.sources.values():
             for k, m in s.items():
@@ -383,6 +391,38 @@ class ModelBook:
                 else:
                     print("(none)")
                 print()
+    
+    def get(self, model_type, name, class_name=None, *args, **kwargs):
+        """
+        Gets a model object.
+         
+        If not found, dynamically creates it (given the class name)
+
+        Parameters
+        ----------
+        model_type: str
+            The model type
+        name: str
+            The model name
+        class_name: str, optinal
+            Name of the model class
+        args: tuple, optional
+            Arguments for the model class
+        kwargs: dict, optional
+            Arguments for the model class
+        
+        Returns
+        -------
+        model: mclass
+            The model object
+
+        """
+        if name not in self.sources[model_type]:
+            if class_name is None:
+                raise KeyError(f"Model '{name}' of type '{model_type}' not found in model book. Available: {sorted(list(self.sources[model_type].keys()))}")
+            bclass = self.base_classes[model_type]
+            self.sources[model_type][name] = bclass.new(class_name, *args, **kwargs)
+        return self.sources[model_type][name]
 
     def finalize(self, algo, verbosity=0):
         """

foxes/models/turbine_models/rotor_centre_calc.py

@@ -49,8 +49,7 @@ class RotorCentreCalc(TurbineModel):
             The verbosity level, 0 = silent
 
         """
-        pvars = list(self.calc_vars.values())
-        self._wcalc = algo.PointWakesCalculation(point_vars=pvars)
+        self._wcalc = algo.get_model("PointWakesCalculation")()
         super().initialize(algo, verbosity)
 
     def sub_models(self):

foxes/models/turbine_types/CpCt_file.py

@@ -4,7 +4,7 @@ import pandas as pd
 from .PCt_file import PCtFile
 from foxes.data import parse_Pct_file_name
 from foxes.utils import PandasFileHelper
-
+import foxes.constants as FC
 
 class CpCtFile(PCtFile):
     """
@@ -55,6 +55,16 @@ class CpCtFile(PCtFile):
         A = np.pi * (D / 2) ** 2
         ws = data[col_ws].to_numpy()
         cp = data[col_cp].to_numpy()
-        data["P"] = 0.5 * rho * A * cp * ws**3
+        P_unit = pars.pop("P_unit", FC.kW)
+
+        ws_delta = 0.0001
+        ws_min = np.min(ws)
+        ws_max = np.max(ws)
+        N = int((ws_max - ws_min)/ws_delta)
+
+        data_P = pd.DataFrame(index=range(N), dtype=FC.DTYPE)
+        data_P["ws"] = np.linspace(ws_min, ws_max, N, endpoint=True)
+        data_P["cp"] = np.interp(data_P["ws"], ws, cp, left=0, right=0)
+        data_P["P"] = 0.5 * rho * A * data_P["cp"] * data_P["ws"]**3 / FC.P_UNITS[P_unit]
 
-        super().__init__(data, col_ws=col_ws, col_P="P", rho=rho, **pars)
+        super().__init__(data_P, col_ws="ws", col_P="P", rho=rho, P_unit=P_unit, **pars)

foxes/models/turbine_types/CpCt_from_two.py

@@ -66,14 +66,24 @@ class CpCtFromTwo(PCtFromTwo):
         A = np.pi * (D / 2) ** 2
         ws = data_cp[col_ws_cp_file].to_numpy()
         cp = data_cp[col_cp].to_numpy()
-        data_cp["P"] = 0.5 * rho * A * cp * ws**3 / FC.P_UNITS[FC.kW]
+        P_unit = pars.pop("P_unit", FC.kW)
+
+        ws_delta = 0.0001
+        ws_min = np.min(ws)
+        ws_max = np.max(ws)
+        N = int((ws_max - ws_min)/ws_delta)
+
+        data_P = pd.DataFrame(index=range(N), dtype=FC.DTYPE)
+        data_P["ws"] = np.linspace(ws_min, ws_max, N, endpoint=True)
+        data_P["cp"] = np.interp(data_P["ws"], ws, cp, left=0, right=0)
+        data_P["P"] = 0.5 * rho * A * data_P["cp"] * data_P["ws"]**3 / FC.P_UNITS[P_unit]
 
         super().__init__(
-            data_cp,
+            data_P,
             data_ct,
-            col_ws_P_file=col_ws_cp_file,
+            col_ws_P_file="ws",
             col_P="P",
             rho=rho,
-            P_unit=FC.kW,
+            P_unit=P_unit,
             **pars,
         )

foxes/models/vertical_profiles/abl_log_neutral_ws.py

@@ -8,10 +8,32 @@ class ABLLogNeutralWsProfile(VerticalProfile):
     """
     The neutral ABL wind speed log profile.
 
+    Attributes
+    ----------
+    ustar_input: bool
+        Flag for using ustar as an input
+
     :group: models.vertical_profiles
 
     """
 
+    def __init__(self, *args, ustar_input=False, **kwargs):
+        """
+        Constructor.
+        
+        Parameters
+        ----------
+        args: tuple, optional
+            Additional arguments for VerticalProfile
+        ustar_input: bool
+            Flag for using ustar as an input
+        kwargs: dict, optional
+            Additional arguments for VerticalProfile
+
+        """
+        super().__init__(*args, **kwargs)
+        self.ustar_input = ustar_input
+
     def input_vars(self):
         """
         The input variables needed for the profile
@@ -23,7 +45,10 @@ class ABLLogNeutralWsProfile(VerticalProfile):
             The variable names
 
         """
-        return [FV.WS, FV.H, FV.Z0]
+        if self.ustar_input:
+            return [FV.USTAR, FV.Z0]
+        else:
+            return [FV.WS, FV.H, FV.Z0]
 
     def calculate(self, data, heights):
         """
@@ -44,9 +69,11 @@ class ABLLogNeutralWsProfile(VerticalProfile):
 
         """
         z0 = data[FV.Z0]
-        h0 = data[FV.H]
-        ws = data[FV.WS]
-
-        ustar = neutral.ustar(ws, h0, z0, kappa=FC.KAPPA)
+        if self.ustar_input:
+            ustar = data[FV.USTAR]
+        else:
+            h0 = data[FV.H]
+            ws = data[FV.WS]
+            ustar = neutral.ustar(ws, h0, z0, kappa=FC.KAPPA)
 
         return neutral.calc_ws(heights, z0, ustar, kappa=FC.KAPPA)

foxes/models/vertical_profiles/abl_log_stable_ws.py

@@ -8,10 +8,32 @@ class ABLLogStableWsProfile(VerticalProfile):
     """
     The stable ABL wind speed log profile.
 
+    Attributes
+    ----------
+    ustar_input: bool
+        Flag for using ustar as an input
+
     :group: models.vertical_profiles
 
     """
 
+    def __init__(self, *args, ustar_input=False, **kwargs):
+        """
+        Constructor.
+        
+        Parameters
+        ----------
+        args: tuple, optional
+            Additional arguments for VerticalProfile
+        ustar_input: bool
+            Flag for using ustar as an input
+        kwargs: dict, optional
+            Additional arguments for VerticalProfile
+
+        """
+        super().__init__(*args, **kwargs)
+        self.ustar_input = ustar_input
+
     def input_vars(self):
         """
         The input variables needed for the profile
@@ -23,7 +45,10 @@ class ABLLogStableWsProfile(VerticalProfile):
             The variable names
 
         """
-        return [FV.WS, FV.H, FV.Z0, FV.MOL]
+        if self.ustar_input:
+            return [FV.USTAR, FV.Z0, FV.MOL]
+        else:
+            return [FV.WS, FV.H, FV.Z0, FV.MOL]
 
     def calculate(self, data, heights):
         """
@@ -43,12 +68,15 @@ class ABLLogStableWsProfile(VerticalProfile):
             shape as heights
 
         """
-        ws = data[FV.WS]
-        h0 = data[FV.H]
         z0 = data[FV.Z0]
         mol = data[FV.MOL]
 
-        ustar = stable.ustar(ws, h0, z0, mol, kappa=FC.KAPPA)
+        if self.ustar_input:
+            ustar = data[FV.USTAR]
+        else:
+            ws = data[FV.WS]
+            h0 = data[FV.H]
+            ustar = stable.ustar(ws, h0, z0, mol, kappa=FC.KAPPA)
         psi = stable.psi(heights, mol)
 
         return stable.calc_ws(heights, z0, ustar, psi, kappa=FC.KAPPA)

foxes/models/vertical_profiles/abl_log_unstable_ws.py

@@ -8,10 +8,32 @@ class ABLLogUnstableWsProfile(VerticalProfile):
     """
     The unstable ABL wind speed log profile.
 
+    Attributes
+    ----------
+    ustar_input: bool
+        Flag for using ustar as an input
+
     :group: models.vertical_profiles
 
     """
 
+    def __init__(self, *args, ustar_input=False, **kwargs):
+        """
+        Constructor.
+        
+        Parameters
+        ----------
+        args: tuple, optional
+            Additional arguments for VerticalProfile
+        ustar_input: bool
+            Flag for using ustar as an input
+        kwargs: dict, optional
+            Additional arguments for VerticalProfile
+
+        """
+        super().__init__(*args, **kwargs)
+        self.ustar_input = ustar_input
+
     def input_vars(self):
         """
         The input variables needed for the profile
@@ -23,7 +45,10 @@ class ABLLogUnstableWsProfile(VerticalProfile):
             The variable names
 
         """
-        return [FV.WS, FV.H, FV.Z0, FV.MOL]
+        if self.ustar_input:
+            return [FV.USTAR, FV.Z0, FV.MOL]
+        else:
+            return [FV.WS, FV.H, FV.Z0, FV.MOL]
 
     def calculate(self, data, heights):
         """
@@ -43,12 +68,15 @@ class ABLLogUnstableWsProfile(VerticalProfile):
             shape as heights
 
         """
-        ws = data[FV.WS]
-        h0 = data[FV.H]
         z0 = data[FV.Z0]
         mol = data[FV.MOL]
 
-        ustar = unstable.ustar(ws, h0, z0, mol, kappa=FC.KAPPA)
+        if self.ustar_input:
+            ustar = data[FV.USTAR]
+        else:
+            ws = data[FV.WS]
+            h0 = data[FV.H]
+            ustar = unstable.ustar(ws, h0, z0, mol, kappa=FC.KAPPA)
         psi = unstable.psi(heights, mol)
 
         return unstable.calc_ws(heights, z0, ustar, psi, kappa=FC.KAPPA)