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

foxes/core/farm_data_model.py

@@ -66,28 +66,29 @@ class FarmDataModel(DataCalcModel):
         """
         return (FC.STATE, FC.TURBINE)
 
-    def ensure_variables(self, algo, mdata, fdata):
+    def ensure_output_vars(self, algo, fdata):
         """
-        Add variables to fdata, initialized with NaN
+        Ensures that the output variables are present in the farm data.
 
         Parameters
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
-            The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
 
         """
-        n_states = fdata.n_states
-        n_turbines = fdata.n_turbines
-        for v in self.output_farm_vars(algo):
-            if v not in fdata:
-                fdata[v] = np.full(
-                    (n_states, n_turbines), np.nan, dtype=config.dtype_double
+        for var in self.output_farm_vars(algo):
+            if var not in fdata:
+                fdata.add(
+                    var,
+                    np.full(
+                        (fdata.n_states, fdata.n_turbines),
+                        np.nan,
+                        dtype=config.dtype_double,
+                    ),
+                    (FC.STATE, FC.TURBINE),
                 )
-                fdata.dims[v] = (FC.STATE, FC.TURBINE)
 
     @abstractmethod
     def calculate(self, algo, mdata, fdata):
@@ -264,7 +265,7 @@ class FarmDataModelList(FarmDataModel):
             The model data
         fdata: foxes.core.FData
             The farm data
-        parameters: list of dict, optional
+        parameters: list of dict
             A list of parameter dicts, one for each model
 
         Returns
@@ -274,6 +275,8 @@ class FarmDataModelList(FarmDataModel):
             Values: numpy.ndarray with shape (n_states, n_turbines)
 
         """
+        self.ensure_output_vars(algo, fdata)
+
         if parameters is None:
             parameters = [{}] * len(self.models)
         elif not isinstance(parameters, list):

foxes/core/model.py

@@ -64,12 +64,30 @@ class Model(ABC):
 
         Returns
         -------
-        str
+        vnm: str
             Model specific variable name
 
         """
         return f"{self.name}_{v}"
 
+    def unvar(self, vnm):
+        """
+        Translates model specific variable name to origninal variable name.
+
+        Parameters
+        ----------
+        vnm: str
+            The vamodel specific variable name
+
+        Returns
+        -------
+        v: str
+            Original variable name
+
+        """
+        lng = len(f"{self.name}_")
+        return vnm[lng:] if vnm.startswith(f"{self.name}_") else None
+
     @property
     def initialized(self):
         """

foxes/core/point_data_model.py

@@ -42,30 +42,33 @@ class PointDataModel(DataCalcModel):
         """
         return (FC.STATE, FC.TARGET, FC.TPOINT)
 
-    def ensure_variables(self, algo, mdata, fdata, tdata):
+    def ensure_output_vars(self, algo, tdata):
         """
-        Add variables to tdata, initialized with NaN
+        Ensures that the output variables are present in the target data.
 
         Parameters
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
-            The model data
-        fdata: foxes.core.Data
-            The farm data
-        tdata: foxes.core.Data
+        tdata: foxes.core.TData
             The target point data
 
         """
-        for v in self.output_point_vars(algo):
-            if v not in tdata:
-                tdata[v] = np.full(
-                    (tdata.n_states, tdata.n_targets, tdata.n_tpoints),
-                    np.nan,
-                    dtype=config.dtype_double,
+        vrs = set(self.output_point_vars(algo))
+        if hasattr(self, "fixed_vars"):
+            vrs.update(self.fixed_vars.keys())
+
+        for var in vrs:
+            if var not in tdata:
+                tdata.add(
+                    var,
+                    np.full(
+                        (tdata.n_states, tdata.n_targets, tdata.n_tpoints),
+                        np.nan,
+                        dtype=config.dtype_double,
+                    ),
+                    (FC.STATE, FC.TARGET, FC.TPOINT),
                 )
-                tdata.dims[v] = (FC.STATE, FC.TARGET, FC.TPOINT)
 
     @abstractmethod
     def calculate(self, algo, mdata, fdata, tdata):
@@ -247,6 +250,8 @@ class PointDataModelList(PointDataModel):
             (n_states, n_targets, n_tpoints)
 
         """
+        self.ensure_output_vars(algo, tdata)
+
         if parameters is None:
             parameters = [{}] * len(self.models)
         elif not isinstance(parameters, list):

foxes/core/rotor_model.py

@@ -362,6 +362,7 @@ class RotorModel(FarmDataModel):
             numpy.ndarray with results, shape: (n_states, n_turbines)
 
         """
+        self.ensure_output_vars(algo, fdata)
 
         if rpoints is None:
             rpoints = mdata.get(

foxes/core/wake_deflection.py

@@ -113,13 +113,13 @@ class WakeDeflection(Model):
         )
 
     @classmethod
-    def new(cls, wframe_type, *args, **kwargs):
+    def new(cls, wdefl_type, *args, **kwargs):
         """
         Run-time wake deflection model factory.
 
         Parameters
         ----------
-        wframe_type: str
+        wdefl_type: str
             The selected derived class name
         args: tuple, optional
             Additional parameters for constructor
@@ -127,4 +127,4 @@ class WakeDeflection(Model):
             Additional parameters for constructor
 
         """
-        return new_instance(cls, wframe_type, *args, **kwargs)
+        return new_instance(cls, wdefl_type, *args, **kwargs)

foxes/engines/dask.py

@@ -199,7 +199,6 @@ def _run_as_ufunc(
     out_coords,
     calc_pars,
     init_vars,
-    ensure_variables,
     calculate,
 ):
     """
@@ -314,7 +313,6 @@ def _run_as_ufunc(
         data[1].dims[FV.WEIGHT] = data[0].dims[FV.WEIGHT]
 
     # run model calculation:
-    ensure_variables(algo, *data)
     results = calculate(algo, *data, **calc_pars)
 
     # replace missing results by first input data with matching shape:
@@ -385,7 +383,7 @@ class XArrayEngine(DaskBaseEngine):
         self,
         algo,
         model,
-        model_data=None,
+        model_data,
         farm_data=None,
         point_data=None,
         out_vars=[],
@@ -408,9 +406,9 @@ class XArrayEngine(DaskBaseEngine):
             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
@@ -537,7 +535,6 @@ class XArrayEngine(DaskBaseEngine):
             out_coords=out_coords,
             calc_pars=calc_pars,
             init_vars=ivars,
-            ensure_variables=model.ensure_variables,
             calculate=model.calculate,
         )
 

foxes/engines/default.py

@@ -60,7 +60,7 @@ class DefaultEngine(Engine):
         self,
         algo,
         model,
-        model_data=None,
+        model_data,
         farm_data=None,
         point_data=None,
         **kwargs,
@@ -75,7 +75,7 @@ class DefaultEngine(Engine):
         model: foxes.core.DataCalcModel
             The model that whose calculate function
             should be run
-        model_data: xarray.Dataset, optional
+        model_data: xarray.Dataset
             The initial model data
         farm_data: xarray.Dataset, optional
             The initial farm data

foxes/engines/numpy.py

@@ -49,7 +49,7 @@ class NumpyEngine(Engine):
         self,
         algo,
         model,
-        model_data=None,
+        model_data,
         farm_data=None,
         point_data=None,
         out_vars=[],
@@ -71,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
@@ -108,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
@@ -161,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])
@@ -177,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
@@ -179,6 +187,7 @@ class PoolEngine(Engine):
             The model results
 
         """
+
         # subset selection:
         model_data, farm_data, point_data = self.select_subsets(
             model_data, farm_data, point_data, sel=sel, isel=isel
@@ -193,9 +202,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 +251,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 +266,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/farm_layout/__init__.py

@@ -10,3 +10,4 @@ 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/states/__init__.py

@@ -4,14 +4,20 @@ Atmospheric input states.
 
 from .single import SingleStateStates as SingleStateStates
 from .scan import ScanStates as ScanStates
-from .field_data_nc import FieldDataNC as FieldDataNC
 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