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

foxes/models/wake_superpositions/ws_pow.py

@@ -145,8 +145,8 @@ class WSPow(WakeSuperposition):
         algo,
         mdata,
         fdata,
+        tdata,
         variable,
-        amb_results,
         wake_delta,
     ):
         """
@@ -161,11 +161,10 @@ class WSPow(WakeSuperposition):
             The model data
         fdata: foxes.core.FData
             The farm data
+        tdata: foxes.core.TData
+            The target point data
         variable: str
             The variable name for which the wake deltas applies
-        amb_results: numpy.ndarray
-            The ambient results at targets,
-            shape: (n_states, n_targets, n_tpoints)
         wake_delta: numpy.ndarray
             The wake deltas at targets, shape:
             (n_states, n_targets, n_tpoints)
@@ -178,6 +177,7 @@ class WSPow(WakeSuperposition):
             (n_states, n_targets, n_tpoints)
 
         """
+        amb_results = tdata[FV.var2amb[variable]]
         w = -(wake_delta ** (1 / self.pow))
         if self.lim_low is not None:
             w = np.maximum(w, self.lim_low - amb_results)
@@ -307,8 +307,8 @@ class WSPowLocal(WakeSuperposition):
         algo,
         mdata,
         fdata,
+        tdata,
         variable,
-        amb_results,
         wake_delta,
     ):
         """
@@ -323,11 +323,10 @@ class WSPowLocal(WakeSuperposition):
             The model data
         fdata: foxes.core.FData
             The farm data
+        tdata: foxes.core.TData
+            The target point data
         variable: str
             The variable name for which the wake deltas applies
-        amb_results: numpy.ndarray
-            The ambient results at targets,
-            shape: (n_states, n_targets, n_tpoints)
         wake_delta: numpy.ndarray
             The wake deltas at targets, shape:
             (n_states, n_targets, n_tpoints)
@@ -340,6 +339,7 @@ class WSPowLocal(WakeSuperposition):
             (n_states, n_targets, n_tpoints)
 
         """
+        amb_results = tdata[FV.var2amb[variable]]
         w = -(wake_delta ** (1 / self.pow)) * amb_results
         if self.lim_low is not None:
             w = np.maximum(w, self.lim_low - amb_results)

foxes/models/wake_superpositions/ws_product.py

@@ -131,8 +131,8 @@ class WSProduct(WakeSuperposition):
         algo,
         mdata,
         fdata,
+        tdata,
         variable,
-        amb_results,
         wake_delta,
     ):
         """
@@ -147,11 +147,10 @@ class WSProduct(WakeSuperposition):
             The model data
         fdata: foxes.core.FData
             The farm data
+        tdata: foxes.core.TData
+            The target point data
         variable: str
             The variable name for which the wake deltas applies
-        amb_results: numpy.ndarray
-            The ambient results at targets,
-            shape: (n_states, n_targets, n_tpoints)
         wake_delta: numpy.ndarray
             The wake deltas at targets, shape:
             (n_states, n_targets, n_tpoints)
@@ -164,6 +163,7 @@ class WSProduct(WakeSuperposition):
             (n_states, n_targets, n_tpoints)
 
         """
+        amb_results = tdata[FV.var2amb[variable]]
         w = amb_results * (wake_delta - 1)
         if self.lim_low is not None:
             w = np.maximum(w, self.lim_low - amb_results)

foxes/models/wake_superpositions/ws_quadratic.py

@@ -140,8 +140,8 @@ class WSQuadratic(WakeSuperposition):
         algo,
         mdata,
         fdata,
+        tdata,
         variable,
-        amb_results,
         wake_delta,
     ):
         """
@@ -156,11 +156,10 @@ class WSQuadratic(WakeSuperposition):
             The model data
         fdata: foxes.core.FData
             The farm data
+        tdata: foxes.core.TData
+            The target point data
         variable: str
             The variable name for which the wake deltas applies
-        amb_results: numpy.ndarray
-            The ambient results at targets,
-            shape: (n_states, n_targets, n_tpoints)
         wake_delta: numpy.ndarray
             The wake deltas at targets, shape:
             (n_states, n_targets, n_tpoints)
@@ -173,6 +172,7 @@ class WSQuadratic(WakeSuperposition):
             (n_states, n_targets, n_tpoints)
 
         """
+        amb_results = tdata[FV.var2amb[variable]]
         w = -np.sqrt(wake_delta)
         if self.lim_low is not None:
             w = np.maximum(w, self.lim_low - amb_results)
@@ -296,8 +296,8 @@ class WSQuadraticLocal(WakeSuperposition):
         algo,
         mdata,
         fdata,
+        tdata,
         variable,
-        amb_results,
         wake_delta,
     ):
         """
@@ -312,11 +312,10 @@ class WSQuadraticLocal(WakeSuperposition):
             The model data
         fdata: foxes.core.FData
             The farm data
+        tdata: foxes.core.TData
+            The target point data
         variable: str
             The variable name for which the wake deltas applies
-        amb_results: numpy.ndarray
-            The ambient results at targets,
-            shape: (n_states, n_targets, n_tpoints)
         wake_delta: numpy.ndarray
             The wake deltas at targets, shape:
             (n_states, n_targets, n_tpoints)
@@ -329,6 +328,7 @@ class WSQuadraticLocal(WakeSuperposition):
             (n_states, n_targets, n_tpoints)
 
         """
+        amb_results = tdata[FV.var2amb[variable]]
         w = -np.sqrt(wake_delta) * amb_results
         if self.lim_low is not None:
             w = np.maximum(w, self.lim_low - amb_results)

foxes/output/__init__.py

@@ -2,24 +2,26 @@
 Output tools and functions.
 """
 
-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, WindRoseBinPlot
-from .results_writer import ResultsWriter
-from .state_turbine_map import StateTurbineMap
-from .turbine_type_curves import TurbineTypeCurves
-from .animation import Animator
-from .calc_points import PointCalculator
-from .slice_data import SliceData
-from .slices_data import SlicesData
-from .rotor_point_plots import RotorPointPlot
-from .state_turbine_table import StateTurbineTable
-from .plt import plt
+from .output import Output as Output
+from .farm_layout import FarmLayoutOutput as FarmLayoutOutput
+from .farm_results_eval import FarmResultsEval as FarmResultsEval
+from .rose_plot import RosePlotOutput as RosePlotOutput
+from .rose_plot import StatesRosePlotOutput as StatesRosePlotOutput
+from .rose_plot import WindRoseBinPlot as WindRoseBinPlot
+from .results_writer import ResultsWriter as ResultsWriter
+from .state_turbine_map import StateTurbineMap as StateTurbineMap
+from .turbine_type_curves import TurbineTypeCurves as TurbineTypeCurves
+from .animation import Animator as Animator
+from .calc_points import PointCalculator as PointCalculator
+from .slice_data import SliceData as SliceData
+from .slices_data import SlicesData as SlicesData
+from .rotor_point_plots import RotorPointPlot as RotorPointPlot
+from .state_turbine_table import StateTurbineTable as StateTurbineTable
+from .plt import plt as plt
 
-from .flow_plots_2d import FlowPlots2D
-from .seq_plugins import SeqFlowAnimationPlugin, SeqWakeDebugPlugin
+from .flow_plots_2d import FlowPlots2D as FlowPlots2D
+from .seq_plugins import SeqFlowAnimationPlugin as SeqFlowAnimationPlugin
+from .seq_plugins import SeqWakeDebugPlugin as SeqWakeDebugPlugin
 
-from . import grids
-from . import seq_plugins
+from . import grids as grids
+from . import seq_plugins as seq_plugins

foxes/output/farm_layout.py

@@ -67,10 +67,10 @@ class FarmLayoutOutput(Output):
         self.D = D
 
         if from_results and farm_results is None:
-            raise ValueError(f"Missing farm_results for switch from_results.")
+            raise ValueError("Missing farm_results for switch from_results.")
 
         if from_results and results_state is None:
-            raise ValueError(f"Please specify results_state for switch from_results.")
+            raise ValueError("Please specify results_state for switch from_results.")
 
     def get_layout_data(self):
         """

foxes/output/farm_results_eval.py

@@ -66,9 +66,9 @@ class FarmResultsEval(Output):
             if isinstance(v, str):
                 vdata = self.results[v].to_numpy()
                 nns = np.sum(np.isnan(vdata))
-                assert (
-                    nns == 0
-                ), f"Found {nns} nan values for variable '{v}' of shape {vdata.shape}"
+                assert nns == 0, (
+                    f"Found {nns} nan values for variable '{v}' of shape {vdata.shape}"
+                )
                 fields.append(vdata)
             else:
                 fields.append(v)
@@ -142,9 +142,9 @@ class FarmResultsEval(Output):
         for v, op in vars_op.items():
             vdata = self.results[v].to_numpy()
             nns = np.sum(np.isnan(vdata))
-            assert (
-                nns == 0
-            ), f"Found {nns} nan values for variable '{v}' of shape {vdata.shape}"
+            assert nns == 0, (
+                f"Found {nns} nan values for variable '{v}' of shape {vdata.shape}"
+            )
 
             if op == "weights":
                 rdata[v] = self.weinsum("t", vdata)
@@ -191,9 +191,9 @@ class FarmResultsEval(Output):
         for v, op in vars_op.items():
             vdata = self.results[v].to_numpy()
             nns = np.sum(np.isnan(vdata))
-            assert (
-                nns == 0
-            ), f"Found {nns} nan values for variable '{v}' of shape {vdata.shape}"
+            assert nns == 0, (
+                f"Found {nns} nan values for variable '{v}' of shape {vdata.shape}"
+            )
 
             if op == "weights":
                 rdata[v] = self.weinsum("s", vdata)
@@ -244,9 +244,9 @@ class FarmResultsEval(Output):
         for v, op in turbines_op.items():
             vdata = sdata[v].to_numpy()
             nns = np.sum(np.isnan(vdata))
-            assert (
-                nns == 0
-            ), f"Found {nns} nan values for variable '{v}' of shape {vdata.shape}"
+            assert nns == 0, (
+                f"Found {nns} nan values for variable '{v}' of shape {vdata.shape}"
+            )
 
             if op == "weights":
                 if states_op[v] == "weights":
@@ -471,11 +471,11 @@ class FarmResultsEval(Output):
             duration = times[-1] - times[0] + delta_t
             duration_seconds = np.int64(duration.astype(np.int64) / 1e9)
             duration_hours = duration_seconds / 3600
-        elif hours is None and annual == True:
+        elif hours is None and annual:
             duration_hours = 8760
         elif hours is None:
             raise ValueError(
-                f"Expecting parameter 'hours' for non-timeseries data, or 'annual=True'"
+                "Expecting parameter 'hours' for non-timeseries data, or 'annual=True'"
             )
         else:
             duration_hours = hours
@@ -654,7 +654,7 @@ class FarmResultsEval(Output):
         else:
             hax = ax
 
-        hax.set_xlabel(f"State")
+        hax.set_xlabel("State")
         hax.set_ylabel(variable)
         cc = cycler(color="bgrcmyk")
 

foxes/output/flow_plots_2d/__init__.py

@@ -1,2 +1,2 @@
-from .flow_plots import FlowPlots2D
-from .get_fig import get_fig
+from .flow_plots import FlowPlots2D as FlowPlots2D
+from .get_fig import get_fig as get_fig

foxes/output/flow_plots_2d/get_fig.py

@@ -181,6 +181,7 @@ def get_fig(
         hax.invert_yaxis()
 
     # add rotor position:
+    imr = []
     if show_rotor_dict is not None:
         D = show_rotor_dict["D"]
         coords = np.zeros(shape=(2, len(D)))  # array to hold change to turbine coords
@@ -211,12 +212,13 @@ def get_fig(
             turb_x2 = x[t] - coords[0, t]
             turb_y1 = y[t] + coords[1, t]
             turb_y2 = y[t] - coords[1, t]
-            hax.plot(
+            imr += hax.plot(
                 [turb_x1, turb_x2],
                 [turb_y1, turb_y2],
                 color=c,
                 linestyle="-",
                 linewidth=1,
+                animated=animated,
             )
 
     if add_bar:
@@ -233,7 +235,7 @@ def get_fig(
     if ret_state:
         out.append(si)
     if ret_im:
-        out.append([i for i in [im, qv, ttl] if i is not None])
+        out.append([i for i in [im, qv, ttl] if i is not None] + imr)
     if ret_state or ret_im:
         out = tuple(out)
 

foxes/output/rose_plot.py

@@ -1,7 +1,6 @@
 import numpy as np
 import matplotlib.pyplot as plt
 from xarray import Dataset
-from matplotlib.cm import ScalarMappable
 from matplotlib.projections.polar import PolarAxes
 from matplotlib.lines import Line2D
 
@@ -58,7 +57,7 @@ class RosePlotOutput(Output):
             self.results = farm_results
             self._rtype = FC.TURBINE
         else:
-            raise KeyError(f"Require either farm_results or point_results")
+            raise KeyError("Require either farm_results or point_results")
 
     @classmethod
     def get_data_info(cls, dname):
@@ -296,7 +295,8 @@ class RosePlotOutput(Output):
 
         llines = [Line2D([0], [0], color=c, lw=10) for c in np.flip(color_list, axis=0)]
         lleg = [
-            f"[{ws_bins[i]:.1f}, {ws_bins[i+1]:.1f})" for i in range(n_wsb - 1, -1, -1)
+            f"[{ws_bins[i]:.1f}, {ws_bins[i + 1]:.1f})"
+            for i in range(n_wsb - 1, -1, -1)
         ]
         lpars = dict(
             loc="upper left",

foxes/output/seq_plugins/__init__.py

@@ -1,2 +1,2 @@
-from .seq_flow_ani_plugin import SeqFlowAnimationPlugin
-from .seq_wake_debug_plugin import SeqWakeDebugPlugin
+from .seq_flow_ani_plugin import SeqFlowAnimationPlugin as SeqFlowAnimationPlugin
+from .seq_wake_debug_plugin import SeqWakeDebugPlugin as SeqWakeDebugPlugin

foxes/output/seq_plugins/seq_flow_ani_plugin.py

@@ -1,5 +1,3 @@
-from copy import deepcopy
-
 from foxes.algorithms.sequential import SequentialPlugin
 
 from ..flow_plots_2d.flow_plots import FlowPlots2D
@@ -116,7 +114,6 @@ class SeqFlowAnimationPlugin(SequentialPlugin):
         fig = ax.get_figure()
         gdata = None
         while len(self._data):
-
             fres, d = self._data.pop(0)
 
             if d[2] is not None:

foxes/output/seq_plugins/seq_wake_debug_plugin.py

@@ -109,7 +109,6 @@ class SeqWakeDebugPlugin(SequentialPlugin):
 
         """
         while len(self._data):
-
             dt, pts, v = self._data.pop(0)
 
             N = len(pts)

foxes/output/turbine_type_curves.py

@@ -1,4 +1,3 @@
-from tabnanny import verbose
 import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
@@ -182,19 +181,19 @@ class TurbineTypeCurves(Output):
             t = f"{vv}, {turbine_type}" if titles[i] is None else titles[i]
             ax.set_title(t)
 
-            l = "Wind speed [m/s]" if x_label is None else x_label
-            ax.set_xlabel(l)
+            lb = "Wind speed [m/s]" if x_label is None else x_label
+            ax.set_xlabel(lb)
 
             if y_labels[i] is None:
                 if v == FV.P:
-                    l = f"Power [kW]"
+                    lb = "Power [kW]"
                 elif v == FV.CT:
-                    l = "ct [-]"
+                    lb = "ct [-]"
                 else:
-                    l = v
+                    lb = v
             else:
-                l = y_labels[i]
-            ax.set_ylabel(l)
+                lb = y_labels[i]
+            ax.set_ylabel(lb)
 
             ax.grid()
 

foxes/utils/__init__.py

@@ -2,23 +2,41 @@
 General utilities.
 """
 
-from .wind_dir import wd2uv, wd2wdvec, wdvec2wd, uv2wd, delta_wd
-from .pandas_utils import PandasFileHelper
-from .xarray_utils import write_nc
-from .subclasses import all_subclasses, new_cls, new_instance
-from .dict import Dict
-from .factory import Factory, FDict, WakeKFactory
-from .data_book import DataBook
-from .cubic_roots import cubic_roots
-from .geopandas_utils import read_shp, shp2csv, read_shp_polygons, shp2geom2d
-from .load import import_module, load_module
-from .exec_python import exec_python
-from .regularize import sqrt_reg
-from .tab_files import read_tab_file
-from .random_xy import random_xy_square
-from .dev_utils import print_mem
-from .wrg_utils import ReaderWRG
+from .wind_dir import wd2uv as wd2uv
+from .wind_dir import wd2wdvec as wd2wdvec
+from .wind_dir import wdvec2wd as wdvec2wd
+from .wind_dir import uv2wd as uv2wd
+from .wind_dir import delta_wd as delta_wd
 
-from . import two_circles
-from . import abl
-from . import geom2d
+from .subclasses import all_subclasses as all_subclasses
+from .subclasses import new_cls as new_cls
+from .subclasses import new_instance as new_instance
+
+from .factory import Factory as Factory
+from .factory import FDict as FDict
+from .factory import WakeKFactory as WakeKFactory
+
+from .geopandas_utils import read_shp as read_shp
+from .geopandas_utils import shp2csv as shp2csv
+from .geopandas_utils import read_shp_polygons as read_shp_polygons
+from .geopandas_utils import shp2geom2d as shp2geom2d
+
+from .load import import_module as import_module
+from .load import load_module as load_module
+
+from .pandas_utils import PandasFileHelper as PandasFileHelper
+from .xarray_utils import write_nc as write_nc
+from .dict import Dict as Dict
+from .data_book import DataBook as DataBook
+from .cubic_roots import cubic_roots as cubic_roots
+from .exec_python import exec_python as exec_python
+from .regularize import sqrt_reg as sqrt_reg
+from .tab_files import read_tab_file as read_tab_file
+from .random_xy import random_xy_square as random_xy_square
+from .dev_utils import print_mem as print_mem
+from .wrg_utils import ReaderWRG as ReaderWRG
+from .weibull import weibull_weights as weibull_weights
+
+from . import two_circles as two_circles
+from . import abl as abl
+from . import geom2d as geom2d

foxes/utils/abl/__init__.py

@@ -2,7 +2,7 @@
 Atmospheric boundary layer functions.
 """
 
-from . import neutral
-from . import stable
-from . import unstable
-from . import sheared
+from . import neutral as neutral
+from . import stable as stable
+from . import unstable as unstable
+from . import sheared as sheared

foxes/utils/cubic_roots.py

@@ -104,7 +104,7 @@ def test_cubic_roots(roots, a0, a1, a2, a3=None, tol=1.0e-12):
         c2 = a2[n]
         c3 = a3[n]
 
-        print(f"Polynomial {n}: a = {(c0,c1,c2,c3)}")
+        print(f"Polynomial {n}: a = {(c0, c1, c2, c3)}")
 
         rts = np.unique(roots[n])
         rts = rts[~np.isnan(rts)]

foxes/utils/data_book.py

@@ -66,9 +66,10 @@ class DataBook:
         except AttributeError:
             contents = list(resources.contents(package))
 
-        check_f = lambda f: any(
-            [len(f) > len(s) and f[-len(s) :] == s for s in file_sfx]
-        )
+        def check_f(f):
+            """little helper function to check file endings"""
+            return any([len(f) > len(s) and f[-len(s) :] == s for s in file_sfx])
+
         contents = [f for f in contents if check_f(f)]
 
         try:

foxes/utils/dict.py

@@ -77,9 +77,9 @@ class Dict(dict):
         """
         try:
             if len(deflt):
-                assert (
-                    len(deflt) == 1
-                ), f"Expecting a single default entry, got {len(deflt)}"
+                assert len(deflt) == 1, (
+                    f"Expecting a single default entry, got {len(deflt)}"
+                )
                 data = self.get(key, deflt[0])
             else:
                 data = self[key]

foxes/utils/exec_python.py

@@ -1,7 +1,7 @@
-import numpy as np
-import pandas as pd
-import xarray as xr
-import matplotlib.pyplot as plt
+import numpy as np  # noqa: F401
+import pandas as pd  # noqa: F401
+import xarray as xr  # noqa: F401
+import matplotlib.pyplot as plt  # noqa: F401
 
 
 def exec_python(s, indicator="%", newline=";", globals=globals(), locals={}):
@@ -38,7 +38,7 @@ def exec_python(s, indicator="%", newline=";", globals=globals(), locals={}):
         L = len(indicator)
         if len(s) > L and s[:L] == indicator:
             a = s[L:]
-            if not indicator in a:
+            if indicator not in a:
                 exec(a, globals, locals)
             else:
                 ilist = a.split(indicator)

foxes/utils/factory.py

@@ -526,9 +526,7 @@ class WakeKFactory:
                 s += f"\n  {v} from {list(f0.options[v])}"
             else:
                 s += f"\n  {v}={f0.hints.get(v, '(value)')}"
-        s += (
-            f"\n  [wake_k]=(None or k<k> or ka<ka> or ka<ka>_kb<kb>, e.g. 004 for 0.04)"
-        )
+        s += "\n  [wake_k]=(None or k<k> or ka<ka> or ka<ka>_kb<kb>, e.g. 004 for 0.04)"
         return s
 
 

foxes/utils/geom2d/__init__.py

@@ -2,8 +2,10 @@
 Geometries in two dimensions.
 """
 
-from .area_geometry import AreaGeometry, InvertedAreaGeometry
-from .area_geometry import AreaUnion, AreaIntersection
-from .polygon import ClosedPolygon
-from .circle import Circle
-from .half_plane import HalfPlane
+from .area_geometry import AreaGeometry as AreaGeometry
+from .area_geometry import InvertedAreaGeometry as InvertedAreaGeometry
+from .area_geometry import AreaUnion as AreaUnion
+from .area_geometry import AreaIntersection as AreaIntersection
+from .polygon import ClosedPolygon as ClosedPolygon
+from .circle import Circle as Circle
+from .half_plane import HalfPlane as HalfPlane

foxes/utils/geopandas_utils.py

@@ -179,7 +179,7 @@ def read_shp_polygons(
     utmz = None
     utml = None
     apply_utm = False
-    if isinstance(to_utm, str) or to_utm == True:
+    if isinstance(to_utm, str) or to_utm:
         apply_utm = True
         check_import_utm()
         utmz = int(to_utm[:-1]) if isinstance(to_utm, str) else None
@@ -190,7 +190,7 @@ def read_shp_polygons(
     names = pnames if names is None else names
     for name in names:
         if name == name:  # exclude nan values
-            if not name in pnames:
+            if name not in pnames:
                 raise KeyError(
                     f"Name '{name}' not found in file '{fname}'. Names: {pnames}"
                 )

foxes/utils/pandas_utils.py

@@ -106,9 +106,10 @@ class PandasFileHelper:
             elif sfx == "h5":
                 f = pd.read_hdf
             elif sfx == "nc":
-                f = lambda fname, **pars: xarray.open_dataset(
-                    fname, **pars
-                ).to_dataframe()
+
+                def f(fname, **pars):
+                    """little helper to read netcdf files"""
+                    return xarray.open_dataset(fname, **pars).to_dataframe()
 
             if f is not None:
                 pars = deepcopy(cls.DEFAULT_READING_PARAMETERS[fmt])

foxes/utils/tab_files.py

@@ -63,7 +63,6 @@ def read_tab_file(fname, normalize=True):
 
 
 if __name__ == "__main__":
-
     import argparse
 
     parser = argparse.ArgumentParser()

foxes/utils/weibull.py

@@ -0,0 +1,28 @@
+import numpy as np
+
+
+def weibull_weights(ws, ws_deltas, A, k):
+    """
+    Computes the weibull weights for given wind speeds
+
+    Parameters
+    ----------
+    ws: numpy.ndarray
+        The wind speed bin centre values
+    ws_deltas: numpy.ndarray
+        The wind speed bin widths, same shape as ws
+    A: numpy.ndarray
+        The Weibull scale parameters, same shape as ws
+    k: numpy.ndarray
+        The Weibull shape parameters, same shape as ws
+
+    Returns
+    -------
+    weights: numpy.ndarray
+        The weights, same shape as ws
+
+    :group: utils
+
+    """
+    wsA = ws / A
+    return ws_deltas * (k / A * wsA ** (k - 1) * np.exp(-(wsA**k)))