foxes 0.6.1__py3-none-any.whl → 0.7__py3-none-any.whl

foxes/output/rose_plot.py

@@ -33,7 +33,7 @@ class RosePlotOutput(Output):
             The calculation results (farm or points)
 
         """
-        dims = list(results.dims.keys())
+        dims = list(results.sizes.keys())
         if dims[1] == FC.TURBINE:
             self._rtype = FC.TURBINE
         elif dims[1] == FC.POINT:
@@ -170,7 +170,7 @@ class RosePlotOutput(Output):
         data[wd_var] = pd.cut(data["wd"], wdb, labels=wds)
         data[lgd] = pd.cut(data[lgd], var_bins, right=False, include_lowest=True)
 
-        grp = data[[wd_var, lgd, "frequency"]].groupby([wd_var, lgd])
+        grp = data[[wd_var, lgd, "frequency"]].groupby([wd_var, lgd], observed=False)
         data = grp.sum().reset_index()
 
         data[wd_var] = data[wd_var].astype(np.float64)
@@ -386,7 +386,7 @@ class StatesRosePlotOutput(RosePlotOutput):
         )
 
         mbook = mbook if mbook is not None else ModelBook()
-        algo = Downwind(mbook, farm, states, wake_models=[], verbosity=0)
+        algo = Downwind(farm, states, wake_models=[], mbook=mbook, verbosity=0)
 
         results = algo.calc_farm(ambient=True).rename_vars({ws_var: FV.AMB_WS})
 

foxes/output/rotor_point_plots.py

@@ -0,0 +1,117 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib import colormaps
+from matplotlib.colors import LinearSegmentedColormap
+
+from foxes.input.states import SingleStateStates
+from foxes.core import WindFarm
+from foxes.algorithms import Downwind
+
+
+class RotorPointPlot:
+    """
+    Visualizes rotor points and their weights.
+
+    Attributes
+    ----------
+    rotor_model: foxes.core.RotorModel
+        The rotor model
+    algo: foxes.core.Algorithm, optional
+        The algorithm
+
+    :group: output
+
+    """
+
+    def __init__(self, rotor_model, algo=None):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        rotor_model: foxes.core.RotorModel
+            The rotor model
+        algo: foxes.core.Algorithm, optional
+            The algorithm
+
+        """
+        self.rotor_model = rotor_model
+        self.algo = algo
+
+        if self.algo is None:
+            farm = WindFarm()
+            states = SingleStateStates(ws=9, wd=270, ti=0.1, rho=1.225)
+            self.algo = Downwind(farm, states, [])
+
+    def get_point_figure(
+        self,
+        ax=None,
+        fig=None,
+        figsize=(5, 5),
+        title=None,
+        **kwargs,
+    ):
+        """
+        Get a scatter plot of the rotor points.
+
+        Parameters
+        ----------
+        ax: matplotlib.Axes, optional
+            The plot axes
+        fig: matplotlib.Figure, optional
+            The figure object
+        figsize: tuple
+            The default figure size
+        title: str, optional
+            The plot title
+        kwargs: dict, optional
+            Additional arguments for pyplot.scatter
+
+        Returns
+        -------
+        ax: matplotlib.Axes
+            The plot axes
+
+        """
+        if fig is None:
+            fig = plt.figure(figsize=figsize)
+            ax = fig.add_subplot(111)
+        else:
+            ax = fig.axes[0] if ax is None else ax
+
+        if not self.rotor_model.initialized:
+            self.rotor_model.initialize(self.algo)
+
+        points = self.rotor_model.design_points()
+        weights = self.rotor_model.rotor_point_weights() * 100
+
+        cmap = colormaps[kwargs.pop("cmap", "viridis_r")]
+        wlist = np.sort(np.unique(weights))
+
+        im = ax.scatter(points[:, 1], points[:, 2], c=weights, cmap=cmap, **kwargs)
+        ax.add_patch(plt.Circle((0, 0), 1, color="black", fill=False, alpha=0.8))
+
+        ax.set_xlabel("x/D")
+        ax.set_ylabel("y/D")
+        if title is None:
+            title = str(self.rotor_model)
+        if title != "":
+            ax.set_title(title)
+        ax.set_aspect("equal", adjustable="box")
+
+        tlabels = [f"{wlist[-1]:.02f}"]
+        for i in range(len(wlist) - 2, -1, -1):
+            w = wlist[i]
+            w1 = wlist[i + 1]
+            if (w1 - w) / (wlist[-1] - wlist[0]) > 0.05:
+                tlabels.insert(0, f"{w:.2f}")
+            elif i == 0:
+                tlabels[0] = ""
+                tlabels.insert(0, f"{w:.2f}")
+            else:
+                tlabels.insert(0, "")
+
+        cbar = fig.colorbar(im, ax=ax, label="Point weight [%]", shrink=0.8)
+        cbar.set_ticks(ticks=wlist, labels=tlabels)
+
+        return im

foxes/output/turbine_type_curves.py

@@ -133,7 +133,7 @@ class TurbineTypeCurves(Output):
             verbosity=0,
         )
 
-        algo = Downwind(self.mbook, farm, states, wake_models=[], verbosity=0)
+        algo = Downwind(farm, states, wake_models=[], mbook=self.mbook, verbosity=0)
 
         results = algo.calc_farm()
 
@@ -149,7 +149,7 @@ class TurbineTypeCurves(Output):
                 verbosity=0,
             )
 
-            algo = Downwind(self.mbook, farm, states, wake_models=[], verbosity=0)
+            algo = Downwind(farm, states, wake_models=[], mbook=self.mbook, verbosity=0)
 
             results1 = algo.calc_farm()
 

foxes/utils/__init__.py

@@ -10,11 +10,12 @@ from .dict import Dict
 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
+from .load import import_module, load_module
 from .exec_python import exec_python
 from .regularize import sqrt_reg
 from .windrose_plot import TabWindroseAxes
 from .tab_files import read_tab_file
+from .random_xy import random_xy_square
 
 from . import two_circles
 from . import abl

foxes/utils/load.py

@@ -1,4 +1,6 @@
 import importlib
+import importlib.util
+import sys
 
 
 def import_module(name, package=None, hint=None):
@@ -29,3 +31,30 @@ def import_module(name, package=None, hint=None):
         mdl = name if package is None else f"{package}.{name}"
         hint = hint if hint is not None else f"pip install {name}"
         raise ModuleNotFoundError(f"Module '{mdl}' not found, maybe try '{hint}'")
+
+
+def load_module(name, path):
+    """
+    Imports a module from file path
+
+    Parameters
+    ----------
+    name: str
+        The name of the module
+    path: str
+        The path to the python file
+
+    Returns
+    -------
+    module:
+        The module object
+
+    :group: utils
+
+    """
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+
+    return module

foxes/utils/random_xy.py

@@ -0,0 +1,56 @@
+import numpy as np
+from scipy.spatial.distance import cdist
+
+
+def random_xy_square(
+    n,
+    min_dist=500,
+    xmax_ini=None,
+    growth=1.02,
+    seed=None,
+    verbosity=1,
+):
+    """
+    Creates random xy positions within a square,
+    with mean (0, 0)
+
+    Parameters
+    ----------
+    n: int
+        The number of positions
+    min_dist: float
+        The minimal distance between any two positions
+    xmax_ini: float, optional
+        The initial maximal distance of any coordinates
+    growth: float
+        The growth factor of the initial radius, must be
+        greater 1
+    seed: int, optional
+        The random seed
+    verbosity: int
+        The verbosity level. 0 = silent
+
+    Returns
+    -------
+    xy: numpy.ndarray
+        The positions, shape: (n, 2)
+
+    :group: utils
+
+    """
+    if seed:
+        np.random.seed(seed)
+
+    xmax = np.sqrt(n) * min_dist if xmax_ini is None else xmax_ini
+    xy = np.random.uniform(0, xmax, (n, 2))
+    while True:
+        dists = cdist(xy, xy)
+        np.fill_diagonal(dists, np.inf)
+        sel = np.unique(np.where(dists < min_dist)[0])
+        if not len(sel):
+            break
+        if verbosity > 0:
+            print(f"Re-generating coordinates: {len(sel)}, xmax = {xmax:.1f}")
+        xmax *= growth
+        xy[sel] = np.random.uniform(0, xmax, (len(sel), 2))
+    return xy - np.mean(xy, axis=0)[None, :]

foxes/utils/runners/runners.py

@@ -194,7 +194,19 @@ class DaskRunner(Runner):
         """
         Initialize the runner
         """
-        if self.scheduler == "distributed":
+        if self.scheduler is not None:
+            dask.config.set(scheduler=self.scheduler)
+
+        if self.scheduler == "dthreads":
+            self.print("Launching local dask cluster..")
+
+            cargs = deepcopy(self.cluster_args)
+            del cargs["processes"]
+            self._client = Client(processes=False, **self.client_args, **cargs)
+
+            self.print(f"Dashboard: {self._client.dashboard_link}\n")
+
+        elif self.scheduler == "distributed":
             self.print("Launching local dask cluster..")
 
             self._cluster = LocalCluster(**self.cluster_args)

foxes/utils/windrose_plot.py

@@ -104,6 +104,7 @@ class TabWindroseAxes(WindroseAxes):
             angle = 360.0 / nsector
             dir_bins = np.arange(-angle / 2, 360.0 + angle, angle, dtype=float)
             dir_edges = dir_bins.tolist()
+
             dir_edges.pop(-1)
             dir_edges[0] = dir_edges.pop(-1)
             dir_bins[0] = 0.0
@@ -119,7 +120,6 @@ class TabWindroseAxes(WindroseAxes):
             bins,
             table,
         )
-
         return bins, nbins, nsector, colors, angles, kwargs
 
     def legend(self, loc="upper right", *args, **kwargs):

foxes/variables.py

@@ -34,6 +34,16 @@ ORDER = "order"
 :group: foxes.variables
 """
 
+ORDER_INV = "order_inv"
+""" The inverse of the turbine order
+:group: foxes.variables
+"""
+
+ORDER_SSEL = "order_ssel"
+""" The states selection for applying the order
+:group: foxes.variables
+"""
+
 WS = "WS"
 """ The wind speed in m/s
 :group: foxes.variables

{foxes-0.6.1.dist-info → foxes-0.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foxes
-Version: 0.6.1
+Version: 0.7
 Summary: Farm Optimization and eXtended yield Evaluation Software
 Author: Fraunhofer IWES
 Author-email: jonas.schmidt@iwes.fraunhofer.de
@@ -43,6 +43,7 @@ Requires-Dist: nbsphinx ; extra == 'doc'
 Requires-Dist: ipykernel ; extra == 'doc'
 Requires-Dist: ipywidgets ; extra == 'doc'
 Requires-Dist: m2r2 ; extra == 'doc'
+Requires-Dist: lxml-html-clean ; extra == 'doc'
 Provides-Extra: io
 Requires-Dist: windio >=1.0 ; extra == 'io'
 Provides-Extra: scripts
@@ -102,7 +103,7 @@ Evaluation Software"`
 }
  ```
 
-## Requirements
+## Installation via pip
 
 The supported Python versions are: 
 
@@ -110,8 +111,7 @@ The supported Python versions are:
 - `Python 3.9`
 - `Python 3.10`
 - `Python 3.11`
-
-## Installation via pip
+- `Python 3.12`
 
 ### Virtual Python environment
 
@@ -162,6 +162,14 @@ The last line makes sure that all your code changes are included whenever import
 
 ## Installation via conda
 
+The supported Python versions are: 
+
+- `Python 3.8`
+- `Python 3.9`
+- `Python 3.10`
+- `Python 3.11`
+- `Python 3.12`
+
 ### Preparation
 
 It is strongly recommend to use the `libmamba` dependency solver instead of the default solver. Install it once by
@@ -233,12 +241,10 @@ import foxes
 
 states = foxes.input.states.Timeseries("timeseries_3000.csv.gz", ["WS", "WD","TI","RHO"])
 
-mbook = foxes.ModelBook()
-
 farm = foxes.WindFarm()
 foxes.input.farm_layout.add_from_file(farm, "test_farm_67.csv", turbine_models=["NREL5MW"])
 
-algo = foxes.algorithms.Downwind(mbook, farm, states, ["Jensen_linear_k007"])
+algo = foxes.algorithms.Downwind(farm, states, ["Jensen_linear_k007"])
 farm_results = algo.calc_farm()
 
 print(farm_results)