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

foxes/engines/numpy.py

@@ -1,6 +1,5 @@
 from tqdm import tqdm
 from xarray import Dataset
-from tqdm import tqdm
 
 from foxes.core import Engine
 import foxes.constants as FC
@@ -50,7 +49,7 @@ class NumpyEngine(Engine):
         self,
         algo,
         model,
-        model_data=None,
+        model_data,
         farm_data=None,
         point_data=None,
         out_vars=[],
@@ -72,9 +71,9 @@ class NumpyEngine(Engine):
             should be run
         model_data: xarray.Dataset
             The initial model data
-        farm_data: xarray.Dataset
+        farm_data: xarray.Dataset, optional
             The initial farm data
-        point_data: xarray.Dataset
+        point_data: xarray.Dataset, optional
             The initial point data
         out_vars: list of str, optional
             Names of the output variables
@@ -109,9 +108,6 @@ class NumpyEngine(Engine):
         coords = {}
         if FC.STATE in out_coords and FC.STATE in model_data.coords:
             coords[FC.STATE] = model_data[FC.STATE].to_numpy()
-        if farm_data is None:
-            farm_data = Dataset()
-        goal_data = farm_data if point_data is None else point_data
 
         # DEBUG objec mem sizes:
         # from foxes.utils import print_mem
@@ -146,8 +142,6 @@ class NumpyEngine(Engine):
             for chunki_points in range(n_chunks_targets):
                 i1_targets = i0_targets + chunk_sizes_targets[chunki_points]
 
-                i = chunki_states * n_chunks_targets + chunki_points
-
                 # get this chunk's data:
                 data = self.get_chunk_input_data(
                     algo=algo,
@@ -164,10 +158,10 @@ class NumpyEngine(Engine):
                 results[key] = _run(
                     algo,
                     model,
-                    data,
-                    iterative,
-                    chunk_store,
-                    (i0_states, i0_targets),
+                    *data,
+                    iterative=iterative,
+                    chunk_store=chunk_store,
+                    i0_t0=(i0_states, i0_targets),
                     **calc_pars,
                 )
                 chunk_store.update(results[key][1])
@@ -180,7 +174,11 @@ class NumpyEngine(Engine):
 
             i0_states = i1_states
 
+        if farm_data is None:
+            farm_data = Dataset()
+        goal_data = farm_data if point_data is None else point_data
         del calc_pars, farm_data, point_data
+
         if pbar is not None:
             pbar.close()
 

foxes/engines/pool.py

@@ -7,7 +7,15 @@ from foxes.core import Engine
 import foxes.constants as FC
 
 
-def _run(algo, model, data, iterative, chunk_store, i0_t0, **cpars):
+def _run(
+    algo,
+    model,
+    *data,
+    iterative,
+    chunk_store,
+    i0_t0,
+    **cpars,
+):
     """Helper function for running in a single process"""
     algo.reset_chunk_store(chunk_store)
     results = model.calculate(algo, *data, **cpars)
@@ -134,7 +142,7 @@ class PoolEngine(Engine):
         self,
         algo,
         model,
-        model_data=None,
+        model_data,
         farm_data=None,
         point_data=None,
         out_vars=[],
@@ -156,9 +164,9 @@ class PoolEngine(Engine):
             should be run
         model_data: xarray.Dataset
             The initial model data
-        farm_data: xarray.Dataset
+        farm_data: xarray.Dataset, optional
             The initial farm data
-        point_data: xarray.Dataset
+        point_data: xarray.Dataset, optional
             The initial point data
         out_vars: list of str, optional
             Names of the output variables
@@ -193,9 +201,6 @@ class PoolEngine(Engine):
         coords = {}
         if FC.STATE in out_coords and FC.STATE in model_data.coords:
             coords[FC.STATE] = model_data[FC.STATE].to_numpy()
-        if farm_data is None:
-            farm_data = xr.Dataset()
-        goal_data = farm_data if point_data is None else point_data
 
         # DEBUG objec mem sizes:
         # from foxes.utils import print_mem
@@ -245,10 +250,10 @@ class PoolEngine(Engine):
                     _run,
                     algo,
                     model,
-                    data,
-                    iterative,
-                    chunk_store,
-                    (i0_states, i0_targets),
+                    *data,
+                    iterative=iterative,
+                    chunk_store=chunk_store,
+                    i0_t0=(i0_states, i0_targets),
                     **calc_pars,
                 )
                 del data
@@ -260,6 +265,10 @@ class PoolEngine(Engine):
 
             i0_states = i1_states
 
+        if farm_data is None:
+            farm_data = xr.Dataset()
+        goal_data = farm_data if point_data is None else point_data
+
         del calc_pars, farm_data, point_data
         if pbar is not None:
             pbar.close()

foxes/engines/single.py

@@ -73,7 +73,7 @@ class SingleChunkEngine(Engine):
         self,
         algo,
         model,
-        model_data=None,
+        model_data,
         farm_data=None,
         point_data=None,
         out_vars=[],
@@ -95,9 +95,9 @@ class SingleChunkEngine(Engine):
             should be run
         model_data: xarray.Dataset
             The initial model data
-        farm_data: xarray.Dataset
+        farm_data: xarray.Dataset, optional
             The initial farm data
-        point_data: xarray.Dataset
+        point_data: xarray.Dataset, optional
             The initial point data
         out_vars: list of str, optional
             Names of the output variables
@@ -133,9 +133,6 @@ class SingleChunkEngine(Engine):
         coords = {}
         if FC.STATE in out_coords and FC.STATE in model_data.coords:
             coords[FC.STATE] = model_data[FC.STATE].to_numpy()
-        if farm_data is None:
-            farm_data = Dataset()
-        goal_data = farm_data if point_data is None else point_data
         algo.reset_chunk_store(chunk_store)
 
         # calculate:
@@ -157,6 +154,11 @@ class SingleChunkEngine(Engine):
 
         results = {}
         results[(0, 0)] = (model.calculate(algo, *data, **calc_pars), algo.chunk_store)
+        del data
+
+        if farm_data is None:
+            farm_data = Dataset()
+        goal_data = farm_data if point_data is None else point_data
 
         return self.combine_results(
             algo=algo,

foxes/input/__init__.py

@@ -2,6 +2,6 @@
 Functions and classes for input data definition.
 """
 
-from . import farm_layout
-from . import states
-from . import yaml
+from . import farm_layout as farm_layout
+from . import states as states
+from . import yaml as yaml

foxes/input/farm_layout/__init__.py

@@ -2,11 +2,12 @@
 Functions for adding turbines to the wind farm.
 """
 
-from .row import add_row
-from .grid import add_grid
-from .from_json import add_from_json
-from .from_csv import add_from_csv
-from .from_file import add_from_file
-from .from_df import add_from_df
-from .from_random import add_random
-from .ring import add_ring
+from .row import add_row as add_row
+from .grid import add_grid as add_grid
+from .from_json import add_from_json as add_from_json
+from .from_csv import add_from_csv as add_from_csv
+from .from_file import add_from_file as add_from_file
+from .from_df import add_from_df as add_from_df
+from .from_random import add_random as add_random
+from .ring import add_ring as add_ring
+from .from_arrays import add_from_arrays as add_from_arrays

foxes/input/farm_layout/from_arrays.py

@@ -0,0 +1,68 @@
+from foxes.core import Turbine
+
+
+def add_from_arrays(
+    farm,
+    x,
+    y,
+    heights=None,
+    diameters=None,
+    ids=None,
+    names=None,
+    turbine_base_name="T",
+    turbine_base_name_count_shift=False,
+    verbosity=1,
+    **turbine_parameters,
+):
+    """
+    Add turbines to wind farm from direct one dimensional data arrays.
+
+    Parameters
+    ----------
+    farm: foxes.WindFarm
+        The wind farm
+    x: list or numpy.ndarray
+        The x-coordinates of the turbines
+    y: list or numpy.ndarray
+        The y-coordinates of the turbines
+    heights: list or numpy.ndarray, optional
+        The hub heights of the turbines, or None
+    diameters: list or numpy.ndarray, optional
+        The rotor diameters of the turbines, or None
+    ids: list or numpy.ndarray, optional
+        The ids of the turbines, or None
+    names: list or numpy.ndarray, optional
+        The names of the turbines, or None
+    turbine_base_name: str, optional
+        The turbine base name, only used
+        if col_name is None
+    turbine_base_name_count_shift: bool, optional
+        Start turbine names by 1 instead of 0
+    verbosity: int
+        The verbosity level, 0 = silent
+    turbine_parameters: dict, optional
+        Additional parameters are forwarded to the WindFarm.add_turbine().
+
+    :group: input.farm_layout
+
+    """
+    tmodels = turbine_parameters.pop("turbine_models", [])
+    H = turbine_parameters.pop("H", None)
+    D = turbine_parameters.pop("D", None)
+
+    for i in range(len(x)):
+        s = 1 if turbine_base_name_count_shift else 0
+        tname = f"{turbine_base_name}{i + s}" if names is None else names[i]
+
+        farm.add_turbine(
+            Turbine(
+                name=tname,
+                index=ids[i] if ids is not None else i,
+                xy=[x[i], y[i]],
+                H=heights[i] if heights is not None else H,
+                D=diameters[i] if diameters is not None else D,
+                turbine_models=tmodels,
+                **turbine_parameters,
+            ),
+            verbosity=verbosity,
+        )

foxes/input/farm_layout/from_csv.py

@@ -86,7 +86,7 @@ def add_from_csv(
     for i in data.index:
         s = 1 if turbine_base_name_count_shift else 0
         tname = (
-            f"{turbine_base_name}{i+s}" if col_name is None else data.loc[i, col_name]
+            f"{turbine_base_name}{i + s}" if col_name is None else data.loc[i, col_name]
         )
         txy = data.loc[i, [col_x, col_y]].values
 

foxes/input/farm_layout/ring.py

@@ -49,7 +49,6 @@ def add_ring(
     da = 360 / n_turbines
 
     for i in range(n_turbines):
-
         n = wd2wdvec(a)[0]
 
         farm.add_turbine(

foxes/input/states/__init__.py

@@ -2,18 +2,34 @@
 Atmospheric input states.
 """
 
-from .single import SingleStateStates
-from .scan import ScanStates
-from .states_table import StatesTable, Timeseries, TabStates
-from .field_data_nc import FieldDataNC
-from .multi_height import MultiHeightStates, MultiHeightTimeseries
-from .multi_height import MultiHeightNCStates, MultiHeightNCTimeseries
+from .single import SingleStateStates as SingleStateStates
+from .scan import ScanStates as ScanStates
+from .wrg_states import WRGStates as WRGStates
+from .weibull_sectors import WeibullSectors as WeibullSectors
+from .dataset_states import DatasetStates as DatasetStates
+
+from .states_table import StatesTable as StatesTable
+from .states_table import Timeseries as Timeseries
+from .states_table import TabStates as TabStates
+
+from .field_data import FieldData as FieldData
+from .field_data import WeibullField as WeibullField
+
+from .point_cloud_data import WeibullPointCloud as WeibullPointCloud
+from .point_cloud_data import PointCloudData as PointCloudData
+
+from .multi_height import MultiHeightStates as MultiHeightStates
+from .multi_height import MultiHeightTimeseries as MultiHeightTimeseries
+from .multi_height import MultiHeightNCStates as MultiHeightNCStates
+from .multi_height import MultiHeightNCTimeseries as MultiHeightNCTimeseries
+
+from .one_point_flow import OnePointFlowStates as OnePointFlowStates
+from .one_point_flow import OnePointFlowTimeseries as OnePointFlowTimeseries
+from .one_point_flow import (
+    OnePointFlowMultiHeightTimeseries as OnePointFlowMultiHeightTimeseries,
+)
 from .one_point_flow import (
-    OnePointFlowStates,
-    OnePointFlowTimeseries,
-    OnePointFlowMultiHeightTimeseries,
-    OnePointFlowMultiHeightNCTimeseries,
+    OnePointFlowMultiHeightNCTimeseries as OnePointFlowMultiHeightNCTimeseries,
 )
-from .wrg_states import WRGStates
 
-from . import create
+from . import create as create

foxes/input/states/create/__init__.py

@@ -1,2 +1,3 @@
-from .random_abl_states import create_random_abl_states, write_random_abl_states
-from .random_timeseries import random_timseries_data
+from .random_abl_states import create_random_abl_states as create_random_abl_states
+from .random_abl_states import write_random_abl_states as write_random_abl_states
+from .random_timeseries import random_timseries_data as random_timseries_data