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

foxes/__init__.py

@@ -3,24 +3,28 @@ Farm Optimization and eXtended yield Evaluation Software
 
 """
 
-from .config import config, get_path  # noqa: F401
-from .core import Engine, WindFarm, Turbine, get_engine, reset_engine  # noqa: F401
-from .models import ModelBook  # noqa: F401
-from .data import (
-    parse_Pct_file_name,
-    parse_Pct_two_files,
-    FARM,
-    STATES,
-    PCTCURVE,
-    StaticData,
-)  # noqa: F401
+from .config import config as config
+from .config import get_path as get_path
+from .core import Engine as Engine
+from .core import WindFarm as WindFarm
+from .core import Turbine as Turbine
+from .core import get_engine as get_engine
+from .core import reset_engine as reset_engine
+from .models import ModelBook as ModelBook
 
-from . import algorithms  # noqa: F401
-from . import engines  # noqa: F401
-from . import models  # noqa: F401
-from . import input  # noqa: F401
-from . import output  # noqa: F401
-from . import utils  # noqa: F401
+from .data import parse_Pct_file_name as parse_Pct_file_name
+from .data import parse_Pct_two_files as parse_Pct_two_files
+from .data import FARM as FARM
+from .data import STATES as STATES
+from .data import PCTCURVE as PCTCURVE
+from .data import StaticData as StaticData
+
+from . import algorithms as algorithms
+from . import engines as engines
+from . import models as models
+from . import input as input
+from . import output as output
+from . import utils as utils
 
 import importlib
 from pathlib import Path

foxes/algorithms/__init__.py

@@ -2,10 +2,10 @@
 Algorithms define the main calculation routines.
 """
 
-from .downwind.downwind import Downwind
-from .iterative.iterative import Iterative
-from .sequential import Sequential
+from .downwind.downwind import Downwind as Downwind
+from .iterative.iterative import Iterative as Iterative
+from .sequential import Sequential as Sequential
 
-from . import downwind
-from . import iterative
-from . import sequential
+from . import downwind as downwind
+from . import iterative as iterative
+from . import sequential as sequential

foxes/algorithms/downwind/__init__.py

@@ -1,3 +1,3 @@
-from .downwind import Downwind
+from .downwind import Downwind as Downwind
 
-from . import models
+from . import models as models

foxes/algorithms/downwind/downwind.py

@@ -32,6 +32,8 @@ class Downwind(Algorithm):
     partial_wakes: dict
         The partial wakes mapping. Key: wake model name,
         value: foxes.core.PartialWakesModel
+    deflection: foxes.core.WakeDeflection
+        The wake deflection model
     ground_models: dict
         The ground models mapping. Key: wake model name,
         value: foxes.core.GroundModel
@@ -70,6 +72,7 @@ class Downwind(Algorithm):
         wake_models,
         rotor_model="centre",
         wake_frame="rotor_wd",
+        wake_deflection="no_deflection",
         partial_wakes=None,
         ground_models=None,
         farm_controller="basic_ctrl",
@@ -94,6 +97,8 @@ class Downwind(Algorithm):
         wake_frame: str
             The wake frame. Will be looked up in the
             model book
+        deflection: foxes.core.WakeDeflection, optional
+            The wake deflection model
         partial_wakes: dict, list or str, optional
             The partial wakes mapping. Key: wake model name,
             value: partial wake model name
@@ -123,6 +128,9 @@ class Downwind(Algorithm):
         self.__wake_frame = self.mbook.wake_frames.get_item(wake_frame)
         self.wake_frame.name = wake_frame
 
+        self.__wake_deflection = self.mbook.wake_deflections.get_item(wake_deflection)
+        self.wake_deflection.name = wake_deflection
+
         self.__wake_models = {}
         for w in wake_models:
             m = self.mbook.wake_models.get_item(w)
@@ -251,6 +259,19 @@ class Downwind(Algorithm):
         """
         return self.__wake_frame
 
+    @property
+    def wake_deflection(self):
+        """
+        The wake deflection
+
+        Returns
+        -------
+        m: foxes.core.WakeDeflection
+            The wake deflection model
+
+        """
+        return self.__wake_deflection
+
     @property
     def partial_wakes(self):
         """
@@ -310,6 +331,15 @@ class Downwind(Algorithm):
         """
         return getattr(mdls, name)
 
+    def update_n_turbines(self):
+        """
+        Reset the number of turbines,
+        according to self.farm
+        """
+        if self.n_turbines != self.farm.n_turbines:
+            super().update_n_turbines()
+            self.farm_controller.find_turbine_types(self)
+
     def print_deco(self, func_name=None, n_points=None):
         """
         Helper function for printing model names
@@ -334,25 +364,26 @@ class Downwind(Algorithm):
             if n_points is not None:
                 print(f"  n_points : {n_points}")
             print(deco)
-            print(f"  states   : {self.states}")
-            print(f"  rotor    : {self.rotor_model}")
+            print(f"  states    : {self.states}")
+            print(f"  rotor     : {self.rotor_model}")
             print(f"  controller: {self.farm_controller}")
             print(f"  wake frame: {self.wake_frame}")
+            print(f"  deflection: {self.wake_deflection}")
             print(deco)
-            print(f"  wakes:")
+            print("  wakes:")
             for i, w in enumerate(self.wake_models.values()):
                 print(f"    {i}) {w.name}: {w}")
             print(deco)
-            print(f"  partial wakes:")
+            print("  partial wakes:")
             for i, (w, p) in enumerate(self.partial_wakes.items()):
                 print(f"    {i}) {w}: {p.name}, {p}")
             print(deco)
-            print(f"  turbine models:")
+            print("  turbine models:")
             for i, m in enumerate(self.farm_controller.pre_rotor_models.models):
                 print(f"    {i}) {m.name}: {m} [pre-rotor]")
             for i, m in enumerate(self.farm_controller.post_rotor_models.models):
                 print(
-                    f"    {i+len(self.farm_controller.pre_rotor_models.models)}) {m.name}: {m}"
+                    f"    {i + len(self.farm_controller.pre_rotor_models.models)}) {m.name}: {m}"
                 )
             print(deco)
             print()
@@ -364,7 +395,7 @@ class Downwind(Algorithm):
         if self.verbosity > 0:
             deco = "-" * 50
             print(f"\n{deco}")
-            print(f"  Model oder")
+            print("  Model oder")
             print(f"{deco}")
 
             for i, m in enumerate(mlist.models):
@@ -402,6 +433,7 @@ class Downwind(Algorithm):
             self.states,
             self.farm_controller,
             self.rotor_model,
+            self.wake_deflection,
             self.wake_frame,
         ]
         mdls += list(self.wake_models.values())
@@ -463,7 +495,7 @@ class Downwind(Algorithm):
             calc_pars.append(calc_parameters.get(mlist.models[-1].name, {}))
 
         # 6) reorder back to state-turbine dimensions:
-        if outputs != False:
+        if not isinstance(outputs, bool) or outputs:
             mlist.models.append(self.get_model("ReorderFarmOutput")(outputs))
             calc_pars.append(calc_parameters.get(mlist.models[-1].name, {}))
 
@@ -573,8 +605,8 @@ class Downwind(Algorithm):
         # get input model data:
         model_data = self.get_models_data()
         self.print("\nInput data:\n\n", model_data, "\n")
-        self.print(f"\nFarm variables:", ", ".join(self.farm_vars))
-        self.print(f"\nOutput variables:", ", ".join(outputs))
+        self.print("\nFarm variables:", ", ".join(self.farm_vars))
+        self.print("\nOutput variables:", ", ".join(outputs))
 
         # run main calculation:
         farm_results = super().calc_farm(
@@ -779,7 +811,7 @@ class Downwind(Algorithm):
         if persist_mdata:
             model_data = model_data.persist()
         self.print("\nInput data:\n\n", model_data, "\n")
-        self.print(f"\nOutput farm variables:", ", ".join(self.farm_vars))
+        self.print("\nOutput farm variables:", ", ".join(self.farm_vars))
 
         # chunk farm results:
         self.print("\nInput farm data:\n\n", farm_results, "\n")
@@ -798,7 +830,7 @@ class Downwind(Algorithm):
 
         # check vars:
         ovars = mlist.output_point_vars(self) if outputs is None else outputs
-        self.print(f"\nOutput point variables:", ", ".join(ovars))
+        self.print("\nOutput point variables:", ", ".join(ovars))
 
         # calculate:
         point_results = super().calc_points(

foxes/algorithms/downwind/models/__init__.py

@@ -1,6 +1,6 @@
-from .set_amb_farm_results import SetAmbFarmResults
-from .set_amb_point_results import SetAmbPointResults
-from .farm_wakes_calc import FarmWakesCalculation
-from .point_wakes_calc import PointWakesCalculation
-from .init_farm_data import InitFarmData
-from .reorder_farm_output import ReorderFarmOutput
+from .set_amb_farm_results import SetAmbFarmResults as SetAmbFarmResults
+from .set_amb_point_results import SetAmbPointResults as SetAmbPointResults
+from .farm_wakes_calc import FarmWakesCalculation as FarmWakesCalculation
+from .point_wakes_calc import PointWakesCalculation as PointWakesCalculation
+from .init_farm_data import InitFarmData as InitFarmData
+from .reorder_farm_output import ReorderFarmOutput as ReorderFarmOutput

foxes/algorithms/downwind/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
 
@@ -69,8 +69,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"""
@@ -78,12 +84,10 @@ class FarmWakesCalculation(FarmDataModel):
             wdelta = {v: d[s] for v, d in wdeltas.items()}
             return tdata, wdelta
 
-        def _evaluate(
-            gmodel, tdata, amb_res, rwghts, wake_res, wdeltas, oi, wmodel, pwake
-        ):
+        def _evaluate(gmodel, tdata, rwghts, wake_res, wdeltas, oi, wmodel, pwake):
             """Helper function for data evaluation at turbines"""
             wres = gmodel.finalize_farm_wakes(
-                algo, mdata, fdata, tdata, amb_res, rwghts, wdeltas, wmodel, oi, pwake
+                algo, mdata, fdata, tdata, rwghts, wdeltas, wmodel, oi, pwake
             )
 
             hres = {
@@ -124,7 +128,6 @@ class FarmWakesCalculation(FarmDataModel):
                         _evaluate(
                             gmodel,
                             tdatap,
-                            amb_res,
                             rwghts,
                             wake_res,
                             wdeltas,
@@ -149,7 +152,6 @@ class FarmWakesCalculation(FarmDataModel):
                         _evaluate(
                             gmodel,
                             tdatap,
-                            amb_res,
                             rwghts,
                             wake_res,
                             wdeltas,

foxes/algorithms/downwind/models/init_farm_data.py

@@ -86,7 +86,6 @@ class InitFarmData(FarmDataModel):
         # set X, Y, H, D:
         fdata[FV.D] = np.zeros((n_states, n_turbines), dtype=config.dtype_double)
         for ti, t in enumerate(algo.farm.turbines):
-
             if len(t.xy.shape) == 1:
                 fdata[FV.TXYH][:, ti, :2] = t.xy[None, :]
             else:

foxes/algorithms/downwind/models/point_wakes_calc.py

@@ -1,4 +1,5 @@
 from foxes.core import PointDataModel
+import foxes.variables as FV
 
 
 class PointWakesCalculation(PointDataModel):
@@ -114,17 +115,17 @@ class PointWakesCalculation(PointDataModel):
             (n_states, n_targets, n_tpoints)
 
         """
-        res = {}
+
         wmodels = (
             algo.wake_models.values() if self.wake_models is None else self.wake_models
         )
+        pvrs = self.pvars + [FV.UV]
         for wmodel in wmodels:
             gmodel = algo.ground_models[wmodel.name]
 
             wdeltas = gmodel.new_point_wake_deltas(algo, mdata, fdata, tdata, wmodel)
 
-            if len(set(self.pvars).intersection(wdeltas.keys())):
-
+            if len(set(pvrs).intersection(wdeltas.keys())):
                 if downwind_index is None:
                     for oi in range(fdata.n_turbines):
                         gmodel.contribute_to_point_wakes(
@@ -135,18 +136,11 @@ class PointWakesCalculation(PointDataModel):
                         algo, mdata, fdata, tdata, downwind_index, wdeltas, wmodel
                     )
 
-                for v in self.pvars:
-                    if v not in res and v in tdata:
-                        res[v] = tdata[v].copy()
+                gmodel.finalize_point_wakes(algo, mdata, fdata, tdata, wdeltas, wmodel)
 
-                gmodel.finalize_point_wakes(algo, mdata, fdata, res, wdeltas, wmodel)
-
-                for v in res.keys():
+                for v in tdata.keys():
                     if v in wdeltas:
-                        res[v] += wdeltas[v]
-
-        for v in res.keys():
-            tdata[v] = res[v]
+                        tdata[v] += wdeltas[v]
 
         if self.emodels is not None:
             self.emodels.calculate(algo, mdata, fdata, tdata, self.emodels_cpars)

foxes/algorithms/downwind/models/set_amb_point_results.py

@@ -60,7 +60,7 @@ class SetAmbPointResults(PointDataModel):
         """
         return [FV.var2amb[v] for v in self.vars] + [FV.WEIGHT]
 
-    def calculate(self, algo, mdata, fdata, pdata):
+    def calculate(self, algo, mdata, fdata, tdata):
         """
         The main model calculation.
 
@@ -71,11 +71,11 @@ class SetAmbPointResults(PointDataModel):
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
+        mdata: foxes.core.MData
             The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
-        pdata: foxes.core.Data
+        tdata: foxes.core.TData
             The point data
 
         Returns
@@ -86,5 +86,5 @@ class SetAmbPointResults(PointDataModel):
 
         """
         for v in self.vars:
-            pdata[FV.var2amb[v]] = pdata[v].copy()
-        return {v: pdata[v] for v in self.output_point_vars(algo)}
+            tdata.add(FV.var2amb[v], tdata[v].copy(), tdata.dims[v])
+        return {v: tdata[v] for v in self.output_point_vars(algo)}

foxes/algorithms/iterative/__init__.py

@@ -1,4 +1,8 @@
-from .iterative import Iterative
-from .models.convergence import ConvCrit, ConvCritList, ConvVarDelta, DefaultConv
+from .iterative import Iterative as Iterative
 
-from . import models
+from .models.convergence import ConvCrit as ConvCrit
+from .models.convergence import ConvCritList as ConvCritList
+from .models.convergence import ConvVarDelta as ConvVarDelta
+from .models.convergence import DefaultConv as DefaultConv
+
+from . import models as models

foxes/algorithms/iterative/iterative.py

@@ -114,7 +114,7 @@ class Iterative(Downwind):
 
         """
         if self.initialized:
-            raise ValueError(f"Attempt to set_urelax after initialization")
+            raise ValueError("Attempt to set_urelax after initialization")
         if self._urelax is None:
             self._urelax = Dict(
                 first={},
@@ -219,7 +219,6 @@ class Iterative(Downwind):
 
             # do not rotate back from downwind order:
             if not self._final_run:
-
                 # add under-relaxation during wake calculation:
                 urelax = None
                 if self._urelax is not None and len(self._urelax["pre_wake"]):

foxes/algorithms/iterative/models/__init__.py

@@ -1,3 +1,7 @@
-from .convergence import ConvCrit, ConvCritList, ConvVarDelta, DefaultConv
-from .farm_wakes_calc import FarmWakesCalculation
-from .urelax import URelax
+from .convergence import ConvCrit as ConvCrit
+from .convergence import ConvCritList as ConvCritList
+from .convergence import ConvVarDelta as ConvVarDelta
+from .convergence import DefaultConv as DefaultConv
+
+from .farm_wakes_calc import FarmWakesCalculation as FarmWakesCalculation
+from .urelax import URelax as URelax

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

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