foxes 0.8.2__py3-none-any.whl → 1.1.0.2__py3-none-any.whl

foxes/core/rotor_model.py

@@ -27,13 +27,13 @@ class RotorModel(FarmDataModel):
 
     """
 
-    def __init__(self, calc_vars):
+    def __init__(self, calc_vars=None):
         """
         Constructor.
 
         Parameters
         ----------
-        calc_vars: list of str
+        calc_vars: list of str, optional
             The variables that are calculated by the model
             (Their ambients are added automatically)
 
@@ -41,10 +41,6 @@ class RotorModel(FarmDataModel):
         super().__init__()
         self.calc_vars = calc_vars
 
-        self.RPOINTS = self.var("rpoints")
-        self.RWEIGHTS = self.var("rweights")
-        self.AMBRES = self.var("amb_res")
-
     def output_farm_vars(self, algo):
         """
         The variables which are being modified by the model.
@@ -60,12 +56,21 @@ class RotorModel(FarmDataModel):
             The output variable names
 
         """
-        return list(
-            set(
-                self.calc_vars
-                + [FV.var2amb[v] for v in self.calc_vars if v in FV.var2amb]
-            )
-        )
+        if self.calc_vars is None:
+            vrs = algo.states.output_point_vars(algo)
+            if FV.WS in vrs:
+                self.calc_vars = [FV.REWS] + [v for v in vrs if v != FV.WS]
+            else:
+                self.calc_vars = vrs
+
+            if algo.farm_controller.needs_rews2() and FV.REWS2 not in self.calc_vars:
+                self.calc_vars.append(FV.REWS2)
+            if algo.farm_controller.needs_rews3() and FV.REWS3 not in self.calc_vars:
+                self.calc_vars.append(FV.REWS3)
+
+            self.calc_vars = sorted(self.calc_vars)
+
+        return self.calc_vars
 
     @abstractmethod
     def n_rotor_points(self):
@@ -207,6 +212,10 @@ class RotorModel(FarmDataModel):
             variables after calculation
 
         """
+        for v in [FV.REWS2, FV.REWS3]:
+            if v in fdata and v not in self.calc_vars:
+                self.calc_vars.append(v)
+
         uvp = None
         uv = None
         if (
@@ -348,11 +357,11 @@ class RotorModel(FarmDataModel):
         """
 
         if rpoints is None:
-            rpoints = mdata.get(self.RPOINTS, self.get_rotor_points(algo, mdata, fdata))
+            rpoints = mdata.get(
+                FC.ROTOR_POINTS, self.get_rotor_points(algo, mdata, fdata)
+            )
         if store_rpoints:
-            mdata[self.RPOINTS] = rpoints
-            mdata.dims[self.RPOINTS] = (FC.STATE, FC.TURBINE, FC.TPOINT, FC.XYH)
-            self.data_to_store(self.RPOINTS, algo, mdata)
+            algo.add_to_chunk_store(FC.ROTOR_POINTS, rpoints, mdata=mdata)
 
         if downwind_index is not None:
             rpoints = rpoints[:, downwind_index, None]
@@ -360,9 +369,7 @@ class RotorModel(FarmDataModel):
         if weights is None:
             weights = mdata.get(FC.TWEIGHTS, self.rotor_point_weights())
         if store_rweights:
-            mdata[self.RWEIGHTS] = weights
-            mdata.dims[self.RWEIGHTS] = (FC.TPOINT,)
-            self.data_to_store(self.RWEIGHTS, algo, mdata)
+            algo.add_to_chunk_store(FC.ROTOR_WEIGHTS, weights, mdata=mdata)
 
         tdata = TData.from_tpoints(rpoints, weights)
         svars = algo.states.output_point_vars(algo)
@@ -377,8 +384,7 @@ class RotorModel(FarmDataModel):
         tdata.update(sres)
 
         if store_amb_res:
-            mdata[self.AMBRES] = sres.copy()
-            self.data_to_store(self.AMBRES, algo, mdata)
+            algo.add_to_chunk_store(FC.AMB_ROTOR_RES, sres.copy(), mdata=mdata)
 
         self.eval_rpoint_results(
             algo,

foxes/core/states.py

@@ -61,6 +61,22 @@ class States(PointDataModel):
         """
         pass
 
+    def reset(self, algo=None, states_sel=None, states_loc=None, verbosity=0):
+        """
+        Reset the states, optionally select states
+
+        Parameters
+        ----------
+        states_sel: slice or range or list of int, optional
+            States subset selection
+        states_loc: list, optional
+            State index selection via pandas loc function
+        verbosity: int
+            The verbosity level, 0 = silent
+
+        """
+        raise NotImplementedError(f"States '{self.name}': Reset is not implemented")
+
     def load_data(self, algo, verbosity=0):
         """
         Load and/or create all model data that is subject to chunking.
@@ -279,7 +295,7 @@ class ExtendedStates(States):
         return self.states.output_point_vars(algo)
 
     def calculate(self, algo, mdata, fdata, tdata):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,

foxes/core/turbine_type.py

@@ -1,3 +1,5 @@
+from abc import abstractmethod
+
 import foxes.constants as FC
 from foxes.utils import all_subclasses
 
@@ -64,6 +66,32 @@ class TurbineType(TurbineModel):
         a = f"D={self.D}, H={self.H}, P_nominal={self.P_nominal}, P_unit={self.P_unit}"
         return f"{type(self).__name__}({a})"
 
+    @abstractmethod
+    def needs_rews2(self):
+        """
+        Returns flag for requiring REWS2 variable
+
+        Returns
+        -------
+        flag: bool
+            True if REWS2 is required
+
+        """
+        pass
+
+    @abstractmethod
+    def needs_rews3(self):
+        """
+        Returns flag for requiring REWS3 variable
+
+        Returns
+        -------
+        flag: bool
+            True if REWS3 is required
+
+        """
+        pass
+
     def modify_cutin(self, modify_ct, modify_P):
         """
         Modify the data such that a discontinuity

foxes/core/wake_frame.py

@@ -6,7 +6,7 @@ from foxes.utils import all_subclasses
 import foxes.constants as FC
 import foxes.variables as FV
 
-from .data import MData, FData, TData
+from .data import TData
 from .model import Model
 
 
@@ -21,13 +21,31 @@ class WakeFrame(Model):
     They are also responsible for the calculation of
     the turbine evaluation order.
 
+    Attributes
+    ----------
+    max_length_km: float
+        The maximal wake length in km
+
     :group: core
 
     """
 
+    def __init__(self, max_length_km=3e4):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        max_length_km: float
+            The maximal wake length in km
+
+        """
+        super().__init__()
+        self.max_length_km = max_length_km
+
     @abstractmethod
     def calc_order(self, algo, mdata, fdata):
-        """ "
+        """
         Calculates the order of turbine evaluation.
 
         This function is executed on a single chunk of data,
@@ -74,7 +92,7 @@ class WakeFrame(Model):
             The target point data
         downwind_index: int
             The index of the wake causing turbine
-            in the downwnd order
+            in the downwind order
 
         Returns
         -------
@@ -94,7 +112,6 @@ class WakeFrame(Model):
         tdata,
         target,
         states0=None,
-        upcast=False,
     ):
         """
         Return data that is required for computing the
@@ -118,47 +135,26 @@ class WakeFrame(Model):
             FC.STATE_TARGET_TPOINT
         states0: numpy.ndarray, optional
             The states of wake creation
-        upcast: bool
-            Flag for ensuring targets dimension,
-            otherwise dimension 1 is entered
 
         Returns
         -------
         data: numpy.ndarray
             Data for wake modelling, shape:
             (n_states, n_turbines) or (n_states, n_target)
-        dims: tuple
-            The data dimensions
 
         """
-        n_states = fdata.n_states
         s = np.s_[:] if states0 is None else states0
 
-        if not upcast:
-            if target == FC.STATE_TARGET_TPOINT:
-                out = fdata[variable][s, downwind_index, None, None]
-                dims = (FC.STATE, 1, 1)
-            else:
-                out = fdata[variable][s, downwind_index, None]
-                dims = (FC.STATE, 1)
-        elif target == FC.STATE_TURBINE:
-            out = np.zeros((n_states, fdata.n_turbines), dtype=FC.DTYPE)
-            out[:] = fdata[variable][s, downwind_index, None]
-            dims = (FC.STATE, FC.TURBINE)
-        elif target == FC.STATE_TARGET:
-            out = np.zeros((n_states, tdata.n_targets), dtype=FC.DTYPE)
-            out[:] = fdata[variable][s, downwind_index, None]
-            dims = (FC.STATE, FC.TARGET)
-        elif target == FC.STATE_TARGET_TPOINT:
-            out = np.zeros((n_states, tdata.n_targets, tdata.n_tpoints), dtype=FC.DTYPE)
-            out[:] = fdata[variable][s, downwind_index, None, None]
-            dims = (FC.STATE, FC.TARGET, FC.TPOINT)
+        if target == FC.STATE_TARGET_TPOINT:
+            out = fdata[variable][s, downwind_index, None, None]
+        elif target in [FC.STATE_TURBINE, FC.STATE_TARGET]:
+            out = fdata[variable][s, downwind_index, None]
         else:
             raise ValueError(
-                f"Unsupported target '{target}', expcting '{FC.STATE_TURBINE}', '{FC.STATE_TARGET}', {FC.STATE_TARGET_TPOINT}"
+                f"Unkown target '{target}', choices are {FC.STATE_TURBINE}, {FC.STATE_TARGET}, {FC.STATE_TARGET_TPOINT}"
             )
 
-        return out, dims
+        return out
 
     def get_centreline_points(self, algo, mdata, fdata, downwind_index, x):
         """
@@ -241,7 +237,7 @@ class WakeFrame(Model):
 
         # calc evaluation points:
         xmin = 0.0
-        xmax = np.nanmax(x)
+        xmax = min(np.nanmax(x), self.max_length_km * 1e3)
         n_steps = int((xmax - xmin) / dx)
         if xmin + n_steps * dx < xmax:
             n_steps += 1
@@ -262,7 +258,7 @@ class WakeFrame(Model):
         res = algo.states.calculate(algo, mdata, fdata, tdata)
         tdata.update(res)
         amb2var = algo.get_model("SetAmbPointResults")()
-        amb2var.initialize(algo, verbosity=0)
+        amb2var.initialize(algo, verbosity=0, force=True)
         res = amb2var.calculate(algo, mdata, fdata, tdata)
         tdata.update(res)
         del res, amb2var
@@ -277,7 +273,7 @@ class WakeFrame(Model):
         # calc wakes:
         if not ambient:
             wcalc = algo.get_model("PointWakesCalculation")(wake_models=wake_models)
-            wcalc.initialize(algo, verbosity=0)
+            wcalc.initialize(algo, verbosity=0, force=True)
             wsrc = downwind_index if self_wake else None
             res = wcalc.calculate(algo, mdata, fdata, tdata, downwind_index=wsrc)
             tdata.update(res)

foxes/core/wake_model.py

@@ -81,7 +81,7 @@ class WakeModel(Model):
             The target point data
         downwind_index: int
             The index of the wake causing turbine
-            in the downwnd order
+            in the downwind order
         wake_coos: numpy.ndarray
             The wake frame coordinates of the evaluation
             points, shape: (n_states, n_targets, n_tpoints, 3)
@@ -304,9 +304,9 @@ class WakeK(Model):
             The k array as returned by get_data
 
         """
-        if self._k is not None:
-            setattr(self, self.k_var, self._k)
-        elif self._ka is not None or self._kb is not None:
+        sel = kwargs.pop("selection", None)
+        setattr(self, self.k_var, self._k)
+        if self._ka is not None or self._kb is not None:
             if self.ti_var == FV.TI and ti is not None:
                 pass
             elif self.ti_var == FV.AMB_TI and amb_ti is not None:
@@ -316,6 +316,6 @@ class WakeK(Model):
             kb = 0 if self._kb is None else self._kb
             setattr(self, self.k_var, self._ka * ti + kb)
 
-        k = self.get_data(self.k_var, *args, lookup=lookup_k, **kwargs)
+        k = self.get_data(self.k_var, *args, lookup=lookup_k, selection=sel, **kwargs)
         setattr(self, self.k_var, None)
         return k

foxes/core/wake_superposition.py

@@ -45,7 +45,7 @@ class WakeSuperposition(Model):
             The target point data
         downwind_index: int
             The index of the wake causing turbine
-            in the downwnd order
+            in the downwind order
         st_sel: numpy.ndarray of bool
             The selection of targets, shape: (n_states, n_targets)
         variable: str

foxes/data/windio/windio_5turbines_timeseries.yaml

@@ -14,10 +14,9 @@ site:
 wind_farm: 
   name: One row with 5 turbines
   layouts:
-      initial_layout:
-          coordinates:
-              x: [0, 0, 0, 0, 0]
-              y: [0, 600, 1150, 1730, 2400]
+    - coordinates:
+        x: [0, 0, 0, 0, 0]
+        y: [0, 600, 1150, 1730, 2400]
   turbines: !include DTU_10MW_turbine.yaml
 
 attributes:
@@ -26,38 +25,55 @@ attributes:
 
   analysis:
 
+    #pywake and foxes
     wind_deficit_model:
       name: Bastankhah2014
       wake_expansion_coefficient: # k = ka*ti + kb
-        k_a: 0.04 
-        k_b: 0.0
+        k_a: 0.0
+        k_b: 0.04
         free_stream_ti: false
       ceps: 0.2
       use_effective_ws: true
-
     axial_induction_model: Madsen
-
     deflection_model:
       name: None
-    
     turbulence_model:
       name: CrespoHernandez
-    
     superposition_model:
       ws_superposition: Linear
       ti_superposition: Quadratic
-
     rotor_averaging:
       grid: grid
       n_x_grid_points: 4
       n_y_grid_points: 4
-      background_averaging: grid
-      wake_averaging: axiwake9
+      background_averaging: center
+      wake_averaging: centre
       wind_speed_exponent_for_power: 3
       wind_speed_exponent_for_ct: 2
-
     blockage_model:
       name: None
 
-
+  outputs:
+    output_folder: "results"
+    turbine_outputs:
+        turbine_nc_filename: 'turbine_data.nc' # dimension = states, turbine
+        output_variables: ['power', 'rotor_effective_velocity'] #'frequency'
+    #
+    flow_field:
+      report: False
+      flow_nc_filename: flow_field.nc
+      cases_run:
+        all_occurences: True
+      output_variables: ['wind_speed', 'wind_direction']
+      z_planes:
+        z_sampling: "hub_height"
+        xy_sampling: "default"
+    #
+    statistics:
+      stats_filename: None
+      AEP: False
+      AEP_per_turbine: False
+      power_percentiles:
+        report: False
+        percentiles: None
 

foxes/engines/__init__.py

@@ -0,0 +1,17 @@
+from .pool import PoolEngine
+from .multiprocess import MultiprocessEngine
+from .numpy import NumpyEngine
+from .single import SingleChunkEngine
+from .futures import ThreadsEngine, ProcessEngine
+from .mpi import MPIEngine
+from .ray import RayEngine
+
+from .dask import (
+    DaskBaseEngine,
+    XArrayEngine,
+    DaskEngine,
+    LocalClusterEngine,
+    SlurmClusterEngine,
+)
+
+from .default import DefaultEngine