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

foxes/core/rotor_model.py

@@ -1,12 +1,14 @@
 import numpy as np
 from abc import abstractmethod
 
+from foxes.config import config
+from foxes.utils import wd2uv, uv2wd, all_subclasses
+
 import foxes.variables as FV
 import foxes.constants as FC
-from .farm_data_model import FarmDataModel
-from foxes.utils import wd2uv, uv2wd, all_subclasses
 
 from .data import TData
+from .farm_data_model import FarmDataModel
 
 
 class RotorModel(FarmDataModel):
@@ -146,14 +148,16 @@ class RotorModel(FarmDataModel):
         dpoints = self.design_points()
         D = fdata[FV.D]
 
-        rax = np.zeros((n_states, n_turbines, 3, 3), dtype=FC.DTYPE)
+        rax = np.zeros((n_states, n_turbines, 3, 3), dtype=config.dtype_double)
         n = rax[:, :, 0, 0:2]
         m = rax[:, :, 1, 0:2]
         n[:] = wd2uv(fdata[FV.YAW], axis=-1)
         m[:] = np.stack([-n[:, :, 1], n[:, :, 0]], axis=-1)
         rax[:, :, 2, 2] = 1
 
-        points = np.zeros((n_states, n_turbines, n_points, 3), dtype=FC.DTYPE)
+        points = np.zeros(
+            (n_states, n_turbines, n_points, 3), dtype=config.dtype_double
+        )
         points[:] = fdata[FV.TXYH][:, :, None, :]
         points[:] += (
             0.5 * D[:, :, None, None] * np.einsum("stad,pa->stpd", rax, dpoints)

foxes/core/turbine_type.py

@@ -1,7 +1,7 @@
 from abc import abstractmethod
 
-import foxes.constants as FC
 from foxes.utils import all_subclasses
+import foxes.constants as FC
 
 from .turbine_model import TurbineModel
 

foxes/core/wake_frame.py

@@ -3,8 +3,9 @@ import numpy as np
 from scipy.interpolate import interpn
 
 from foxes.utils import all_subclasses
-import foxes.constants as FC
+from foxes.config import config
 import foxes.variables as FV
+import foxes.constants as FC
 
 from .data import TData
 from .model import Model
@@ -243,7 +244,7 @@ class WakeFrame(Model):
             n_steps += 1
         n_ix = n_steps + 1
         xs = np.arange(xmin, xmin + n_ix * dx, dx)
-        xpts = np.zeros((n_states, n_steps), dtype=FC.DTYPE)
+        xpts = np.zeros((n_states, n_steps), dtype=config.dtype_double)
         xpts[:] = xs[None, 1:]
         pts = self.get_centreline_points(algo, mdata, fdata, downwind_index, xpts)
 
@@ -251,7 +252,8 @@ class WakeFrame(Model):
         tdata = TData.from_points(
             pts,
             data={
-                v: np.full((n_states, n_steps, 1), np.nan, dtype=FC.DTYPE) for v in vrs
+                v: np.full((n_states, n_steps, 1), np.nan, dtype=config.dtype_double)
+                for v in vrs
             },
             dims={v: (FC.STATE, FC.TARGET, FC.TPOINT) for v in vrs},
         )
@@ -280,13 +282,13 @@ class WakeFrame(Model):
             del wcalc, res
 
         # collect integration results:
-        iresults = np.zeros((n_states, n_ix, n_vars), dtype=FC.DTYPE)
+        iresults = np.zeros((n_states, n_ix, n_vars), dtype=config.dtype_double)
         for vi, v in enumerate(variables):
             for i in range(n_steps):
                 iresults[:, i + 1, vi] = iresults[:, i, vi] + tdata[v][:, i, 0] * dx
 
         # interpolate to x of interest:
-        qts = np.zeros((n_states, n_points, 2), dtype=FC.DTYPE)
+        qts = np.zeros((n_states, n_points, 2), dtype=config.dtype_double)
         qts[:, :, 0] = np.arange(n_states)[:, None]
         qts[:, :, 1] = x
         qts = qts.reshape(n_states * n_points, 2)

foxes/core/wake_model.py

@@ -1,7 +1,7 @@
 from abc import abstractmethod
 import numpy as np
 
-from foxes.utils import all_subclasses, Factory
+from foxes.utils import all_subclasses
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -259,6 +259,11 @@ class WakeK(Model):
             s = f"k_var={self.k_var}"
         return s
 
+    @property
+    def is_kTI(self):
+        """Flag for ka != 0"""
+        return self._ka is not None and self._ka != 0
+
     @property
     def all_none(self):
         """Flag for k=ka=kb=None"""

foxes/data/__init__.py

@@ -3,4 +3,4 @@ Static data collection.
 """
 
 from .parse import parse_Pct_file_name, parse_Pct_two_files
-from .static_data import FARM, STATES, PCTCURVE, WINDIO, StaticData
+from .static_data import FARM, STATES, PCTCURVE, StaticData

foxes/data/static_data.py

@@ -3,7 +3,6 @@ from foxes.utils import DataBook
 from . import farms
 from . import states
 from . import power_ct_curves
-from . import windio
 
 FARM = "farm"
 """ Static wind farm data identifier
@@ -20,11 +19,6 @@ PCTCURVE = "power_ct_curve"
 :group: data
 """
 
-WINDIO = "windio"
-""" Static windio data identifier
-:group: data
-"""
-
 
 class StaticData(DataBook):
     """
@@ -41,4 +35,3 @@ class StaticData(DataBook):
         self.add_data_package(FARM, farms, ".csv")
         self.add_data_package(STATES, states, [".csv", ".csv.gz", ".nc", ".tab"])
         self.add_data_package(PCTCURVE, power_ct_curves, ".csv")
-        self.add_data_package(WINDIO, windio, ".yaml")

foxes/engines/dask.py

@@ -5,6 +5,7 @@ from tqdm import tqdm
 
 from foxes.core import Engine, MData, FData, TData
 from foxes.utils import import_module
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -212,7 +213,7 @@ def _run_as_ufunc(
     odims = {v: tuple(out_coords) for v in out_vars}
     odata = {
         v: (
-            np.full(oshape, np.nan, dtype=FC.DTYPE)
+            np.full(oshape, np.nan, dtype=config.dtype_double)
             if v not in init_vars
             else prev[init_vars.index(v)].copy()
         )
@@ -264,7 +265,7 @@ def _run_as_ufunc(
 
     # create output:
     n_vars = len(out_vars)
-    data = np.zeros(oshape + [n_vars], dtype=FC.DTYPE)
+    data = np.zeros(oshape + [n_vars], dtype=config.dtype_double)
     for v in out_vars:
         data[..., out_vars.index(v)] = results[v]
 
@@ -449,7 +450,7 @@ class XArrayEngine(DaskBaseEngine):
             *ldata,
             input_core_dims=[[]] + iidims + icdims,
             output_core_dims=[out_core_vars],
-            output_dtypes=[FC.DTYPE],
+            output_dtypes=[config.dtype_double],
             dask="parallelized",
             dask_gufunc_kwargs=dargs,
             kwargs=wargs,

foxes/engines/single.py

@@ -1,7 +1,7 @@
 from xarray import Dataset
 
-import foxes.constants as FC
 from foxes.core import Engine
+import foxes.constants as FC
 
 
 class SingleChunkEngine(Engine):

foxes/input/__init__.py

@@ -4,4 +4,4 @@ Functions and classes for input data definition.
 
 from . import farm_layout
 from . import states
-from . import windio
+from . import yaml

foxes/input/farm_layout/from_csv.py

@@ -1,6 +1,7 @@
 import pandas as pd
 
 from foxes.core import Turbine
+from foxes.config import get_path
 
 
 def add_from_csv(
@@ -75,7 +76,8 @@ def add_from_csv(
     else:
         if verbosity:
             print("Reading file", data_source)
-        data = pd.read_csv(data_source, index_col=col_index)
+        pth = get_path(data_source)
+        data = pd.read_csv(pth, index_col=col_index)
 
     tmodels = turbine_parameters.pop("turbine_models", [])
     H = turbine_parameters.pop("H", None)

foxes/input/farm_layout/from_file.py

@@ -1,6 +1,6 @@
-from pathlib import Path
-
 from foxes.data import FARM, StaticData
+from foxes.config import get_path
+
 from .from_json import add_from_json
 from .from_csv import add_from_csv
 
@@ -31,24 +31,24 @@ def add_from_file(farm, file_path, *args, verbosity=1, dbook=None, **kwargs):
 
     """
 
-    fpath = Path(file_path)
+    fpath = get_path(file_path)
     dbook = StaticData() if dbook is None else dbook
 
     if not fpath.is_file():
         if verbosity:
             print(f"Reading static data '{fpath.name}' from context '{FARM}'")
-        fpath = dbook.get_file_path(FARM, fpath.name, check_raw=False)
+        file_path = dbook.get_file_path(FARM, fpath.name, check_raw=False)
 
     if fpath.suffix == ".json":
-        add_from_json(farm, fpath, *args, **kwargs)
+        add_from_json(farm, file_path, *args, **kwargs)
     elif (
         fpath.suffix == ".csv"
-        or (len(fpath) > 7 and fpath[-7:] == ".csv.gz")
-        or (len(fpath) > 8 and fpath[-8:] == ".csv.bz2")
-        or (len(fpath) > 8 and fpath[-8:] == ".csv.zip")
+        or (len(file_path) > 7 and file_path[-7:] == ".csv.gz")
+        or (len(file_path) > 8 and file_path[-8:] == ".csv.bz2")
+        or (len(file_path) > 8 and file_path[-8:] == ".csv.zip")
     ):
-        add_from_csv(farm, fpath, *args, verbosity=verbosity, **kwargs)
+        add_from_csv(farm, file_path, *args, verbosity=verbosity, **kwargs)
     else:
         raise KeyError(
-            f"Unsupported file suffix: '{fpath}'. Please provide any of: json, csv, csv.gz, csv.bz2, csv.zip"
+            f"Unsupported file suffix: '{file_path}'. Please provide any of: json, csv, csv.gz, csv.bz2, csv.zip"
         )

foxes/input/farm_layout/from_json.py

@@ -3,6 +3,7 @@ import numpy as np
 from copy import deepcopy
 
 from foxes.core import Turbine
+from foxes.config import get_path
 
 
 def add_from_json(
@@ -27,10 +28,10 @@ def add_from_json(
     :group: input.farm_layout
 
     """
-
+    fpath = get_path(file_path)
     if verbosity:
-        print("Reading file", file_path)
-    with open(file_path) as f:
+        print("Reading file", fpath)
+    with open(fpath) as f:
         dict = json.load(f)
 
     keys = list(dict.keys())

foxes/input/farm_layout/grid.py

@@ -1,7 +1,7 @@
 import numpy as np
 
 from foxes.core import Turbine
-import foxes.constants as FC
+from foxes.config import config
 
 
 def add_grid(
@@ -44,8 +44,8 @@ def add_grid(
     inds = list(np.ndindex(*steps))
     n_turbines = len(inds)
 
-    xy_base = np.array(xy_base, dtype=FC.DTYPE)
-    step_vectors = np.array(step_vectors, dtype=FC.DTYPE)
+    xy_base = np.array(xy_base, dtype=config.dtype_double)
+    step_vectors = np.array(step_vectors, dtype=config.dtype_double)
 
     for i in range(n_turbines):
         xi, yi = inds[i]

foxes/input/states/create/random_abl_states.py

@@ -1,6 +1,7 @@
 import pandas as pd
 import numpy as np
 
+from foxes.config import config, get_path
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -41,7 +42,7 @@ def create_random_abl_states(
 
     for v, mm in cols_minmax.items():
         data[v] = np.random.uniform(low=mm[0], high=mm[1], size=(n_states,)).astype(
-            FC.DTYPE
+            config.dtype_double
         )
 
     cmol = var2col.get(FV.MOL, FV.MOL)
@@ -98,8 +99,9 @@ def write_random_abl_states(
 
     """
 
+    fpath = get_path(file_path)
     if verbosity:
-        print("Writing file", file_path)
+        print("Writing file", fpath)
 
     data = create_random_abl_states(
         n_states, cols_minmax, var2col, mol_abs_range, normalize
@@ -130,4 +132,4 @@ def write_random_abl_states(
             if d is not None:
                 data[v] = data[v].round(d)
 
-    data.to_csv(file_path, **kwargs)
+    data.to_csv(fpath, **kwargs)

foxes/input/states/field_data_nc.py

@@ -2,13 +2,13 @@ import numpy as np
 import pandas as pd
 import xarray as xr
 from scipy.interpolate import interpn
-from pathlib import Path
 
 from foxes.core import States
 from foxes.utils import wd2uv, uv2wd, import_module
 from foxes.data import STATES, StaticData
 import foxes.variables as FV
 import foxes.constants as FC
+from foxes.config import config, get_path
 
 
 class FieldDataNC(States):
@@ -150,9 +150,11 @@ class FieldDataNC(States):
             if "*" in str(self.data_source):
                 pass
             else:
-                self.__data_source = StaticData().get_file_path(
-                    STATES, self.data_source, check_raw=True
-                )
+                self.__data_source = get_path(self.data_source)
+                if not self.data_source.is_file():
+                    self.__data_source = StaticData().get_file_path(
+                        STATES, self.data_source.name, check_raw=False
+                    )
             if verbosity:
                 if pre_load:
                     print(
@@ -164,13 +166,14 @@ class FieldDataNC(States):
                     )
 
             def _read_ds():
-                if Path(self.data_source).is_file():
-                    return xr.open_dataset(self.data_source)
+                fpath = get_path(self.data_source)
+                if fpath.is_file():
+                    return xr.open_dataset(fpath)
                 else:
                     # try to read multiple files, needs dask:
                     try:
                         return xr.open_mfdataset(
-                            str(self.data_source),
+                            str(fpath),
                             parallel=False,
                             concat_dim=self.states_coord,
                             combine="nested",
@@ -182,8 +185,7 @@ class FieldDataNC(States):
                         import_module("dask", hint="pip install dask")
                         raise e
 
-            with _read_ds() as ds:
-                self.__data_source = ds
+            self.__data_source = _read_ds()
 
         if sel is not None:
             self.__data_source = self.data_source.sel(self.sel)
@@ -275,7 +277,9 @@ class FieldDataNC(States):
                     f"States '{self.name}': Wrong coordinate order for variable '{ncv}': Found {ds[ncv].dims}, expecting {cor_shxy}, {cor_shyx}, {cor_sh} or {cor_s}"
                 )
 
-        data = np.zeros((n_sts, n_h, n_y, n_x, len(self.var2ncvar)), dtype=FC.DTYPE)
+        data = np.zeros(
+            (n_sts, n_h, n_y, n_x, len(self.var2ncvar)), dtype=config.dtype_double
+        )
         for v in vars_shyx:
             ncv = self.var2ncvar[v]
             if ds[ncv].dims == cor_shyx:
@@ -290,7 +294,9 @@ class FieldDataNC(States):
             data[..., self._dkys[v]] = ds[ncv].to_numpy()[:, None, None, None]
         if FV.WD in self.fixed_vars:
             data[..., self._dkys[FV.WD]] = np.full(
-                (n_sts, n_h, n_y, n_x), self.fixed_vars[FV.WD], dtype=FC.DTYPE
+                (n_sts, n_h, n_y, n_x),
+                self.fixed_vars[FV.WD],
+                dtype=config.dtype_double,
             )
 
         if verbosity > 1:
@@ -365,7 +371,7 @@ class FieldDataNC(States):
 
         if self.__weights is None:
             self.__weights = np.full(
-                (self._N, algo.n_turbines), 1.0 / self._N, dtype=FC.DTYPE
+                (self._N, algo.n_turbines), 1.0 / self._N, dtype=config.dtype_double
             )
 
         idata = super().load_data(algo, verbosity)
@@ -608,7 +614,9 @@ class FieldDataNC(States):
 
         # prepare points:
         sts = np.arange(n_states)
-        pts = np.append(points, np.zeros((n_states, n_pts, 1), dtype=FC.DTYPE), axis=2)
+        pts = np.append(
+            points, np.zeros((n_states, n_pts, 1), dtype=config.dtype_double), axis=2
+        )
         pts[:, :, 3] = sts[:, None]
         pts = pts.reshape(n_states * n_pts, 4)
         pts = np.flip(pts, axis=1)
@@ -697,7 +705,7 @@ class FieldDataNC(States):
                     out[v] = data[..., self._dkys[v]]
                 else:
                     out[v] = np.full(
-                        (n_states, n_pts), self.fixed_vars[v], dtype=FC.DTYPE
+                        (n_states, n_pts), self.fixed_vars[v], dtype=config.dtype_double
                     )
 
         return {v: d.reshape(n_states, n_targets, n_tpoints) for v, d in out.items()}

foxes/input/states/multi_height.py

@@ -1,15 +1,15 @@
 import numpy as np
 import pandas as pd
 from xarray import Dataset, open_dataset
-from pathlib import Path
 from scipy.interpolate import interp1d
 
 from foxes.core import States
 from foxes.utils import PandasFileHelper
 from foxes.data import STATES
+from foxes.config import config, get_path
+from foxes.utils import wd2uv, uv2wd
 import foxes.variables as FV
 import foxes.constants as FC
-from foxes.utils import wd2uv, uv2wd
 
 
 class MultiHeightStates(States):
@@ -92,7 +92,7 @@ class MultiHeightStates(States):
         super().__init__()
 
         self.ovars = output_vars
-        self.heights = np.array(heights, dtype=FC.DTYPE)
+        self.heights = np.array(heights, dtype=config.dtype_double)
         self.rpars = pd_read_pars
         self.var2col = var2col
         self.fixed_vars = fixed_vars
@@ -198,13 +198,14 @@ class MultiHeightStates(States):
 
         """
         if not isinstance(self.data_source, pd.DataFrame):
-            if not Path(self.data_source).is_file():
+            self._data_source = get_path(self.data_source)
+            if not self.data_source.is_file():
                 if verbosity:
                     print(
                         f"States '{self.name}': Reading static data '{self.data_source}' from context '{STATES}'"
                     )
                 self._data_source = algo.dbook.get_file_path(
-                    STATES, self.data_source, check_raw=False
+                    STATES, self.data_source.name, check_raw=False
                 )
                 if verbosity:
                     print(f"Path: {self.data_source}")
@@ -226,7 +227,7 @@ class MultiHeightStates(States):
         self._inds = data.index.to_numpy()
 
         col_w = self.var2col.get(FV.WEIGHT, FV.WEIGHT)
-        self._weights = np.zeros((self._N, algo.n_turbines), dtype=FC.DTYPE)
+        self._weights = np.zeros((self._N, algo.n_turbines), dtype=config.dtype_double)
         if col_w in data:
             self._weights[:] = data[col_w].to_numpy()[:, None]
         elif FV.WEIGHT in self.var2col:
@@ -446,7 +447,7 @@ class MultiHeightStates(States):
         vrs = list(mdata[self.VARS])
         n_vars = len(vrs)
 
-        coeffs = np.zeros((n_h, n_h), dtype=FC.DTYPE)
+        coeffs = np.zeros((n_h, n_h), dtype=config.dtype_double)
         np.fill_diagonal(coeffs, 1.0)
         ipars = dict(
             assume_sorted=True,
@@ -499,10 +500,14 @@ class MultiHeightStates(States):
             elif has_wd and v == FV.WS:
                 results[v] = np.linalg.norm(uv, axis=-1)
             elif v in self.fixed_vars:
-                results[v] = np.zeros((n_states, n_targets, n_tpoints), dtype=FC.DTYPE)
+                results[v] = np.zeros(
+                    (n_states, n_targets, n_tpoints), dtype=config.dtype_double
+                )
                 results[v][:] = self.fixed_vars[v]
             elif v in self._solo:
-                results[v] = np.zeros((n_states, n_targets, n_tpoints), dtype=FC.DTYPE)
+                results[v] = np.zeros(
+                    (n_states, n_targets, n_tpoints), dtype=config.dtype_double
+                )
                 results[v][:] = mdata[self.var(v)][:, None, None]
             else:
                 results[v] = ires[vrs.index(v)]
@@ -620,13 +625,14 @@ class MultiHeightNCStates(MultiHeightStates):
 
         """
         if not isinstance(self.data_source, Dataset):
-            if not Path(self.data_source).is_file():
+            self._data_source = get_path(self.data_source)
+            if not self.data_source.is_file():
                 if verbosity:
                     print(
                         f"States '{self.name}': Reading static data '{self.data_source}' from context '{STATES}'"
                     )
                 self._data_source = algo.dbook.get_file_path(
-                    STATES, self.data_source, check_raw=False
+                    STATES, self.data_source.name, check_raw=False
                 )
                 if verbosity:
                     print(f"Path: {self.data_source}")
@@ -652,7 +658,7 @@ class MultiHeightNCStates(MultiHeightStates):
             self._inds = format_times_func(self._inds)
 
         w_name = self.var2col.get(FV.WEIGHT, FV.WEIGHT)
-        self._weights = np.zeros((self._N, algo.n_turbines), dtype=FC.DTYPE)
+        self._weights = np.zeros((self._N, algo.n_turbines), dtype=config.dtype_double)
         if w_name in data.data_vars:
             if data[w_name].dims != (self.state_coord,):
                 raise ValueError(
@@ -664,7 +670,9 @@ class MultiHeightNCStates(MultiHeightStates):
                 f"Weight variable '{w_name}' defined in var2col, but not found in data_vars {list(data.data_vars.keys())}"
             )
         else:
-            self._weights = np.zeros((self._N, algo.n_turbines), dtype=FC.DTYPE)
+            self._weights = np.zeros(
+                (self._N, algo.n_turbines), dtype=config.dtype_double
+            )
             self._weights[:] = 1.0 / self._N
 
         cols = {}
@@ -707,11 +715,14 @@ class MultiHeightNCStates(MultiHeightStates):
             dims,
             np.stack(
                 [data.data_vars[c].to_numpy() for c in cols.values()], axis=1
-            ).astype(FC.DTYPE),
+            ).astype(config.dtype_double),
         )
 
         for v, d in self._solo.items():
-            idata["data_vars"][self.var(v)] = ((FC.STATE,), d.astype(FC.DTYPE))
+            idata["data_vars"][self.var(v)] = (
+                (FC.STATE,),
+                d.astype(config.dtype_double),
+            )
         self._solo = list(self._solo.keys())
 
         return idata

foxes/input/states/one_point_flow.py

@@ -4,6 +4,7 @@ from scipy.interpolate import interpn
 from foxes.core import States
 from foxes.utils import uv2wd
 from foxes.models.wake_frames.timelines import Timelines
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -65,7 +66,7 @@ class OnePointFlowStates(States):
 
         """
         super().__init__()
-        self.ref_xy = np.array(ref_xy, dtype=FC.DTYPE)
+        self.ref_xy = np.array(ref_xy, dtype=config.dtype_double)
         self.heights = tl_heights
         self.base_states = base_states
         self.dt_min = dt_min
@@ -268,9 +269,9 @@ class OnePointFlowStates(States):
 
         i0 = mdata.states_i0(counter=True)
         trace_p = points[:, :, :2] - ref_xy[:, :, :2]
-        trace_si = np.zeros((n_states, n_points), dtype=FC.ITYPE)
+        trace_si = np.zeros((n_states, n_points), dtype=config.dtype_int)
         trace_si[:] = i0 + np.arange(n_states)[:, None]
-        coeffs = np.full((n_states, n_points), np.nan, dtype=FC.DTYPE)
+        coeffs = np.full((n_states, n_points), np.nan, dtype=config.dtype_double)
 
         # flake8: noqa: F821
         def _eval_trace(sel, hdxy=None, hdxy0=None, trs=None):
@@ -396,7 +397,7 @@ class OnePointFlowStates(States):
             sts = trace_si[hi]
             cfs = coeffs[hi]
             data = self.timelines_data[v].to_numpy()[hi]
-            out = np.zeros(sts.shape, dtype=FC.DTYPE)
+            out = np.zeros(sts.shape, dtype=config.dtype_double)
 
             sel_low = sts < 0
             if np.any(sel_low):
@@ -436,7 +437,7 @@ class OnePointFlowStates(States):
             vres = list(data.keys())
             data = np.stack(list(data.values()), axis=-1)
 
-            eval = np.zeros((n_states, n_points, 3), dtype=FC.DTYPE)
+            eval = np.zeros((n_states, n_points, 3), dtype=config.dtype_double)
             eval[:, :, 0] = points[:, :, 2]
             eval[:, :, 1] = ar_states[:, None]
             eval[:, :, 2] = ar_points[None, :]

foxes/input/states/scan_ws.py

@@ -1,6 +1,7 @@
 import numpy as np
 
 from foxes.core import States
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -198,7 +199,9 @@ class ScanWS(States):
             The weights, shape: (n_states, n_turbines)
 
         """
-        return np.full((self.N, algo.n_turbines), 1.0 / self.N, dtype=FC.DTYPE)
+        return np.full(
+            (self.N, algo.n_turbines), 1.0 / self.N, dtype=config.dtype_double
+        )
 
     def calculate(self, algo, mdata, fdata, tdata):
         """