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

foxes/algorithms/sequential/models/seq_state.py

@@ -30,7 +30,6 @@ class SeqState(States):
 
         # updated by SequentialIter:
         self._size = states.size()
-        self._weight = None
         self._indx = None
         self._counter = None
 
@@ -100,23 +99,6 @@ class SeqState(States):
         """
         return self._counter
 
-    def weights(self, algo):
-        """
-        The statistical weights of all states.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-
-        Returns
-        -------
-        weights: numpy.ndarray
-            The weights, shape: (n_states, n_turbines)
-
-        """
-        return self._weight[None, :] if self._size == 1 else self.states.weights(algo)
-
     def output_point_vars(self, algo):
         """
         The variables which are being modified by the model.

foxes/algorithms/sequential/sequential.py

@@ -139,7 +139,6 @@ class Sequential(Iterative):
             self.print_deco("calc_farm")
 
             self._inds = self.states0.index()
-            self._weights = self.states0.weights(self)
             self._i = 0
             self._counter = 0
 
@@ -155,15 +154,18 @@ 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()
             self._farm_results = Dataset(
-                coords={FC.STATE: self._model_data[FC.STATE].to_numpy()},
+                coords={FC.STATE: sts},
                 data_vars={
                     v: (
                         (FC.STATE, FC.TURBINE),
-                        np.zeros_like(self._model_data[FV.WEIGHT].to_numpy()),
+                        np.zeros(
+                            (len(sts), self.n_turbines), dtype=config.dtype_double
+                        ),
                     )
                     for v in self.farm_vars
                 },
@@ -186,12 +188,10 @@ 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
             self.states._indx = self._inds[self._i]
-            self.states._weight = self._weights[self._i]
 
             if self._verbo0 > 0:
                 print(f"{self.name}: Running state {self.states.index()[0]}")
@@ -257,7 +257,6 @@ class Sequential(Iterative):
             self.states._counter = None
             self.states._size = len(self._inds)
             self.states._indx = self._inds
-            self.states._weight = self._weights
 
             for p in self.plugins:
                 p.finalize(self)
@@ -323,19 +322,6 @@ class Sequential(Iterative):
         """
         return self.counter if counter else self.index
 
-    @property
-    def weight(self):
-        """
-        The current weight array
-
-        Returns
-        -------
-        w: numpy.ndarray
-            The current weight array, shape: (n_turbines,)
-
-        """
-        return self.states._weight if self.iterating else None
-
     @property
     def farm_results(self):
         """
@@ -414,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(
@@ -446,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
@@ -73,11 +78,17 @@ ROTOR_WEIGHTS = "rotor_weights"
 """ Identifier for rotor point weights
 :group: foxes.constants
 """
+
 AMB_ROTOR_RES = "amb_rotor_res"
 """ Identifier for ambient rotor point results
 :group: foxes.constants
 """
 
+WEIGHT_RES = "weight_res"
+""" Identifier for weights results at rotor points
+:group: foxes.constants
+"""
+
 
 VARS = "vars"
 """ Variables identifier
@@ -140,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

@@ -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(
                 [
                     [

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",
     ):
@@ -153,13 +153,14 @@ 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:
+                if c not in self.sizes or self.sizes[c] == 1:
                     self.sizes[c] = self[name].shape[ci]
+                elif c != FC.TARGET and self[name].shape[ci] == 1:
+                    pass
                 elif self.sizes[c] != self[name].shape[ci]:
                     raise ValueError(
                         f"Inconsistent size for data entry '{name}', dimension '{c}': Expecting {self.sizes[c]}, found {self[name].shape[ci]} in shape {self[name].shape}"
@@ -239,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):
@@ -288,12 +294,16 @@ class Data(Dict):
                     raise ValueError(
                         f"Expecting coordinate '{FC.STATE}' at position 0 for data variable '{v}', got {d.dims}"
                     )
-                n_states = len(d.to_numpy())
+                n_states = d.shape[0]
                 s = np.s_[:] if s_states is None else s_states
                 data[v] = d.to_numpy()[s].copy() if copy else d.to_numpy()[s]
+                dims[v] = d.dims
+                if v == FV.WEIGHT and d.dims == (FC.STATE,):
+                    data[v] = data[v][:, None]
+                    dims[v] = (FC.STATE, FC.TURBINE)
             else:
                 data[v] = d.to_numpy().copy() if copy else d.to_numpy()
-            dims[v] = d.dims
+                dims[v] = d.dims
 
         if callback is not None:
             callback(data, dims)
@@ -355,15 +365,14 @@ 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"""
         super()._run_entry_checks(name, data, dims)
         data = self[name]
         dims = self.dims[name]
-
-        if name not in self.sizes and name not in FC.TNAME:
+        if name not in self.sizes and name not in [FC.TNAME, FV.WEIGHT]:
             dms = (FC.STATE, FC.TURBINE)
             shp = (self.n_states, self.n_turbines)
             if len(data.shape) < 2:
@@ -418,8 +427,6 @@ class FData(Data):
                 if FC.STATE not in data:
                     data[FC.STATE] = mdata[FC.STATE]
                     dims[FC.STATE] = mdata.dims[FC.STATE]
-                    data[FV.WEIGHT] = mdata[FV.WEIGHT]
-                    dims[FV.WEIGHT] = mdata.dims[FV.WEIGHT]
                 if callback is not None:
                     callback(data, dims)
 
@@ -451,7 +458,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"""
@@ -587,8 +594,9 @@ class TData(Data):
     def from_points(
         cls,
         points,
-        data={},
-        dims={},
+        data=None,
+        dims=None,
+        variables=None,
         name="tdata",
         **kwargs,
     ):
@@ -599,11 +607,14 @@ class TData(Data):
         ----------
         points: np.ndarray
             The points, shape: (n_states, n_points, 3)
-        data: dict
+        data: dict, optional
             The initial data to be stored
-        dims: dict
+        dims: dict, optional
             The dimensions tuples, same or subset
             of data keys
+        variables: list of str
+            Add default empty variables with NaN values
+            and shape (n_states, n_targets, n_tpoints)
         name: str
             The data container name
         kwargs: dict, optional
@@ -619,19 +630,26 @@ class TData(Data):
             raise ValueError(
                 f"Expecting points shape (n_states, n_points, 3), got {points.shape}"
             )
+        data = {} if data is None else data
+        dims = {} if dims is None else dims
         data[FC.TARGETS] = points[:, :, None, :]
         dims[FC.TARGETS] = (FC.STATE, FC.TARGET, FC.TPOINT, FC.XYH)
         data[FC.TWEIGHTS] = np.array([1], dtype=config.dtype_double)
         dims[FC.TWEIGHTS] = (FC.TPOINT,)
-        return cls(data, dims, [FC.STATE, FC.TARGET], name=name, **kwargs)
+        if variables is not None:
+            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, name=name, **kwargs)
 
     @classmethod
     def from_tpoints(
         cls,
         tpoints,
         tweights,
-        data={},
-        dims={},
+        data=None,
+        dims=None,
+        variables=None,
         name="tdata",
         **kwargs,
     ):
@@ -646,11 +664,14 @@ class TData(Data):
         tweights: np.ndarray, optional
             The target point weights, shape:
             (n_tpoints,)
-        data: dict
+        data: dict, optional
             The initial data to be stored
-        dims: dict
+        dims: dict, optional
             The dimensions tuples, same or subset
             of data keys
+        variables: list of str
+            Add default empty variables with NaN values
+            and shape (n_states, n_targets, n_tpoints)
         name: str
             The data container name
         kwargs: dict, optional
@@ -666,11 +687,17 @@ class TData(Data):
             raise ValueError(
                 f"Expecting tpoints shape (n_states, n_targets, n_tpoints, 3), got {tpoints.shape}"
             )
+        data = {} if data is None else data
+        dims = {} if dims is None else dims
         data[FC.TARGETS] = tpoints
         dims[FC.TARGETS] = (FC.STATE, FC.TARGET, FC.TPOINT, FC.XYH)
         data[FC.TWEIGHTS] = tweights
         dims[FC.TWEIGHTS] = (FC.TPOINT,)
-        return cls(data, dims, [FC.STATE], name=name, **kwargs)
+        if variables is not None:
+            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, name=name, **kwargs)
 
     @classmethod
     def from_dataset(
@@ -738,7 +765,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/engine.py

@@ -4,7 +4,7 @@ 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
@@ -73,7 +73,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 +81,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 +127,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 +147,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 +302,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 +312,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
 
@@ -389,7 +387,6 @@ class Engine(ABC):
             mdata=mdata,
             s_states=s_states,
             callback=cb,
-            loop_dims=[FC.STATE],
             states_i0=i0_states,
             copy=True,
         )
@@ -413,7 +410,6 @@ class Engine(ABC):
                 s_states=s_states,
                 s_targets=s_targets,
                 callback=cb,
-                loop_dims=[FC.STATE, FC.TARGET],
                 states_i0=i0_states,
                 copy=True,
             )
@@ -515,9 +511,27 @@ class Engine(ABC):
         if FC.STATE in out_coords and FC.STATE in model_data.coords:
             coords[FC.STATE] = model_data[FC.STATE].to_numpy()
 
+        # reducing weights dimensions:
+        dvars = {}
+        for v, (dims, d) in data_vars.items():
+            if (
+                dims == (FC.STATE, FC.TURBINE)
+                and d.shape[1] == 1
+                and algo.n_turbines > 1
+            ):
+                dvars[v] = ((FC.STATE,), d[:, 0])
+            elif (
+                dims == (FC.STATE, FC.TARGET, FC.TPOINT)
+                and goal_data.sizes[FC.TARGET] > n_chunks_targets
+                and d.shape[1:] == (n_chunks_targets, 1)
+            ):
+                dvars[v] = ((FC.STATE,), d[:, 0, 0])
+            else:
+                dvars[v] = (dims, d)
+
         return Dataset(
             coords=coords,
-            data_vars={v: tuple(d) for v, d in data_vars.items()},
+            data_vars=dvars,
         )
 
     @abstractmethod

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)

foxes/core/farm_data_model.py

@@ -246,6 +246,7 @@ class FarmDataModelList(FarmDataModel):
         ovars = []
         for m in self.models:
             ovars += m.output_farm_vars(algo)
+
         return list(dict.fromkeys(ovars))
 
     def calculate(self, algo, mdata, fdata, parameters=[]):

foxes/core/ground_model.py

@@ -91,7 +91,6 @@ class GroundModel(Model):
         mdata,
         fdata,
         tdata,
-        amb_res,
         rpoint_weights,
         wake_deltas,
         wmodel,
@@ -114,11 +113,6 @@ class GroundModel(Model):
             The farm data
         tdata: foxes.core.Data
             The target point data
-        amb_res: dict
-            The ambient results at the target points
-            of all rotors. Key: variable name, value
-            np.ndarray of shape:
-            (n_states, n_turbines, n_rotor_points)
         rpoint_weights: numpy.ndarray
             The rotor point weights, shape: (n_rotor_points,)
         wake_deltas: dict
@@ -143,7 +137,6 @@ class GroundModel(Model):
             mdata,
             fdata,
             tdata,
-            amb_res,
             rpoint_weights,
             wake_deltas,
             wmodel,
@@ -226,7 +219,7 @@ class GroundModel(Model):
         algo,
         mdata,
         fdata,
-        amb_results,
+        tdata,
         wake_deltas,
         wmodel,
     ):
@@ -243,17 +236,15 @@ class GroundModel(Model):
             The model data
         fdata: foxes.core.FData
             The farm data
-        amb_results: dict
-            The ambient results, key: variable name str,
-            values: numpy.ndarray with shape
-            (n_states, n_targets, n_tpoints)
+        tdata: foxes.core.TData
+            The target point data
         wake_deltas: dict
             The wake deltas object at the selected target
             turbines. Key: variable str, value: numpy.ndarray
             with shape (n_states, n_targets, n_tpoints)
 
         """
-        wmodel.finalize_wake_deltas(algo, mdata, fdata, amb_results, wake_deltas)
+        wmodel.finalize_wake_deltas(algo, mdata, fdata, tdata, wake_deltas)
 
     @classmethod
     def new(cls, ground_type, *args, **kwargs):