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

foxes/models/wake_frames/timelines.py

@@ -4,6 +4,7 @@ from xarray import Dataset
 from foxes.core import WakeFrame, MData, FData, TData
 from foxes.utils import wd2uv
 from foxes.algorithms.iterative import Iterative
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -69,10 +70,16 @@ class Timelines(WakeFrame):
                 raise KeyError(
                     f"{self.name}: Expecting 'dt_min' for single step timeseries"
                 )
-            dt = (times[1:] - times[:-1]).astype("timedelta64[s]").astype(FC.ITYPE)
+            dt = (
+                (times[1:] - times[:-1])
+                .astype("timedelta64[s]")
+                .astype(config.dtype_int)
+            )
         else:
             n = max(len(times) - 1, 1)
-            dt = np.full(n, self.dt_min * 60, dtype="timedelta64[s]").astype(FC.ITYPE)
+            dt = np.full(n, self.dt_min * 60, dtype="timedelta64[s]").astype(
+                config.dtype_int
+            )
 
         # prepare mdata:
         data = algo.get_model_data(states)["coords"]
@@ -90,11 +97,11 @@ class Timelines(WakeFrame):
         # prepare tdata:
         n_states = states.size()
         data = {
-            v: np.zeros((n_states, 1, 1), dtype=FC.DTYPE)
+            v: np.zeros((n_states, 1, 1), dtype=config.dtype_double)
             for v in states.output_point_vars(algo)
         }
         pdims = {v: (FC.STATE, FC.TARGET, FC.TPOINT) for v in data.keys()}
-        points = np.zeros((n_states, 1, 3), dtype=FC.DTYPE)
+        points = np.zeros((n_states, 1, 3), dtype=config.dtype_double)
 
         # calculate all heights:
         self.timelines_data = {"dxy": (("height", FC.STATE, "dir"), [])}
@@ -175,7 +182,7 @@ class Timelines(WakeFrame):
         super().initialize(algo, verbosity)
 
         # find turbine hub heights:
-        t2h = np.zeros(algo.n_turbines, dtype=FC.DTYPE)
+        t2h = np.zeros(algo.n_turbines, dtype=config.dtype_double)
         for ti, t in enumerate(algo.farm.turbines):
             t2h[ti] = (
                 t.H if t.H is not None else algo.farm_controller.turbine_types[ti].H
@@ -285,7 +292,7 @@ class Timelines(WakeFrame):
             The turbine order, shape: (n_states, n_turbines)
 
         """
-        order = np.zeros((fdata.n_states, fdata.n_turbines), dtype=FC.ITYPE)
+        order = np.zeros((fdata.n_states, fdata.n_turbines), dtype=config.dtype_int)
         order[:] = np.arange(fdata.n_turbines)[None, :]
         return order
 
@@ -331,26 +338,26 @@ class Timelines(WakeFrame):
         heights = self.timelines_data["height"].to_numpy()
         data_dxy = self.timelines_data["dxy"].to_numpy()
 
-        D = np.zeros((n_states, n_points), dtype=FC.DTYPE)
+        D = np.zeros((n_states, n_points), dtype=config.dtype_double)
         D[:] = fdata[FV.D][:, downwind_index, None]
 
-        wcoos = np.full((n_states, n_points, 3), 1e20, dtype=FC.DTYPE)
+        wcoos = np.full((n_states, n_points, 3), 1e20, dtype=config.dtype_double)
         wcoosx = wcoos[:, :, 0]
         wcoosy = wcoos[:, :, 1]
         wcoos[:, :, 2] = points[:, :, 2] - rxyz[:, None, 2]
 
         i0 = mdata.states_i0(counter=True)
         i1 = i0 + mdata.n_states
-        trace_si = np.zeros((n_states, n_points), dtype=FC.ITYPE)
+        trace_si = np.zeros((n_states, n_points), dtype=config.dtype_int)
         trace_si[:] = i0 + np.arange(n_states)[:, None]
         for hi, h in enumerate(heights):
             dxy = data_dxy[hi][:i1]
             precond = theights[:, None] == h
 
-            trace_p = np.zeros((n_states, n_points, 2), dtype=FC.DTYPE)
+            trace_p = np.zeros((n_states, n_points, 2), dtype=config.dtype_double)
             trace_p[:] = points[:, :, :2] - rxyz[:, None, :2]
-            trace_l = np.zeros((n_states, n_points), dtype=FC.DTYPE)
-            trace_d = np.full((n_states, n_points), np.inf, dtype=FC.DTYPE)
+            trace_l = np.zeros((n_states, n_points), dtype=config.dtype_double)
+            trace_d = np.full((n_states, n_points), np.inf, dtype=config.dtype_double)
             h_trace_si = trace_si.copy()
 
             # flake8: noqa: F821
@@ -446,12 +453,12 @@ class Timelines(WakeFrame):
         heights = self.timelines_data["height"].to_numpy()
         data_dxy = self.timelines_data["dxy"].to_numpy()
 
-        points = np.zeros((n_states, n_points, 3), dtype=FC.DTYPE)
+        points = np.zeros((n_states, n_points, 3), dtype=config.dtype_double)
         points[:] = rxyz[:, None, :]
 
         trace_dp = np.zeros_like(points[..., :2])
         trace_l = x.copy()
-        trace_si = np.zeros((n_states, n_points), dtype=FC.ITYPE)
+        trace_si = np.zeros((n_states, n_points), dtype=config.dtype_int)
         trace_si[:] = np.arange(n_states)[:, None]
 
         for hi, h in enumerate(heights):

foxes/models/wake_frames/yawed_wakes.py

@@ -5,8 +5,10 @@ from foxes.models.wake_models.wind.bastankhah16 import (
     Bastankhah2016Model,
     Bastankhah2016,
 )
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
+
 from .rotor_wd import RotorWD
 
 
@@ -200,7 +202,7 @@ class YawedWakes(WakeFrame):
         if np.any(st_sel):
             # prepare:
             n_st_sel = np.sum(st_sel)
-            ydef = np.zeros((n_st_sel,), dtype=FC.DTYPE)
+            ydef = np.zeros((n_st_sel,), dtype=config.dtype_double)
 
             # collect data:
             near = self.model.get_data(Bastankhah2016Model.NEAR, mdata)

foxes/models/wake_models/induction/vortex_sheet.py

@@ -1,7 +1,6 @@
 import numpy as np
 
 from foxes.core import TurbineInductionModel
-from foxes.utils import uv2wd, wd2uv
 import foxes.variables as FV
 import foxes.constants as FC
 

foxes/models/wake_models/ti/crespo_hernandez.py

@@ -2,6 +2,7 @@ import numpy as np
 
 from foxes.core import WakeK
 from foxes.models.wake_models.top_hat import TopHatWakeModel
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -299,7 +300,7 @@ class CrespoHernandezTIWake(TopHatWakeModel):
         twoa = 2 * self.induction.ct2a(ct)
 
         # prepare output:
-        wake_deltas = np.zeros(n_targts, dtype=FC.DTYPE)
+        wake_deltas = np.zeros(n_targts, dtype=config.dtype_double)
 
         # calc near wake length, if not given
         if self.near_wake_D is None:

foxes/models/wake_models/wind/bastankhah14.py

@@ -2,6 +2,7 @@ import numpy as np
 
 from foxes.core import WakeK
 from foxes.models.wake_models.gaussian import GaussianWakeModel
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -187,7 +188,7 @@ class Bastankhah2014(GaussianWakeModel):
         else:
             st_sel = np.zeros_like(x, dtype=bool)
             n_sp = np.sum(st_sel)
-            ampld = np.zeros(n_sp, dtype=FC.DTYPE)
-            sigma = np.zeros(n_sp, dtype=FC.DTYPE)
+            ampld = np.zeros(n_sp, dtype=config.dtype_double)
+            sigma = np.zeros(n_sp, dtype=config.dtype_double)
 
         return {FV.WS: (ampld, sigma)}, st_sel

foxes/models/wake_models/wind/bastankhah16.py

@@ -2,6 +2,7 @@ import numpy as np
 
 from foxes.models.wake_models.dist_sliced import DistSlicedWakeModel
 from foxes.core import Model, WakeK
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -570,7 +571,7 @@ class Bastankhah2016(DistSlicedWakeModel):
         # select targets:
         st_sel = self.model.get_data(Bastankhah2016Model.ST_SEL, mdata)
         n_sp_sel = np.sum(st_sel)
-        wdeltas = {FV.WS: np.zeros((n_sp_sel, n_y_per_z), dtype=FC.DTYPE)}
+        wdeltas = {FV.WS: np.zeros((n_sp_sel, n_y_per_z), dtype=config.dtype_double)}
         if np.any(st_sel):
             # apply filter:
             yz = yz[st_sel]

foxes/models/wake_models/wind/turbopark.py

@@ -2,6 +2,7 @@ import numpy as np
 
 from foxes.core import WakeK
 from foxes.models.wake_models.gaussian import GaussianWakeModel
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -188,8 +189,7 @@ class TurbOParkWake(GaussianWakeModel):
                 fdata=fdata,
                 tdata=tdata,
                 downwind_index=downwind_index,
-                upcast=False,
-                selection=st_sel,
+                upcast=True,
             )
 
             # get k:
@@ -211,6 +211,7 @@ class TurbOParkWake(GaussianWakeModel):
             epsilon = self.sbeta_factor * np.sqrt(beta)
             del a, beta
 
+            ati = ati[st_sel]
             alpha = self.c1 * ati
             beta = self.c2 * ati / np.sqrt(ct)
 
@@ -218,7 +219,6 @@ class TurbOParkWake(GaussianWakeModel):
             sigma = D * (
                 epsilon
                 + k
-                * ati
                 / beta
                 * (
                     np.sqrt((alpha + beta * x / D) ** 2 + 1)
@@ -246,8 +246,8 @@ class TurbOParkWake(GaussianWakeModel):
         else:
             st_sel = np.zeros_like(x, dtype=bool)
             n_sp = np.sum(st_sel)
-            ampld = np.zeros(n_sp, dtype=FC.DTYPE)
-            sigma = np.zeros(n_sp, dtype=FC.DTYPE)
+            ampld = np.zeros(n_sp, dtype=config.dtype_double)
+            sigma = np.zeros(n_sp, dtype=config.dtype_double)
 
         return {FV.WS: (ampld, sigma)}, st_sel
 
@@ -318,6 +318,8 @@ class TurbOParkWakeIX(GaussianWakeModel):
         self.induction = induction
         self.wake_k = WakeK(**wake_k)
 
+        assert not self.wake_k.is_kTI, f"{self.name}: Cannot apply ka or ambka setup"
+
     def __repr__(self):
         iname = (
             self.induction if isinstance(self.induction, str) else self.induction.name
@@ -507,8 +509,8 @@ class TurbOParkWakeIX(GaussianWakeModel):
         else:
             st_sel = np.zeros_like(x, dtype=bool)
             n_sp = np.sum(st_sel)
-            ampld = np.zeros(n_sp, dtype=FC.DTYPE)
-            sigma = np.zeros(n_sp, dtype=FC.DTYPE)
+            ampld = np.zeros(n_sp, dtype=config.dtype_double)
+            sigma = np.zeros(n_sp, dtype=config.dtype_double)
 
         return {FV.WS: (ampld, sigma)}, st_sel
 

foxes/models/wake_superpositions/ws_product.py

@@ -2,7 +2,6 @@ import numpy as np
 
 from foxes.core import WakeSuperposition
 import foxes.variables as FV
-import foxes.constants as FC
 
 
 class WSProduct(WakeSuperposition):

foxes/output/__init__.py

@@ -6,7 +6,7 @@ from .round import round_defaults
 from .output import Output
 from .farm_layout import FarmLayoutOutput
 from .farm_results_eval import FarmResultsEval
-from .rose_plot import RosePlotOutput, StatesRosePlotOutput
+from .rose_plot import RosePlotOutput, StatesRosePlotOutput, WindRoseBinPlot
 from .results_writer import ResultsWriter
 from .state_turbine_map import StateTurbineMap
 from .turbine_type_curves import TurbineTypeCurves
@@ -15,6 +15,7 @@ from .calc_points import PointCalculator
 from .slice_data import SliceData
 from .rotor_point_plots import RotorPointPlot
 from .state_turbine_table import StateTurbineTable
+from .plt import plt
 
 from .flow_plots_2d import FlowPlots2D
 from .seq_plugins import SeqFlowAnimationPlugin, SeqWakeDebugPlugin

foxes/output/calc_points.py

@@ -1,9 +1,10 @@
 import numpy as np
 from xarray import Dataset
 
-import foxes.constants as FC
-import foxes.variables as FV
+from foxes.config import config
 from foxes.utils import write_nc
+import foxes.variables as FV
+import foxes.constants as FC
 
 from .output import Output
 
@@ -67,7 +68,7 @@ class PointCalculator(Output):
         weight_turbine: int, optional
             Index of the turbine from which to take the weight
         to_file: str, optional
-            Path to the output netCDF file
+            The output netCDF file name
         write_vars: list of str
             The variables to be written to file, or None
             for all
@@ -87,7 +88,9 @@ class PointCalculator(Output):
             pts = points
             p_has_s = True
         elif points.shape[-1] == 3 and len(points.shape) == 2:
-            pts = np.zeros([self.algo.n_states] + list(points.shape), dtype=FC.DTYPE)
+            pts = np.zeros(
+                [self.algo.n_states] + list(points.shape), dtype=config.dtype_double
+            )
             pts[:] = points[None, :]
             p_has_s = False
         else:

foxes/output/farm_layout.py

@@ -4,7 +4,7 @@ import pandas as pd
 import matplotlib.pyplot as plt
 from mpl_toolkits.axes_grid1 import make_axes_locatable
 
-import foxes.constants as FC
+from foxes.config import config
 import foxes.variables as FV
 from foxes.output.output import Output
 
@@ -31,7 +31,13 @@ class FarmLayoutOutput(Output):
     """
 
     def __init__(
-        self, farm, farm_results=None, from_results=False, results_state=None, D=None
+        self,
+        farm,
+        farm_results=None,
+        from_results=False,
+        results_state=None,
+        D=None,
+        **kwargs,
     ):
         """
         Constructor.
@@ -48,8 +54,11 @@ class FarmLayoutOutput(Output):
             The state index, for from_res
         D: float, optional
             The rotor diameter, if not from data
+        kwargs: dict, optional
+            Additional parameters for the base class
 
         """
+        super().__init__(**kwargs)
         self.farm = farm
         self.fres = farm_results
         self.from_res = from_results
@@ -75,7 +84,7 @@ class FarmLayoutOutput(Output):
 
         """
 
-        data = np.zeros([self.farm.n_turbines, 3], dtype=FC.DTYPE)
+        data = np.zeros([self.farm.n_turbines, 3], dtype=config.dtype_double)
 
         if self.from_res:
             data[:, 0] = self.fres[FV.X][self.rstate]
@@ -284,14 +293,14 @@ class FarmLayoutOutput(Output):
 
         return ax
 
-    def write_plot(self, file_path=None, fontsize=8, **kwargs):
+    def write_plot(self, file_name=None, fontsize=8, **kwargs):
         """
         Writes the layout plot to file.
 
         Parameters
         ----------
-        file_path: str
-            The file into which to plot, or None
+        file_name: str
+            Name of the file into which to plot, or None
             for default
         fontsize: int
             Size of the turbine numbers
@@ -303,8 +312,9 @@ class FarmLayoutOutput(Output):
         ax = self.get_figure(fontsize=fontsize, ret_im=False, **kwargs)
         fig = ax.get_figure()
 
-        fname = file_path if file_path is not None else self.farm.name + ".png"
-        fig.savefig(fname, bbox_inches="tight")
+        fname = file_name if file_name is not None else self.farm.name + ".png"
+        fpath = self.get_fpath(fname)
+        fig.savefig(fpath, bbox_inches="tight")
 
         plt.close(fig)
 
@@ -325,14 +335,14 @@ class FarmLayoutOutput(Output):
         fname = file_path if file_path is not None else self.farm.name + ".xyh"
         np.savetxt(fname, data, header="x y h")
 
-    def write_csv(self, file_path=None, type_col=None, algo=None):
+    def write_csv(self, file_name=None, type_col=None, algo=None):
         """
         Writes csv layout file.
 
         Parameters
         ----------
-        file_path: str
-            The file into which to plot, or None
+        file_name: str
+            Name of the file into which to plot, or None
             for default
         type_col: str, optional
             Name of the turbine type column
@@ -343,7 +353,8 @@ class FarmLayoutOutput(Output):
 
         data = self.get_layout_data()
 
-        fname = file_path if file_path is not None else self.farm.name + ".csv"
+        fname = file_name if file_name is not None else self.farm.name + ".csv"
+        fpath = self.get_fpath(fname)
 
         lyt = pd.DataFrame(index=range(len(data)), columns=["name", "x", "y", "h", "D"])
         lyt.index.name = "index"
@@ -356,22 +367,23 @@ class FarmLayoutOutput(Output):
         if type_col is not None:
             lyt[type_col] = [m.name for m in algo.farm_controller.turbine_types]
 
-        lyt.to_csv(fname)
+        lyt.to_csv(fpath)
 
-    def write_json(self, file_path=None):
+    def write_json(self, file_name=None):
         """
         Writes xyh layout file.
 
         Parameters
         ----------
-        file_path: str
-            The file into which to plot, or None
+        file_name: str
+            Name of the file into which to plot, or None
             for default
 
         """
 
         data = self.get_layout_dict()
 
-        fname = file_path if file_path is not None else self.farm.name + ".json"
-        with open(fname, "w") as outfile:
+        fname = file_name if file_name is not None else self.farm.name + ".json"
+        fpath = self.get_fpath(fname)
+        with open(fpath, "w") as outfile:
             json.dump(data, outfile, indent=4)