foxes 1.5.1__tar.gz → 1.5.2__tar.gz

{foxes-1.5.1/foxes.egg-info → foxes-1.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: foxes
-Version: 1.5.1
+Version: 1.5.2
 Summary: Farm Optimization and eXtended yield Evaluation Software
 Author: Jonas Schulte
 Maintainer: Jonas Schulte
@@ -47,17 +47,16 @@ Classifier: Development Status :: 4 - Beta
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: cycler>=0.10
-Requires-Dist: h5netcdf>=1.0
 Requires-Dist: matplotlib>=3.8
 Requires-Dist: numpy>=1.26
 Requires-Dist: pandas>=2.0
-Requires-Dist: pyyaml>=4.0
 Requires-Dist: scipy>=1.12
-Requires-Dist: tqdm>=2.0
 Requires-Dist: xarray>=2023
+Requires-Dist: h5netcdf>=1.0
+Requires-Dist: pyyaml>=4.0
+Requires-Dist: tqdm>=2.0
 Provides-Extra: opt
-Requires-Dist: foxes-opt>=0.5; extra == "opt"
+Requires-Dist: foxes-opt>=0.6; extra == "opt"
 Provides-Extra: dask
 Requires-Dist: dask>=2022.0; extra == "dask"
 Requires-Dist: distributed>=2022.0; extra == "dask"

{foxes-1.5.1 → foxes-1.5.2}/foxes/input/yaml/windio/read_attributes.py

@@ -167,7 +167,13 @@ def _read_blockage(blockage_model, induction, algo_dict, mbook, verbosity):
         print("      Name:", wname)
         print("      Contents:", [k for k in blockage_model.keys()])
     if wname not in ["None", "none"]:
-        indc_dict = Dict(wmodel_type=indc_def_map[wname], induction=induction)
+        kys = list(blockage_model.keys())
+        for k in kys:
+            if len(k) > 3 and k[:3] == "ss_":
+                blockage_model[k[3:]] = blockage_model.pop_item(k)
+        indc_dict = Dict(
+            wmodel_type=indc_def_map[wname], induction=induction, **blockage_model
+        )
         mbook.wake_models[wname] = WakeModel.new(**indc_dict)
         if verbosity > 2:
             print(f"      Created wake model '{wname}':")
@@ -378,7 +384,7 @@ def read_attributes(wio_attrs, idict, mbook, verbosity=1):
             print("    Reading flow_model")
             print("      Name:", fmname)
             print("      Contents:", [k for k in flow_model.keys()])
-        if fmname != "foxes":
+        if verbosity > 0 and fmname != "foxes":
             print(f"Running flow model 'foxes', overruling original choice '{fmname}'")
 
     # read analysis:

{foxes-1.5.1 → foxes-1.5.2}/foxes/input/yaml/windio/read_farm.py

@@ -3,7 +3,9 @@ import pandas as pd
 
 from foxes.utils import Dict
 from foxes.core import Turbine, TurbineType, WindFarm
+from foxes.models.farm_controllers import BasicFarmController, OpFlagController
 import foxes.variables as FV
+import foxes.constants as FC
 
 
 def read_turbine_types(wio_farm, mbook, ws_exp_P, ws_exp_ct, verbosity):
@@ -204,6 +206,22 @@ def read_farm(wio_dict, mbook, verbosity):
         ws_exp_P = 1
         ws_exp_ct = 1
 
+    # create farm controller:
+    if FV.OPERATING in wio_farm:
+        op_dims, operating = wio_farm.pop_item(FV.OPERATING)
+        assert (
+            len(op_dims) == 2
+            and op_dims[1] == FC.TURBINE
+            and op_dims[0] in [FC.STATE, FC.TIME]
+        ), f"Expecting operating field to have dims (state, turbine), got {op_dims}"
+        mbook.farm_controllers["farm_cntrl"] = OpFlagController(operating)
+    else:
+        mbook.farm_controllers["farm_cntrl"] = BasicFarmController()
+    if verbosity > 1:
+        print(
+            f"  Farm controller type: {type(mbook.farm_controllers['farm_cntrl']).__name__}"
+        )
+
     # read turbine type:
     ttypes = read_turbine_types(wio_farm, mbook, ws_exp_P, ws_exp_ct, verbosity)
 
@@ -211,6 +229,8 @@ def read_farm(wio_dict, mbook, verbosity):
     farm = WindFarm()
     wfarm = wio_farm["layouts"]
     if isinstance(wfarm, dict):
+        if "coordinates" in wfarm:
+            wfarm = {"0": wfarm}
         layouts = Dict(wfarm, _name=wio_farm.name + ".layouts")
     else:
         layouts = {str(i): lf for i, lf in enumerate(wfarm)}

{foxes-1.5.1 → foxes-1.5.2}/foxes/input/yaml/windio/read_fields.py

@@ -24,6 +24,7 @@ wio2foxes = {
     "reference_height": FV.H,
     "weibull_a": FV.WEIBULL_A,
     "weibull_k": FV.WEIBULL_k,
+    "operating": FV.OPERATING,
 }
 
 """ Mapping from foxes to windio variables
@@ -137,6 +138,7 @@ def read_wind_resource_field(
     """
     if name in [
         "potential_temperature",
+        "real_temperature",
         "friction_velocity",
         "k",
         "epsilon",
@@ -180,6 +182,7 @@ def read_wind_resource_field(
         "reference_height",
         "weibull_a",
         "weibull_k",
+        "operating",
     ] and _read_multi_dimensional_data(name, wio_data, fields, dims):
         return True
 

{foxes-1.5.1 → foxes-1.5.2}/foxes/input/yaml/windio/read_outputs.py

@@ -110,14 +110,28 @@ def _read_flow_field(wio_outs, olist, algo, states_isel, verbosity):
             assert len(xb) == 2, f"Expecting two entries for x_bounds, got {xb}"
             yb = z_planes.pop_item("y_bounds")
             assert len(yb) == 2, f"Expecting two entries for y_bounds, got {yb}"
-            dx = z_planes.pop_item("dx")
-            dy = z_planes.pop_item("dy")
-            nx = max(int((xb[1] - xb[0]) / dx), 1) + 1
-            if (xb[1] - xb[0]) / (nx - 1) > dx:
-                nx += 1
-            ny = max(int((yb[1] - yb[0]) / dy), 1) + 1
-            if (yb[1] - yb[0]) / (ny - 1) > dy:
-                ny += 1
+            if "dx" in z_planes or "dy" in z_planes:
+                assert "dx" in z_planes and "dy" in z_planes, (
+                    f"Expecting both 'dx' and 'dy' in z_planes, got {list(z_planes.keys())}"
+                )
+                dx = z_planes.pop_item("dx")
+                dy = z_planes.pop_item("dy")
+                nx = max(int((xb[1] - xb[0]) / dx), 1) + 1
+                if (xb[1] - xb[0]) / (nx - 1) > dx:
+                    nx += 1
+                ny = max(int((yb[1] - yb[0]) / dy), 1) + 1
+                if (yb[1] - yb[0]) / (ny - 1) > dy:
+                    ny += 1
+            elif "Nx" in z_planes or "Ny" in z_planes:
+                assert "Nx" in z_planes and "Ny" in z_planes, (
+                    f"Expecting both 'Nx' and 'Ny' in z_planes, got {list(z_planes.keys())}"
+                )
+                nx = z_planes.pop_item("Nx")
+                ny = z_planes.pop_item("Ny")
+            else:
+                raise KeyError(
+                    f"Expecting either 'dx' and 'dy' or 'Nx' and 'Ny' in z_planes, got {list(z_planes.keys())}"
+                )
             z_list = np.asarray(z_list)
             if verbosity > 2:
                 print("          x_bounds      :", xb)
@@ -186,11 +200,10 @@ def read_outputs(wio_outs, idict, algo, verbosity=1):
 
     # read subset:
     run_configuration = wio_outs.pop_item("run_configuration", {})
+    states_isel = None
     if "times_run" in run_configuration:
         times_run = run_configuration.pop_item("times_run")
-        if times_run.get_item("all_occurences"):
-            states_isel = None
-        else:
+        if not times_run.get_item("all_occurences"):
             states_isel = times_run.get_item("subset")
     elif "wind_speeds_run" in run_configuration:
         wind_speeds_run = run_configuration.get_item("wind_speeds_run")
@@ -203,7 +216,6 @@ def read_outputs(wio_outs, idict, algo, verbosity=1):
             raise NotImplementedError(
                 f"Wind speed and direction subsets are not yet supported, got {directions_run.name} {directions_run}"
             )
-        states_isel = None
 
     # read turbine_outputs:
     _read_turbine_outputs(wio_outs, olist, algo, states_isel, verbosity)

{foxes-1.5.1 → foxes-1.5.2}/foxes/input/yaml/windio/read_site.py

@@ -11,6 +11,14 @@ import foxes.constants as FC
 from .read_fields import read_wind_resource_field
 
 
+default_values = {
+    FV.WS: 8.0,
+    FV.WD: 270.0,
+    FV.TI: 0.1,
+    FV.RHO: 1.225,
+}
+
+
 def _get_profiles(coords, fields, dims, ovars, fixval, verbosity):
     """Read ABL profiles information
     :group: input.yaml.windio
@@ -22,6 +30,8 @@ def _get_profiles(coords, fields, dims, ovars, fixval, verbosity):
                 print(
                     f"Ignoring '{FV.Z0}', since no reference_height found. No ABL profile activated."
                 )
+            fields.pop(FV.Z0)
+            dims.pop(FV.Z0)
         elif FV.MOL in fields:
             ovars.append(FV.MOL)
             fixval[FV.H] = fields[FV.H]
@@ -56,7 +66,7 @@ def _get_SingleStateStates(
 
     smap = {FV.WS: "ws", FV.WD: "wd", FV.TI: "ti", FV.RHO: "rho"}
 
-    data = {smap[v]: d for v, d in fixval.items()}
+    data = {smap[v]: fixval.get(v, default_values[v]) for v in ovars}
     for v, d in coords.items():
         if v in smap:
             data[smap[v]] = d
@@ -91,7 +101,7 @@ def _get_Timeseries(
             print("        selecting class 'Timeseries'")
 
         data = {}
-        fix = {}
+        fix = {v: fixval.get(v, default_values[v]) for v in ovars if v not in fields}
         for v, d in fields.items():
             if dims[v] == (FC.TIME,):
                 data[v] = d
@@ -99,7 +109,6 @@ def _get_Timeseries(
                 fix[v] = d
             elif verbosity > 2:
                 print(f"        ignoring field '{v}' with dims {dims[v]}")
-        fix.update({v: d for v, d in fixval.items() if v not in data})
 
         sdata = pd.DataFrame(index=coords[FC.TIME], data=data)
         sdata.index.name = FC.TIME
@@ -132,7 +141,7 @@ def _get_MultiHeightNCTimeseries(
             )
 
         data = {}
-        fix = {}
+        fix = {v: fixval.get(v, default_values[v]) for v in ovars if v not in fields}
         for v, d in fields.items():
             if dims[v] == (FC.TIME, FV.H):
                 data[v] = ((FC.TIME, FV.H), d)
@@ -142,7 +151,6 @@ def _get_MultiHeightNCTimeseries(
                 fix[v] = d
             elif verbosity > 2:
                 print(f"        ignoring field '{v}' with dims {dims[v]}")
-        fix.update({v: d for v, d in fixval.items() if v not in data})
 
         sdata = Dataset(coords=coords, data_vars=data)
         states_dict.update(
@@ -153,6 +161,7 @@ def _get_MultiHeightNCTimeseries(
                 data_source=sdata,
                 output_vars=ovars,
                 fixed_vars=fix,
+                bounds_error=False,
             )
         )
         return True
@@ -177,7 +186,7 @@ def _get_WeibullSectors(
             print("        selecting class 'WeibullSectors'")
 
         data = {}
-        fix = {}
+        fix = {v: fixval.get(v, default_values[v]) for v in ovars if v not in fields}
         c = dims[FV.WEIBULL_A][0]
         for v, d in fields.items():
             if dims[v] == (c,):
@@ -186,7 +195,6 @@ def _get_WeibullSectors(
                 fix[v] = d
             elif verbosity > 2:
                 print(f"        ignoring field '{v}' with dims {dims[v]}")
-        fix.update({v: d for v, d in fixval.items() if v not in data})
 
         if FV.WD in coords:
             data[FV.WD] = coords[FV.WD]
@@ -230,13 +238,12 @@ def _get_WeibullPointCloud(
             print("        selecting class 'WeibullPointCloud'")
 
         data = {}
-        fix = {}
+        fix = {v: fixval.get(v, default_values[v]) for v in ovars if v not in fields}
         for v, d in fields.items():
             if len(dims[v]) == 0:
                 fix[v] = d
             elif v not in fixval:
                 data[v] = (dims[v], d)
-        fix.update({v: d for v, d in fixval.items() if v not in data})
 
         sdata = Dataset(
             coords=coords,
@@ -282,13 +289,12 @@ def _get_WeibullField(
             print("        selecting class 'WeibullField'")
 
         data = {}
-        fix = {}
+        fix = {v: fixval.get(v, default_values[v]) for v in ovars if v not in fields}
         for v, d in fields.items():
             if len(dims[v]) == 0:
                 fix[v] = d
             elif v not in fixval:
                 data[v] = (dims[v], d)
-        fix.update({v: d for v, d in fixval.items() if v not in data})
 
         sdata = Dataset(
             coords=coords,
@@ -342,7 +348,7 @@ def get_states(coords, fields, dims, verbosity=1):
         print("      Creating states")
 
     ovars = [FV.WS, FV.WD, FV.TI, FV.RHO]
-    fixval = {FV.RHO: 1.225}
+    fixval = {}
     profiles = _get_profiles(coords, fields, dims, ovars, fixval, verbosity)
 
     states_dict = {}
@@ -421,6 +427,21 @@ def read_site(wio_dict, verbosity=1):
     dims = Dict(_name="dims")
     for n, d in wind_resource.items():
         read_wind_resource_field(n, d, coords, fields, dims, verbosity)
+
+    # special case: operating field
+    if FV.OPERATING in fields:
+        wio_dict["wind_farm"][FV.OPERATING] = (
+            dims.pop(FV.OPERATING),
+            fields.pop(FV.OPERATING),
+        )
+        if FC.TURBINE in coords:
+            if not any([FC.TURBINE in dms for dms in dims.values()]):
+                if verbosity > 2:
+                    print(
+                        f"      Removing coordinate '{FC.TURBINE}', since only relevant for operating flag"
+                    )
+                coords.pop(FC.TURBINE)
+
     if verbosity > 2:
         print("      Coords:")
         for c, d in coords.items():

{foxes-1.5.1 → foxes-1.5.2}/foxes/input/yaml/windio/windio.py

@@ -55,6 +55,7 @@ def read_windio(wio_dict, verbosity=1):
         algorithm=Dict(
             algo_type="Downwind",
             wake_models=[],
+            farm_controller="farm_cntrl",
             _name="wio2fxs.algorithm",
             verbosity=verbosity - 3,
         ),

{foxes-1.5.1 → foxes-1.5.2}/foxes/models/farm_controllers/__init__.py

@@ -3,3 +3,4 @@ Farm controller models.
 """
 
 from .basic import BasicFarmController as BasicFarmController
+from .op_flag import OpFlagController as OpFlagController

foxes-1.5.2/foxes/models/farm_controllers/op_flag.py

@@ -0,0 +1,196 @@
+import numpy as np
+from xarray import open_dataset, Dataset
+
+from foxes.core import FarmController
+import foxes.constants as FC
+import foxes.variables as FV
+
+
+class OpFlagController(FarmController):
+    """
+    A basic controller with a flag for
+    turbine operation at each state.
+
+    Parameters
+    ----------
+    non_op_values: dict
+        The non-operational values for variables,
+        keys: variable str, values: float
+    var2ncvar: dict
+        The mapping of variable names to NetCDF variable names,
+        only needed if data_source is a path to a NetCDF file
+
+    :group: models.farm_controllers
+
+    """
+
+    def __init__(
+        self,
+        data_source,
+        non_op_values=None,
+        var2ncvar={},
+        **kwargs,
+    ):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        data_source: numpy.ndarray or str
+            The operating flag data, shape: (n_states, n_turbines),
+            or path to a NetCDF file
+        non_op_values: dict, optional
+            The non-operational values for variables,
+            keys: variable str, values: float
+        var2ncvar: dict
+            The mapping of variable names to NetCDF variable names,
+            only needed if data_source is a path to a NetCDF file
+        kwargs: dict, optional
+            Additional keyword arguments for the
+            base class constructor
+
+        """
+        super().__init__(**kwargs)
+        self.data_source = data_source
+        self.var2ncvar = var2ncvar
+
+        self.non_op_values = {
+            FV.P: 0.0,
+            FV.CT: 0.0,
+        }
+        if non_op_values is not None:
+            self.non_op_values.update(non_op_values)
+
+        self._op_flags = None
+
+    def output_farm_vars(self, algo):
+        """
+        The variables which are being modified by the model.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+
+        Returns
+        -------
+        output_vars: list of str
+            The output variable names
+
+        """
+        vrs = set(super().output_farm_vars(algo))
+        vrs.update([FV.OPERATING])
+        return list(vrs)
+
+    def load_data(self, algo, verbosity=0):
+        """
+        Load and/or create all model data that is subject to chunking.
+
+        Such data should not be stored under self, for memory reasons. The
+        data returned here will automatically be chunked and then provided
+        as part of the mdata object during calculations.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        verbosity: int
+            The verbosity level, 0 = silent
+
+        Returns
+        -------
+        idata: dict
+            The dict has exactly two entries: `data_vars`,
+            a dict with entries `name_str -> (dim_tuple, data_ndarray)`;
+            and `coords`, a dict with entries `dim_name_str -> dim_array`
+
+        """
+
+        idata = super().load_data(algo, verbosity)
+
+        if isinstance(self.data_source, np.ndarray):
+            self._op_flags = self.data_source
+
+        elif isinstance(self.data_source, Dataset):
+            cop = self.var2ncvar.get(FV.OPERATING, FV.OPERATING)
+            self._op_flags = self.data_source[cop].to_numpy()
+
+        else:
+            if verbosity > 0:
+                print(f"OpFlagController: Reading data from {self.data_source}")
+            ds = open_dataset(self.data_source)
+            cop = self.var2ncvar.get(FV.OPERATING, FV.OPERATING)
+            self._op_flags = ds[cop].to_numpy()
+            del ds
+
+        assert self._op_flags.shape == (algo.n_states, algo.n_turbines), (
+            f"OpFlagController data shape {self._op_flags.shape} does not match "
+            f"(n_states, n_turbines)=({algo.n_states}, {algo.n_turbines})"
+        )
+        op_flags = self._op_flags.astype(bool)
+
+        off = np.where(~op_flags)
+        tmsels = idata["data_vars"][FC.TMODEL_SELS][1]
+        tmsels[off[0], off[1], :] = False
+        self._tmall = [np.all(t) for t in tmsels]
+
+        idata["data_vars"][FC.TMODEL_SELS] = (
+            (FC.STATE, FC.TURBINE, FC.TMODELS),
+            tmsels,
+        )
+        idata["data_vars"][FV.OPERATING] = (
+            (FC.STATE, FC.TURBINE),
+            op_flags,
+        )
+
+        return idata
+
+    def calculate(self, algo, mdata, fdata, pre_rotor, downwind_index=None):
+        """
+        The main model calculation.
+
+        This function is executed on a single chunk of data,
+        all computations should be based on numpy arrays.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        mdata: foxes.core.MData
+            The model data
+        fdata: foxes.core.FData
+            The farm data
+        pre_rotor: bool
+            Flag for running pre-rotor or post-rotor
+            models
+        downwind_index: int, optional
+            The index in the downwind order
+
+        Returns
+        -------
+        results: dict
+            The resulting data, keys: output variable str.
+            Values: numpy.ndarray with shape (n_states, n_turbines)
+
+        """
+        self.ensure_output_vars(algo, fdata)
+
+        # compute data for all operating turbines:
+        op = mdata[FV.OPERATING].astype(bool)
+        fdata[FV.OPERATING] = op
+        results = super().calculate(algo, mdata, fdata, pre_rotor, downwind_index)
+        results[FV.OPERATING] = fdata[FV.OPERATING]
+
+        # set non-operating values:
+        if downwind_index is None:
+            off = np.where(~op)
+            for v in self.output_farm_vars(algo):
+                if v != FV.OPERATING:
+                    fdata[v][off[0], off[1]] = self.non_op_values.get(v, np.nan)
+        else:
+            off = np.where(~op[:, downwind_index])
+            for v in self.output_farm_vars(algo):
+                if v != FV.OPERATING:
+                    fdata[v][off[0], downwind_index] = self.non_op_values.get(v, np.nan)
+
+        return results

{foxes-1.5.1 → foxes-1.5.2}/foxes/models/wake_models/induction/self_similar.py

@@ -27,6 +27,12 @@ class SelfSimilar(TurbineInductionModel):
 
     Attributes
     ----------
+    alpha: float
+        The alpha parameter
+    beta: float
+        The beta parameter
+    gamma: float
+        The gamma parameter
     pre_rotor_only: bool
         Calculate only the pre-rotor region
     induction: foxes.core.AxialInductionModel or str
@@ -40,6 +46,8 @@ class SelfSimilar(TurbineInductionModel):
         self,
         superposition="ws_linear",
         induction="Madsen",
+        alpha=8 / 9,
+        beta=np.sqrt(2),
         gamma=1.1,
         pre_rotor_only=False,
     ):
@@ -52,8 +60,12 @@ class SelfSimilar(TurbineInductionModel):
             The wind speed superposition.
         induction: foxes.core.AxialInductionModel or str
             The induction model
-        gamma: float, default=1.1
-            The parameter that multiplies Ct in the ct2a calculation
+        alpha: float
+            The alpha parameter
+        beta: float
+            The beta parameter
+        gamma: float
+            The gamma parameter
         pre_rotor_only: bool
             Calculate only the pre-rotor region
 
@@ -61,6 +73,8 @@ class SelfSimilar(TurbineInductionModel):
         super().__init__(wind_superposition=superposition)
         self.induction = induction
         self.pre_rotor_only = pre_rotor_only
+        self.alpha = alpha
+        self.beta = beta
         self.gamma = gamma
 
     def __repr__(self):
@@ -163,9 +177,13 @@ class SelfSimilar(TurbineInductionModel):
         """Helper function: using eqn 13 from [2]"""
         return np.sqrt(0.587 * (1.32 + x_R**2))
 
-    def _rad_fn(self, x_R, r_R, beta=np.sqrt(2), alpha=8 / 9):
+    def _rad_fn(self, x_R, r_R):
         """Helper function: define radial shape function (eqn 12 from [1])"""
-        return (1 / np.cosh(beta * (r_R) / self._r_half(x_R))) ** alpha  # * (x_R < 0)
+        with np.errstate(over="ignore"):
+            result = (
+                1 / np.cosh(self.beta * (r_R) / self._r_half(x_R))
+            ) ** self.alpha  # * (x_R < 0)
+        return result
 
     def contribute(
         self,

{foxes-1.5.1 → foxes-1.5.2}/foxes/models/wake_models/induction/self_similar2020.py

@@ -25,7 +25,7 @@ class SelfSimilar2020(SelfSimilar):
 
     """
 
-    def _a0(self, ct, x_R, gamma=1.1):
+    def _a0(self, ct, x_R):
         """Helper function: define a0 with gamma factor, eqn 8 from [2]"""
 
         x_new = np.minimum(np.maximum(-1 * np.abs(x_R), -6), -1)

{foxes-1.5.1 → foxes-1.5.2}/foxes/models/wake_models/ti/crespo_hernandez.py

@@ -218,7 +218,7 @@ class CrespoHernandezTIWake(TopHatWakeModel):
 
         # calculate:
         a = self.induction.ct2a(ct)
-        beta = (1 - a) / (1 - 2 * a)
+        beta = np.maximum((1 - a) / (1 - 2 * a), 0)
         radius = 2 * (k * x + self.sbeta_factor * np.sqrt(beta) * D)
 
         return radius

{foxes-1.5.1 → foxes-1.5.2}/foxes/models/wake_models/wind/bastankhah14.py

@@ -194,7 +194,7 @@ class Bastankhah2014(GaussianWakeModel):
             # calculate sigma:
             # beta = 0.5 * (1 + np.sqrt(1.0 - ct)) / np.sqrt(1.0 - ct)
             a = self.induction.ct2a(ct)
-            beta = (1 - a) / (1 - 2 * a)
+            beta = np.maximum((1 - a) / (1 - 2 * a), 0)
             sigma = k * x + self.sbeta_factor * np.sqrt(beta) * D
             del beta, a
 

{foxes-1.5.1 → foxes-1.5.2}/foxes/models/wake_models/wind/bastankhah16.py

@@ -423,7 +423,7 @@ class Bastankhah2016(DistSlicedWakeModel):
         self,
         superposition,
         alpha=0.58,
-        beta=0.07,
+        beta=0.077,
         induction="Madsen",
         **wake_k,
     ):

{foxes-1.5.1 → foxes-1.5.2}/foxes/models/wake_models/wind/turbopark.py

@@ -220,7 +220,7 @@ class TurbOParkWake(GaussianWakeModel):
             # calculate sigma:
             # beta = np.sqrt(0.5 * (1 + np.sqrt(1.0 - ct)) / np.sqrt(1.0 - ct))
             a = self.induction.ct2a(ct)
-            beta = (1 - a) / (1 - 2 * a)
+            beta = np.maximum((1 - a) / (1 - 2 * a), 0)
             epsilon = self.sbeta_factor * np.sqrt(beta)
             del a, beta