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

foxes/algorithms/iterative/models/farm_wakes_calc.py

@@ -1,7 +1,7 @@
 import numpy as np
 from copy import deepcopy
 
-from foxes.core import FarmDataModel, TData
+from foxes.core import FarmDataModel
 import foxes.constants as FC
 import foxes.variables as FV
 
@@ -99,8 +99,14 @@ class FarmWakesCalculation(FarmDataModel):
         for wname, wmodel in algo.wake_models.items():
             pwake = algo.partial_wakes[wname]
             if pwake.name not in pwake2tdata:
-                tpoints, tweights = pwake.get_wake_points(algo, mdata, fdata)
-                pwake2tdata[pwake.name] = TData.from_tpoints(tpoints, tweights)
+                wmodels = [
+                    wm
+                    for wn, wm in algo.wake_models.items()
+                    if algo.partial_wakes[wn] is pwake
+                ]
+                pwake2tdata[pwake.name] = pwake.get_initial_tdata(
+                    algo, mdata, fdata, amb_res, rwghts, wmodels
+                )
 
         def _get_wdata(tdatap, wdeltas, variables, s):
             """Helper function for wake data extraction"""
@@ -117,7 +123,6 @@ class FarmWakesCalculation(FarmDataModel):
             wdeltas = pwake.new_wake_deltas(algo, mdata, fdata, tdatap, wmodel)
 
             for oi in range(n_turbines):
-
                 if oi > 0:
                     tdata, wdelta = _get_wdata(
                         tdatap, wdeltas, [FC.STATE, FC.TARGET], np.s_[:, :oi]
@@ -140,7 +145,6 @@ class FarmWakesCalculation(FarmDataModel):
                     mdata,
                     fdata,
                     tdatap,
-                    amb_res,
                     rwghts,
                     wdeltas,
                     wmodel,

foxes/algorithms/sequential/__init__.py

@@ -1,4 +1,4 @@
-from .sequential import Sequential
-from .models import SequentialPlugin
+from .sequential import Sequential as Sequential
+from .models import SequentialPlugin as SequentialPlugin
 
-from . import models
+from . import models as models

foxes/algorithms/sequential/models/__init__.py

@@ -1,2 +1,2 @@
-from .plugin import SequentialPlugin
-from .seq_state import SeqState
+from .plugin import SequentialPlugin as SequentialPlugin
+from .seq_state import SeqState as SeqState

foxes/algorithms/sequential/sequential.py

@@ -154,7 +154,7 @@ class Sequential(Iterative):
             if self._verbo0 > 0:
                 print("\nInput data:\n")
                 print(self._model_data)
-                print(f"\nOutput farm variables:", ", ".join(self.farm_vars))
+                print("\nOutput farm variables:", ", ".join(self.farm_vars))
                 print()
 
             sts = self._model_data[FC.STATE].to_numpy()
@@ -188,7 +188,6 @@ class Sequential(Iterative):
         """Run calculation for current step, then iterate to next"""
 
         if self._i < len(self._inds):
-
             self._counter = self._i
             self.states._counter = self._i
             self.states._size = 1
@@ -401,7 +400,7 @@ class Sequential(Iterative):
 
         """
         if not self.iterating:
-            raise ValueError(f"calc_farm call is only allowed during iterations")
+            raise ValueError("calc_farm call is only allowed during iterations")
         return self.cur_farm_results
 
     def calc_points(
@@ -433,6 +432,6 @@ class Sequential(Iterative):
 
         """
         if not self.iterating:
-            raise ValueError(f"calc_points call is only allowed during iterations")
+            raise ValueError("calc_points call is only allowed during iterations")
 
         return super().calc_points(farm_results, points, finalize=False, **kwargs)

foxes/config/__init__.py

@@ -1 +1,5 @@
-from .config import Config, config, get_path, get_input_path, get_output_path
+from .config import Config as Config
+from .config import config as config
+from .config import get_path as get_path
+from .config import get_input_path as get_input_path
+from .config import get_output_path as get_output_path

foxes/constants.py

@@ -1,3 +1,8 @@
+XY = "xy"
+""" The vector (x, y)
+:group: foxes.variables
+"""
+
 XYH = "xyh"
 """ The vector (x, y, height)
 :group: foxes.variables
@@ -146,6 +151,17 @@ BLOCK_CONVERGENCE = "block_convergence"
 """
 
 
+WDEFL_ROT_ANGLE = "wake_deflection_rotation_angle"
+"""Identifier for the wake deflection rotation angle data
+:group: foxes.constants
+"""
+
+WDEFL_DWS_FACTOR = "wake_deflection_deltaws_factor"
+"""Identifier for the wake deflection delta wind speed factor data
+:group: foxes.constants
+"""
+
+
 KAPPA = 0.41
 """ The Von Karman constant
 :group: foxes.constants

foxes/core/__init__.py

@@ -2,25 +2,48 @@
 Abstract classes and core functionality.
 """
 
-from .data import Data, MData, FData, TData
-from .model import Model
-from .data_calc_model import DataCalcModel
-from .engine import Engine, get_engine, has_engine, reset_engine
-from .states import States, ExtendedStates
-from .wind_farm import WindFarm
-from .algorithm import Algorithm
-from .farm_data_model import FarmDataModel, FarmDataModelList
-from .point_data_model import PointDataModel, PointDataModelList
-from .rotor_model import RotorModel
-from .farm_model import FarmModel
-from .turbine_model import TurbineModel
-from .turbine_type import TurbineType
-from .farm_controller import FarmController
-from .turbine import Turbine
-from .partial_wakes_model import PartialWakesModel
-from .wake_frame import WakeFrame
-from .wake_model import WakeModel, TurbineInductionModel, WakeK
-from .wake_superposition import WakeSuperposition
-from .vertical_profile import VerticalProfile
-from .axial_induction_model import AxialInductionModel
-from .ground_model import GroundModel
+from .model import Model as Model
+from .data_calc_model import DataCalcModel as DataCalcModel
+from .wind_farm import WindFarm as WindFarm
+from .algorithm import Algorithm as Algorithm
+from .rotor_model import RotorModel as RotorModel
+from .farm_model import FarmModel as FarmModel
+from .turbine_model import TurbineModel as TurbineModel
+from .turbine_type import TurbineType as TurbineType
+from .farm_controller import FarmController as FarmController
+from .turbine import Turbine as Turbine
+from .partial_wakes_model import PartialWakesModel as PartialWakesModel
+from .wake_frame import WakeFrame as WakeFrame
+from .wake_deflection import WakeDeflection as WakeDeflection
+from .vertical_profile import VerticalProfile as VerticalProfile
+from .axial_induction_model import AxialInductionModel as AxialInductionModel
+from .ground_model import GroundModel as GroundModel
+
+from .data import Data as Data
+from .data import MData as MData
+from .data import FData as FData
+from .data import TData as TData
+
+from .engine import Engine as Engine
+from .engine import get_engine as get_engine
+from .engine import has_engine as has_engine
+from .engine import reset_engine as reset_engine
+
+from .states import States as States
+from .states import ExtendedStates as ExtendedStates
+
+from .farm_data_model import FarmDataModel as FarmDataModel
+from .farm_data_model import FarmDataModelList as FarmDataModelList
+
+from .point_data_model import PointDataModel as PointDataModel
+from .point_data_model import PointDataModelList as PointDataModelList
+
+from .wake_model import WakeModel as WakeModel
+from .wake_model import SingleTurbineWakeModel as SingleTurbineWakeModel
+from .wake_model import TurbineInductionModel as TurbineInductionModel
+from .wake_model import WakeK as WakeK
+
+from .wake_superposition import WakeSuperposition as WakeSuperposition
+from .wake_superposition import (
+    WindVectorWakeSuperposition as WindVectorWakeSuperposition,
+)

foxes/core/algorithm.py

@@ -63,8 +63,8 @@ class Algorithm(Model):
         self.__farm = farm
         self.__mbook = mbook
         self.__dbook = StaticData() if dbook is None else dbook
-        self.__idata_mem = Dict(name="idata_mem")
-        self.__chunk_store = Dict(name="chunk_store")
+        self.__idata_mem = Dict(_name="idata_mem")
+        self.__chunk_store = Dict(_name="chunk_store")
 
         if len(engine_pars):
             if "engine_type" in engine_pars:
@@ -472,7 +472,6 @@ class Algorithm(Model):
         n_targets = int(tdata.n_targets if tdata is not None else 0)
 
         if prev_s > 0 or prev_t > 0:
-
             inds = np.array(
                 [
                     [
@@ -559,7 +558,7 @@ class Algorithm(Model):
                     "n_states": n_states,
                     "n_targets": n_targets,
                 },
-                name=f"chunk_store_{i0}_{t0}",
+                _name=f"chunk_store_{i0}_{t0}",
             )
 
         self.chunk_store[key][name] = data.copy() if copy else data
@@ -639,11 +638,11 @@ class Algorithm(Model):
         """
         chunk_store = self.chunk_store
         if new_chunk_store is None:
-            self.__chunk_store = Dict(name="chunk_store")
+            self.__chunk_store = Dict(_name="chunk_store")
         elif isinstance(new_chunk_store, Dict):
             self.__chunk_store = new_chunk_store
         else:
-            self.__chunk_store = Dict(name="chunk_store")
+            self.__chunk_store = Dict(_name="chunk_store")
             self.__chunk_store.update(new_chunk_store)
         return chunk_store
 

foxes/core/data.py

@@ -28,9 +28,9 @@ class Data(Dict):
 
     def __init__(
         self,
-        data,
-        dims,
-        loop_dims,
+        data={},
+        dims={},
+        loop_dims=[FC.STATE],
         states_i0=None,
         name="data",
     ):
@@ -53,7 +53,7 @@ class Data(Dict):
             The data container name
 
         """
-        super().__init__(name=name)
+        super().__init__(_name=name)
 
         self.update(data)
         self.dims = dims
@@ -109,12 +109,12 @@ class Data(Dict):
             or the corresponding index
 
         """
-        if FC.STATE not in self:
-            return None
-        elif counter:
+        if counter:
             if self.__states_i0 is None:
                 raise KeyError(f"Data '{self.name}': states_i0 requested but not set")
             return self.__states_i0
+        elif FC.STATE not in self:
+            return None
         else:
             return self[FC.STATE][0]
 
@@ -153,13 +153,13 @@ class Data(Dict):
         # remove axes of size 1, added by dask for extra loop dimensions:
         if dims is not None:
             if len(dims) != len(data.shape):
-                for li, l in enumerate(self.loop_dims):
-                    if data.shape[li] == 1 and (len(dims) < li + 1 or dims[li] != l):
+                for li, ld in enumerate(self.loop_dims):
+                    if data.shape[li] == 1 and (len(dims) < li + 1 or dims[li] != ld):
                         self[name] = np.squeeze(data, axis=li)
             for ci, c in enumerate(dims):
                 if c not in self.sizes or self.sizes[c] == 1:
                     self.sizes[c] = self[name].shape[ci]
-                elif self[name].shape[ci] == 1:
+                elif c != FC.TARGET and self[name].shape[ci] == 1:
                     pass
                 elif self.sizes[c] != self[name].shape[ci]:
                     raise ValueError(
@@ -240,9 +240,14 @@ class Data(Dict):
                 )
         else:
             states_i0 = None
-        return type(self)(
-            data, dims, loop_dims=self.loop_dims, name=name, states_i0=states_i0
-        )
+
+        cls = type(self)
+        if issubclass(cls, Data):
+            return cls(data, dims, name=name, states_i0=states_i0)
+        else:
+            return cls(
+                data, dims, loop_dims=self.loop_dims, name=name, states_i0=states_i0
+            )
 
     @classmethod
     def from_dataset(cls, ds, *args, callback=None, s_states=None, copy=True, **kwargs):
@@ -360,7 +365,7 @@ class FData(Data):
             Arguments for the base class
 
         """
-        super().__init__(*args, name=name, **kwargs)
+        super().__init__(*args, loop_dims=[FC.STATE], name=name, **kwargs)
 
     def _run_entry_checks(self, name, data, dims):
         """Run entry checks on new data"""
@@ -389,6 +394,74 @@ class FData(Data):
                         f"FData '{self.name}': Missing '{x}' in sizes, got {sorted(list(self.sizes.keys()))}"
                     )
 
+    @classmethod
+    def from_sizes(cls, n_states, n_turbines, *args, callback=None, **kwargs):
+        """
+        Create Data object from model data
+
+        Parameters
+        ----------
+        n_states: int
+            The number of states
+        n_turbines: int
+            The number of turbines
+        args: tuple, optional
+            Additional parameters for the constructor
+        callback: Function, optional
+            Function f(data, dims) that manipulates
+            the data and dims dicts before construction
+        kwargs: dict, optional
+            Additional parameters for the constructor
+
+        Returns
+        -------
+        data: Data
+            The data object
+
+        """
+        data = cls(*args, **kwargs)
+        data.sizes[FC.STATE] = n_states
+        data.sizes[FC.TURBINE] = n_turbines
+
+        if callback is not None:
+            callback(data, data.dims)
+
+        return data
+
+    @classmethod
+    def from_mdata(cls, mdata, *args, callback=None, **kwargs):
+        """
+        Create Data object from model data
+
+        Parameters
+        ----------
+        mdata: MData
+            The model data
+        args: tuple, optional
+            Additional parameters for the constructor
+        callback: Function, optional
+            Function f(data, dims) that manipulates
+            the data and dims dicts before construction
+        kwargs: dict, optional
+            Additional parameters for the constructor
+
+        Returns
+        -------
+        data: Data
+            The data object
+
+        """
+        data = cls(*args, **kwargs)
+        for v in [FC.STATE, FC.TURBINE]:
+            data[v] = mdata[v]
+            data.dims[v] = mdata.dims[v]
+            data.sizes[v] = mdata.sizes[v]
+
+        if callback is not None:
+            callback(data, data.dims)
+
+        return data
+
     @classmethod
     def from_dataset(cls, ds, *args, mdata=None, callback=None, **kwargs):
         """
@@ -422,6 +495,9 @@ class FData(Data):
                 if FC.STATE not in data:
                     data[FC.STATE] = mdata[FC.STATE]
                     dims[FC.STATE] = mdata.dims[FC.STATE]
+                if FC.TURBINE not in data:
+                    data[FC.TURBINE] = mdata[FC.TURBINE]
+                    dims[FC.TURBINE] = mdata.dims[FC.TURBINE]
                 if callback is not None:
                     callback(data, dims)
 
@@ -453,7 +529,7 @@ class TData(Data):
             Arguments for the base class
 
         """
-        super().__init__(*args, name=name, **kwargs)
+        super().__init__(*args, loop_dims=[FC.STATE, FC.TARGET], name=name, **kwargs)
 
     def _run_entry_checks(self, name, data, dims):
         """Run entry checks on new data"""
@@ -635,9 +711,7 @@ class TData(Data):
             for v in variables:
                 data[v] = np.full_like(points[:, :, None, 0], np.nan)
                 dims[v] = (FC.STATE, FC.TARGET, FC.TPOINT)
-        return cls(
-            data=data, dims=dims, loop_dims=[FC.STATE, FC.TARGET], name=name, **kwargs
-        )
+        return cls(data=data, dims=dims, name=name, **kwargs)
 
     @classmethod
     def from_tpoints(
@@ -694,9 +768,7 @@ class TData(Data):
             for v in variables:
                 data[v] = np.full_like(tpoints[..., 0], np.nan)
                 dims[v] = (FC.STATE, FC.TARGET, FC.TPOINT)
-        return cls(
-            data=data, dims=dims, loop_dims=[FC.STATE, FC.TARGET], name=name, **kwargs
-        )
+        return cls(data=data, dims=dims, name=name, **kwargs)
 
     @classmethod
     def from_dataset(
@@ -764,7 +836,7 @@ class TData(Data):
                             FC.TPOINT,
                         ):
                             raise ValueError(
-                                f"Expecting coordinates '{ (FC.STATE, FC.TARGET, FC.TPOINT)}' at positions 0-2 for data variable '{v}', got {dims[v]}"
+                                f"Expecting coordinates '{(FC.STATE, FC.TARGET, FC.TPOINT)}' at positions 0-2 for data variable '{v}', got {dims[v]}"
                             )
                         else:
                             data[v] = d[:, s_targets]

foxes/core/data_calc_model.py

@@ -45,8 +45,10 @@ class DataCalcModel(Model):
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        data: tuple of foxes.core.Data
-            The input data
+        data: tuple of foxes.core.Data, optional
+            The input data, typically either (mdata, fdata) in
+            the case of farm calculations, or (mdata, fdata, tdata)
+            for point data calculations
         parameters: dict, optional
             The calculation parameters
 

foxes/core/engine.py

@@ -4,9 +4,8 @@ from abc import ABC, abstractmethod
 from tqdm import tqdm
 from xarray import Dataset
 
-from foxes.core import MData, FData, TData
+from .data import MData, FData, TData
 from foxes.utils import new_instance
-from foxes.config import config
 import foxes.constants as FC
 
 __global_engine_data__ = dict(
@@ -73,7 +72,7 @@ class Engine(ABC):
 
     def __enter__(self):
         if self.__entered:
-            raise ValueError(f"Enter called for already entered engine")
+            raise ValueError("Enter called for already entered engine")
         self.__entered = True
         if not self.initialized:
             self.initialize()
@@ -81,7 +80,7 @@ class Engine(ABC):
 
     def __exit__(self, *exit_args):
         if not self.__entered:
-            raise ValueError(f"Exit called for not entered engine")
+            raise ValueError("Exit called for not entered engine")
         self.__entered = False
         if self.initialized:
             self.finalize(*exit_args)
@@ -127,7 +126,6 @@ class Engine(ABC):
                 raise ValueError(
                     f"Cannot initialize engine '{type(self).__name__}', since engine already set to '{type(get_engine()).__name__}'"
                 )
-            global __global_engine_data__
             __global_engine_data__["engine"] = self
             self.__initialized = True
 
@@ -148,7 +146,6 @@ class Engine(ABC):
         if self.entered:
             self.__exit__(type, value, traceback)
         elif self.initialized:
-            global __global_engine_data__
             __global_engine_data__["engine"] = None
             self.__initialized = False
 
@@ -304,9 +301,9 @@ class Engine(ABC):
                 chunk_sizes_targets[-extra:] += 1
 
             s = np.sum(chunk_sizes_targets)
-            assert (
-                s == n_targets
-            ), f"Targets count mismatch: Expecting {n_targets}, chunks sum is {s}. Chunks: {[int(c) for c in chunk_sizes_targets]}"
+            assert s == n_targets, (
+                f"Targets count mismatch: Expecting {n_targets}, chunks sum is {s}. Chunks: {[int(c) for c in chunk_sizes_targets]}"
+            )
 
         chunk_sizes_states = np.full(n_chunks_states, chunk_size_states)
         extra = n_states - n_chunks_states * chunk_size_states
@@ -314,9 +311,9 @@ class Engine(ABC):
             chunk_sizes_states[-extra:] += 1
 
         s = np.sum(chunk_sizes_states)
-        assert (
-            s == n_states
-        ), f"States count mismatch: Expecting {n_states}, chunks sum is {s}. Chunks: {[int(c) for c in chunk_sizes_states]}"
+        assert s == n_states, (
+            f"States count mismatch: Expecting {n_states}, chunks sum is {s}. Chunks: {[int(c) for c in chunk_sizes_states]}"
+        )
 
         return chunk_sizes_states, chunk_sizes_targets
 
@@ -352,8 +349,9 @@ class Engine(ABC):
 
         Returns
         -------
-        data: list of foxes.core.Data
-            Either [mdata, fdata] or [mdata, fdata, tdata]
+        data: tuple of foxes.core.Data
+            The input data for the chunk calculation,
+            either (mdata, fdata) or (mdata, fdata, tdata)
 
         """
         # prepare:
@@ -372,53 +370,37 @@ class Engine(ABC):
         )
 
         # create fdata:
-        if point_data is None:
-
-            def cb(data, dims):
-                n_states = i1_states - i0_states
-                for o in set(out_vars).difference(data.keys()):
-                    data[o] = np.full(
-                        (n_states, algo.n_turbines), np.nan, dtype=config.dtype_double
-                    )
-                    dims[o] = (FC.STATE, FC.TURBINE)
-
+        if farm_data is not None:
+            fdata = FData.from_dataset(
+                farm_data,
+                mdata=mdata,
+                s_states=s_states,
+                callback=None,
+                states_i0=i0_states,
+                copy=True,
+            )
         else:
-            cb = None
-        fdata = FData.from_dataset(
-            farm_data,
-            mdata=mdata,
-            s_states=s_states,
-            callback=cb,
-            loop_dims=[FC.STATE],
-            states_i0=i0_states,
-            copy=True,
-        )
+            fdata = FData.from_mdata(
+                mdata=mdata,
+                states_i0=i0_states,
+            )
 
         # create tdata:
-        tdata = None
-        if point_data is not None:
-
-            def cb(data, dims):
-                n_states = i1_states - i0_states
-                n_targets = i1_targets - i0_targets
-                for o in set(out_vars).difference(data.keys()):
-                    data[o] = np.full(
-                        (n_states, n_targets, 1), np.nan, dtype=config.dtype_double
-                    )
-                    dims[o] = (FC.STATE, FC.TARGET, FC.TPOINT)
-
-            tdata = TData.from_dataset(
+        tdata = (
+            TData.from_dataset(
                 point_data,
                 mdata=mdata,
                 s_states=s_states,
                 s_targets=s_targets,
-                callback=cb,
-                loop_dims=[FC.STATE, FC.TARGET],
+                callback=None,
                 states_i0=i0_states,
                 copy=True,
             )
+            if point_data is not None
+            else None
+        )
 
-        return [d for d in [mdata, fdata, tdata] if d is not None]
+        return (mdata, fdata) if tdata is None else (mdata, fdata, tdata)
 
     def combine_results(
         self,
@@ -539,7 +521,14 @@ class Engine(ABC):
         )
 
     @abstractmethod
-    def run_calculation(self, algo, model, model_data, farm_data, point_data=None):
+    def run_calculation(
+        self,
+        algo,
+        model,
+        model_data=None,
+        farm_data=None,
+        point_data=None,
+    ):
         """
         Runs the model calculation
 
@@ -547,12 +536,12 @@ class Engine(ABC):
         ----------
         algo: foxes.core.Algorithm
             The algorithm object
-        model: foxes.core.DataCalcModel
+        model: foxes.core.DataCalcModel, optional
             The model that whose calculate function
             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, optional
             The initial point data

foxes/core/farm_controller.py

@@ -171,7 +171,7 @@ class FarmController(FarmDataModel):
         for ti, t in enumerate(algo.farm.turbines):
             if tmis[ti] != len(models[ti]):
                 raise ValueError(
-                    f"Turbine {ti}, {t.name}: Could not find turbine model order that includes all {mtype} turbine models, missing {t.models[tmis[ti]:]}"
+                    f"Turbine {ti}, {t.name}: Could not find turbine model order that includes all {mtype} turbine models, missing {t.models[tmis[ti] :]}"
                 )
 
         return [m.name for m in tmodels], tmsels
@@ -253,7 +253,7 @@ class FarmController(FarmDataModel):
                         prer = m.pre_rotor
                     elif not prer and m.pre_rotor:
                         raise ValueError(
-                            f"Turbine {ti}, {t.name}: Model is classified as pre-rotor, but following the post-rotor model '{t.models[mi-1]}'"
+                            f"Turbine {ti}, {t.name}: Model is classified as pre-rotor, but following the post-rotor model '{t.models[mi - 1]}'"
                         )
                     if m.pre_rotor:
                         prer_models[ti].append(m)