foxes 1.1.1__py3-none-any.whl → 1.2.1__py3-none-any.whl

foxes/models/turbine_types/CpCt_file.py

@@ -1,11 +1,13 @@
 import numpy as np
 import pandas as pd
 
-from .PCt_file import PCtFile
 from foxes.data import parse_Pct_file_name
 from foxes.utils import PandasFileHelper
+from foxes.config import config, get_path
 import foxes.constants as FC
 
+from .PCt_file import PCtFile
+
 
 class CpCtFile(PCtFile):
     """
@@ -47,7 +49,8 @@ class CpCtFile(PCtFile):
         if not isinstance(data_source, pd.DataFrame):
             pars = parse_Pct_file_name(data_source)
             pars.update(parameters)
-            data = PandasFileHelper.read_file(data_source, **pd_file_read_pars)
+            fpath = get_path(data_source)
+            data = PandasFileHelper.read_file(fpath, **pd_file_read_pars)
         else:
             data = data_source
             pars = parameters
@@ -63,7 +66,7 @@ class CpCtFile(PCtFile):
         ws_max = np.max(ws)
         N = int((ws_max - ws_min) / ws_delta)
 
-        data_P = pd.DataFrame(index=range(N), dtype=FC.DTYPE)
+        data_P = pd.DataFrame(index=range(N), dtype=config.dtype_double)
         data_P["ws"] = np.linspace(ws_min, ws_max, N, endpoint=True)
         data_P["cp"] = np.interp(data_P["ws"], ws, cp, left=0, right=0)
         data_P["P"] = (

foxes/models/turbine_types/CpCt_from_two.py

@@ -4,6 +4,7 @@ import pandas as pd
 from .PCt_from_two import PCtFromTwo
 from foxes.data import parse_Pct_two_files
 from foxes.utils import PandasFileHelper
+from foxes.config import config, get_path
 import foxes.constants as FC
 
 
@@ -55,8 +56,10 @@ class CpCtFromTwo(PCtFromTwo):
             data_source_ct, pd.DataFrame
         ):
             pars = parse_Pct_two_files(data_source_cp, data_source_ct)
-            data_cp = PandasFileHelper.read_file(data_source_cp, **pd_file_read_pars_cp)
-            data_ct = PandasFileHelper.read_file(data_source_ct, **pd_file_read_pars_ct)
+            path_cp = get_path(data_source_cp)
+            path_ct = get_path(data_source_ct)
+            data_cp = PandasFileHelper.read_file(path_cp, **pd_file_read_pars_cp)
+            data_ct = PandasFileHelper.read_file(path_ct, **pd_file_read_pars_ct)
         else:
             data_cp = data_source_cp
             data_ct = data_source_ct
@@ -73,7 +76,7 @@ class CpCtFromTwo(PCtFromTwo):
         ws_max = np.max(ws)
         N = int((ws_max - ws_min) / ws_delta)
 
-        data_P = pd.DataFrame(index=range(N), dtype=FC.DTYPE)
+        data_P = pd.DataFrame(index=range(N), dtype=config.dtype_double)
         data_P["ws"] = np.linspace(ws_min, ws_max, N, endpoint=True)
         data_P["cp"] = np.interp(data_P["ws"], ws, cp, left=0, right=0)
         data_P["P"] = (

foxes/models/turbine_types/PCt_file.py

@@ -5,6 +5,7 @@ from pathlib import Path
 from foxes.core import TurbineType
 from foxes.utils import PandasFileHelper
 from foxes.data import PCTCURVE, parse_Pct_file_name
+from foxes.config import get_path
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -173,15 +174,15 @@ class PCtFile(TurbineType):
         if isinstance(self.source, pd.DataFrame):
             data = self.source
         else:
-            fpath = algo.dbook.get_file_path(PCTCURVE, self.source, check_raw=True)
-            if verbosity > 0:
-                if not Path(self.source).is_file():
+            fpath = get_path(self.source)
+            if not fpath.is_file():
+                if verbosity > 0:
                     print(
                         f"Turbine type '{self.name}': Reading static data from context '{PCTCURVE}'"
                     )
-                    print(f"Path: {fpath}")
-                else:
-                    print(f"Turbine type '{self.name}': Reading file", self.source)
+                fpath = algo.dbook.get_file_path(PCTCURVE, self.source, check_raw=False)
+            if verbosity > 0:
+                print(f"Turbine type '{self.name}': Reading file", fpath)
             data = PandasFileHelper.read_file(fpath, **self.rpars)
 
         data = data.set_index(self.col_ws).sort_index()

foxes/models/turbine_types/PCt_from_two.py

@@ -4,6 +4,7 @@ import pandas as pd
 from foxes.core import TurbineType
 from foxes.utils import PandasFileHelper
 from foxes.data import PCTCURVE, parse_Pct_two_files
+from foxes.config import get_path
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -194,7 +195,11 @@ class PCtFromTwo(TurbineType):
         if isinstance(self.source_P, pd.DataFrame):
             self._data_P = self.source_P
         else:
-            fpath = algo.dbook.get_file_path(PCTCURVE, self.source_P, check_raw=True)
+            fpath = get_path(self.source_P)
+            if not fpath.is_file():
+                fpath = algo.dbook.get_file_path(
+                    PCTCURVE, self.source_P, check_raw=False
+                )
             self._data_P = PandasFileHelper.read_file(fpath, **self.rpars_P)
 
         self._data_P = self._data_P.set_index(self.col_ws_P_file).sort_index()
@@ -205,7 +210,11 @@ class PCtFromTwo(TurbineType):
         if isinstance(self.source_ct, pd.DataFrame):
             self._data_ct = self.source_ct
         else:
-            fpath = algo.dbook.get_file_path(PCTCURVE, self.source_ct, check_raw=True)
+            fpath = get_path(self.source_ct)
+            if not fpath.is_file():
+                fpath = algo.dbook.get_file_path(
+                    PCTCURVE, self.source_ct, check_raw=False
+                )
             self._data_ct = PandasFileHelper.read_file(fpath, **self.rpars_ct)
 
         self._data_ct = self._data_ct.set_index(self.col_ws_ct_file).sort_index()

foxes/models/turbine_types/TBL_file.py

@@ -1,10 +1,9 @@
 import numpy as np
 import pandas as pd
-from pathlib import Path
+
+from foxes.config import get_path
 
 from .PCt_file import PCtFile
-from foxes.data import parse_Pct_file_name
-import foxes.constants as FC
 
 
 class TBLFile(PCtFile):
@@ -58,7 +57,7 @@ class TBLFile(PCtFile):
             Additional parameters for PCtFile class
 
         """
-        fpath = Path(tbl_file)
+        fpath = get_path(tbl_file)
         assert fpath.suffix == ".tbl", f"Expecting *.tbl file, got '{tbl_file}'"
 
         meta = np.genfromtxt(fpath, skip_header=1, max_rows=1)

foxes/models/turbine_types/wsrho2PCt_from_two.py

@@ -5,8 +5,8 @@ from scipy.interpolate import interpn
 from foxes.core import TurbineType
 from foxes.utils import PandasFileHelper
 from foxes.data import PCTCURVE, parse_Pct_two_files
+from foxes.config import config, get_path
 import foxes.variables as FV
-import foxes.constants as FC
 
 
 class WsRho2PCtFromTwo(TurbineType):
@@ -183,31 +183,39 @@ class WsRho2PCtFromTwo(TurbineType):
         if isinstance(self.source_P, pd.DataFrame):
             data = self.source_P
         else:
-            fpath = algo.dbook.get_file_path(PCTCURVE, self.source_P, check_raw=True)
+            fpath = get_path(self.source_P)
+            if not fpath.is_file():
+                fpath = algo.dbook.get_file_path(
+                    PCTCURVE, self.source_P, check_raw=False
+                )
             pars = {"index_col": 0}
             pars.update(self.rpars_P)
             data = PandasFileHelper.read_file(fpath, **pars)
 
         data.sort_index(inplace=True)
-        data.columns = data.columns.astype(FC.DTYPE)
-        self._ws_P = data.index.to_numpy(FC.DTYPE)
+        data.columns = data.columns.astype(config.dtype_double)
+        self._ws_P = data.index.to_numpy(config.dtype_double)
         self._rho_P = np.sort(data.columns.to_numpy())
-        self._P = data[self._rho_P].to_numpy(FC.DTYPE)
+        self._P = data[self._rho_P].to_numpy(config.dtype_double)
 
         # read ct curve:
         if isinstance(self.source_ct, pd.DataFrame):
             data = self.source_ct
         else:
-            fpath = algo.dbook.get_file_path(PCTCURVE, self.source_ct, check_raw=True)
+            fpath = get_path(self.source_ct)
+            if not fpath.is_file():
+                fpath = algo.dbook.get_file_path(
+                    PCTCURVE, self.source_ct, check_raw=False
+                )
             pars = {"index_col": 0}
             pars.update(self.rpars_ct)
             data = PandasFileHelper.read_file(fpath, **pars)
 
         data.sort_index(inplace=True)
-        data.columns = data.columns.astype(FC.DTYPE)
-        self._ws_ct = data.index.to_numpy(FC.DTYPE)
+        data.columns = data.columns.astype(config.dtype_double)
+        self._ws_ct = data.index.to_numpy(config.dtype_double)
         self._rho_ct = np.sort(data.columns.to_numpy())
-        self._ct = data[self._rho_ct].to_numpy(FC.DTYPE)
+        self._ct = data[self._rho_ct].to_numpy(config.dtype_double)
 
         return super().load_data(algo, verbosity)
 
@@ -267,7 +275,7 @@ class WsRho2PCtFromTwo(TurbineType):
         if np.any(st_sel_P):
             # prepare interpolation:
             n_sel = np.sum(st_sel_P)
-            qts = np.zeros((n_sel, 2), dtype=FC.DTYPE)  # ws, rho
+            qts = np.zeros((n_sel, 2), dtype=config.dtype_double)  # ws, rho
             qts[:, 0] = fdata[self.WSP][st_sel_P]
             qts[:, 1] = fdata[FV.RHO][st_sel_P]
 
@@ -307,7 +315,7 @@ class WsRho2PCtFromTwo(TurbineType):
         if np.any(st_sel_ct):
             # prepare interpolation:
             n_sel = np.sum(st_sel_ct)
-            qts = np.zeros((n_sel, 2), dtype=FC.DTYPE)  # ws, rho
+            qts = np.zeros((n_sel, 2), dtype=config.dtype_double)  # ws, rho
             qts[:, 0] = fdata[self.WSP][st_sel_ct]
             qts[:, 1] = fdata[FV.RHO][st_sel_ct]
 

foxes/models/turbine_types/wsti2PCt_from_two.py

@@ -6,7 +6,7 @@ from foxes.core import TurbineType
 from foxes.utils import PandasFileHelper
 from foxes.data import PCTCURVE, parse_Pct_two_files
 import foxes.variables as FV
-import foxes.constants as FC
+from foxes.config import config, get_path
 
 
 class WsTI2PCtFromTwo(TurbineType):
@@ -195,31 +195,39 @@ class WsTI2PCtFromTwo(TurbineType):
         if isinstance(self.source_P, pd.DataFrame):
             data = self.source_P
         else:
-            fpath = algo.dbook.get_file_path(PCTCURVE, self.source_P, check_raw=True)
+            fpath = get_path(self.source_P)
+            if not fpath.is_file():
+                fpath = algo.dbook.get_file_path(
+                    PCTCURVE, self.source_P, check_raw=False
+                )
             pars = {"index_col": 0}
             pars.update(self.rpars_P)
             data = PandasFileHelper.read_file(fpath, **pars)
 
         data.sort_index(inplace=True)
-        data.columns = data.columns.astype(FC.DTYPE)
-        self._ws_P = data.index.to_numpy(FC.DTYPE)
+        data.columns = data.columns.astype(config.dtype_double)
+        self._ws_P = data.index.to_numpy(config.dtype_double)
         self._ti_P = np.sort(data.columns.to_numpy())
-        self._P = data[self._ti_P].to_numpy(FC.DTYPE)
+        self._P = data[self._ti_P].to_numpy(config.dtype_double)
 
         # read ct curve:
         if isinstance(self.source_ct, pd.DataFrame):
             data = self.source_ct
         else:
-            fpath = algo.dbook.get_file_path(PCTCURVE, self.source_ct, check_raw=True)
+            fpath = get_path(self.source_ct)
+            if not fpath.is_file():
+                fpath = algo.dbook.get_file_path(
+                    PCTCURVE, self.source_ct, check_raw=False
+                )
             pars = {"index_col": 0}
             pars.update(self.rpars_ct)
             data = PandasFileHelper.read_file(fpath, **pars)
 
         data.sort_index(inplace=True)
-        data.columns = data.columns.astype(FC.DTYPE)
-        self._ws_ct = data.index.to_numpy(FC.DTYPE)
+        data.columns = data.columns.astype(config.dtype_double)
+        self._ws_ct = data.index.to_numpy(config.dtype_double)
         self._ti_ct = np.sort(data.columns.to_numpy())
-        self._ct = data[self._ti_ct].to_numpy(FC.DTYPE)
+        self._ct = data[self._ti_ct].to_numpy(config.dtype_double)
 
         return super().load_data(algo, verbosity)
 
@@ -279,7 +287,7 @@ class WsTI2PCtFromTwo(TurbineType):
         if np.any(st_sel_P):
             # prepare interpolation:
             n_sel = np.sum(st_sel_P)
-            qts = np.zeros((n_sel, 2), dtype=FC.DTYPE)  # ws, ti
+            qts = np.zeros((n_sel, 2), dtype=config.dtype_double)  # ws, ti
             qts[:, 0] = fdata[self.WSP][st_sel_P]
             qts[:, 1] = fdata[FV.TI][st_sel_P]
 
@@ -328,7 +336,7 @@ class WsTI2PCtFromTwo(TurbineType):
         if np.any(st_sel_ct):
             # prepare interpolation:
             n_sel = np.sum(st_sel_ct)
-            qts = np.zeros((n_sel, 2), dtype=FC.DTYPE)  # ws, ti
+            qts = np.zeros((n_sel, 2), dtype=config.dtype_double)  # ws, ti
             qts[:, 0] = fdata[self.WSP][st_sel_ct]
             qts[:, 1] = fdata[FV.TI][st_sel_ct]
 

foxes/models/vertical_profiles/abl_log_neutral_ws.py

@@ -1,7 +1,7 @@
 from foxes.core import VerticalProfile
 from foxes.utils.abl import neutral
-import foxes.constants as FC
 import foxes.variables as FV
+import foxes.constants as FC
 
 
 class ABLLogNeutralWsProfile(VerticalProfile):

foxes/models/vertical_profiles/abl_log_stable_ws.py

@@ -1,7 +1,7 @@
 from foxes.core import VerticalProfile
 from foxes.utils.abl import stable
-import foxes.constants as FC
 import foxes.variables as FV
+import foxes.constants as FC
 
 
 class ABLLogStableWsProfile(VerticalProfile):

foxes/models/vertical_profiles/abl_log_unstable_ws.py

@@ -1,7 +1,7 @@
 from foxes.core import VerticalProfile
 from foxes.utils.abl import unstable
-import foxes.constants as FC
 import foxes.variables as FV
+import foxes.constants as FC
 
 
 class ABLLogUnstableWsProfile(VerticalProfile):

foxes/models/vertical_profiles/abl_log_ws.py

@@ -2,8 +2,8 @@ import numpy as np
 
 from foxes.core import VerticalProfile
 from foxes.utils import abl
-import foxes.constants as FC
 import foxes.variables as FV
+import foxes.constants as FC
 
 
 class ABLLogWsProfile(VerticalProfile):

foxes/models/wake_frames/dynamic_wakes.py

@@ -4,6 +4,7 @@ from scipy.spatial.distance import cdist
 from foxes.core import WakeFrame, TData
 from foxes.utils import wd2uv
 from foxes.algorithms.iterative import Iterative
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -98,12 +99,14 @@ class DynamicWakes(WakeFrame):
                     f"{self.name}: Expecting 'dt_min' for single step timeseries"
                 )
             self._dt = (
-                (times[1:] - times[:-1]).astype("timedelta64[s]").astype(FC.ITYPE)
+                (times[1:] - times[:-1])
+                .astype("timedelta64[s]")
+                .astype(config.dtype_int)
             )
         else:
             n = max(len(times) - 1, 1)
             self._dt = np.full(n, self.dt_min * 60, dtype="timedelta64[s]").astype(
-                FC.ITYPE
+                config.dtype_int
             )
         self._dt = np.append(self._dt, self._dt[-1, None], axis=0)
 
@@ -141,7 +144,7 @@ class DynamicWakes(WakeFrame):
             The turbine order, shape: (n_states, n_turbines)
 
         """
-        order = np.zeros((fdata.n_states, fdata.n_turbines), dtype=FC.ITYPE)
+        order = np.zeros((fdata.n_states, fdata.n_turbines), dtype=config.dtype_int)
         order[:] = np.arange(fdata.n_turbines)[None, :]
         return order
 
@@ -163,10 +166,15 @@ class DynamicWakes(WakeFrame):
         # compute wakes that start within this chunk: x, y, z, length
         data = algo.get_from_chunk_store(name=key, mdata=mdata, error=False)
         if data is None:
-            data = np.full((n_states, self.max_age, 4), np.nan, dtype=FC.DTYPE)
+            data = np.full(
+                (n_states, self.max_age, 4), np.nan, dtype=config.dtype_double
+            )
             data[:, 0, :3] = rxyh
             data[:, 0, 3] = 0
-            tdt = {v: np.zeros((n_states, 1, 1), dtype=FC.DTYPE) for v in tdi.keys()}
+            tdt = {
+                v: np.zeros((n_states, 1, 1), dtype=config.dtype_double)
+                for v in tdi.keys()
+            }
             pts = data[:, 0, :3].copy()
             for age in range(self.max_age - 1):
                 if age == n_states:
@@ -259,7 +267,7 @@ class DynamicWakes(WakeFrame):
                         n_pts = len(pts)
 
                         tdt = {
-                            v: np.zeros((n_states, n_pts, 1), dtype=FC.DTYPE)
+                            v: np.zeros((n_states, n_pts, 1), dtype=config.dtype_double)
                             for v in algo.states.output_point_vars(algo)
                         }
 
@@ -368,9 +376,9 @@ class DynamicWakes(WakeFrame):
         i0 = mdata.states_i0(counter=True)
 
         # initialize:
-        wcoos = np.full((n_states, n_points, 3), 1e20, dtype=FC.DTYPE)
+        wcoos = np.full((n_states, n_points, 3), 1e20, dtype=config.dtype_double)
         wcoos[:, :, 2] = points[:, :, 2] - rxyh[:, None, 2]
-        wake_si = np.zeros((n_states, n_points), dtype=FC.ITYPE)
+        wake_si = np.zeros((n_states, n_points), dtype=config.dtype_int)
         wake_si[:] = i0 + np.arange(n_states)[:, None]
 
         # find nearest wake point:
@@ -400,7 +408,7 @@ class DynamicWakes(WakeFrame):
                     if np.any(~sel):
                         nx[~sel] -= wdata[sts[~sel], ags[~sel] - 1, :2]
                     dx = np.linalg.norm(nx, axis=-1)
-                    nx /= dx[:, None]
+                    nx /= dx[:, None] + 1e-14
 
                     projx = np.einsum("sd,sd->s", dp, nx)
                     sel = (projx > -dx) & (projx < dx)

foxes/models/wake_frames/farm_order.py

@@ -1,9 +1,10 @@
 import numpy as np
 
-import foxes.constants as FC
-from .rotor_wd import RotorWD
+from foxes.config import config
 from foxes.core import WakeFrame
 
+from .rotor_wd import RotorWD
+
 
 class FarmOrder(WakeFrame):
     """
@@ -90,7 +91,7 @@ class FarmOrder(WakeFrame):
             The turbine order, shape: (n_states, n_turbines)
 
         """
-        order = np.zeros((fdata.n_states, fdata.n_turbines), dtype=FC.ITYPE)
+        order = np.zeros((fdata.n_states, fdata.n_turbines), dtype=config.dtype_int)
         order[:] = np.arange(fdata.n_turbines)[None, :]
 
         return order

foxes/models/wake_frames/rotor_wd.py

@@ -2,6 +2,8 @@ import numpy as np
 
 from foxes.core import WakeFrame
 from foxes.utils import wd2uv
+from foxes.config import config
+
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -104,7 +106,7 @@ class RotorWD(WakeFrame):
 
         wd = fdata[self.var_wd][:, downwind_index]
 
-        nax = np.zeros((n_states, 3, 3), dtype=FC.DTYPE)
+        nax = np.zeros((n_states, 3, 3), dtype=config.dtype_double)
         n = nax[:, 0, :2]
         n[:] = wd2uv(wd, axis=-1)
         m = nax[:, 1, :2]

foxes/models/wake_frames/seq_dynamic_wakes.py

@@ -3,9 +3,10 @@ from scipy.spatial.distance import cdist
 
 from foxes.utils import wd2uv
 from foxes.core.data import TData
+from foxes.config import config
+from foxes.algorithms.sequential import Sequential
 import foxes.variables as FV
 import foxes.constants as FC
-from foxes.algorithms.sequential import Sequential
 
 from .farm_order import FarmOrder
 
@@ -80,19 +81,25 @@ class SeqDynamicWakes(FarmOrder):
                     f"{self.name}: Expecting 'dt_min' for single step timeseries"
                 )
             self._dt = (
-                (times[1:] - times[:-1]).astype("timedelta64[s]").astype(FC.ITYPE)
+                (times[1:] - times[:-1])
+                .astype("timedelta64[s]")
+                .astype(config.dtype_int)
             )
         else:
             n = max(len(times) - 1, 1)
             self._dt = np.full(n, self.dt_min * 60, dtype="timedelta64[s]").astype(
-                FC.ITYPE
+                config.dtype_int
             )
 
         # init wake traces data:
-        self._traces_p = np.zeros((algo.n_states, algo.n_turbines, 3), dtype=FC.DTYPE)
-        self._traces_v = np.zeros((algo.n_states, algo.n_turbines, 3), dtype=FC.DTYPE)
+        self._traces_p = np.zeros(
+            (algo.n_states, algo.n_turbines, 3), dtype=config.dtype_double
+        )
+        self._traces_v = np.zeros(
+            (algo.n_states, algo.n_turbines, 3), dtype=config.dtype_double
+        )
         self._traces_l = np.full(
-            (algo.n_states, algo.n_turbines), np.nan, dtype=FC.DTYPE
+            (algo.n_states, algo.n_turbines), np.nan, dtype=config.dtype_double
         )
 
     def calc_order(self, algo, mdata, fdata):
@@ -192,7 +199,7 @@ class SeqDynamicWakes(FarmOrder):
         del dists
 
         # project:
-        wcoos = np.full((n_states, n_points, 3), 1e20, dtype=FC.DTYPE)
+        wcoos = np.full((n_states, n_points, 3), 1e20, dtype=config.dtype_double)
         wcoos[0, :, 2] = points[0, :, 2] - fdata[FV.TXYH][0, downwind_index, None, 2]
         nx = self._traces_v[tri, downwind_index, :2]
         mv = np.linalg.norm(nx, axis=-1)

foxes/models/wake_frames/streamlines.py

@@ -4,6 +4,7 @@ from scipy.interpolate import interpn
 from foxes.core import WakeFrame
 from foxes.utils import wd2uv
 from foxes.core.data import TData
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -64,7 +65,7 @@ class Streamlines2D(WakeFrame):
         N = int(self.max_length_km * 1e3 / self.step)
 
         # calc data: x, y, z, wd
-        data = np.zeros((n_states, n_turbines, N, 4), dtype=FC.DTYPE)
+        data = np.zeros((n_states, n_turbines, N, 4), dtype=config.dtype_double)
         for i in range(N):
 
             # set streamline start point data (rotor centre):
@@ -86,7 +87,9 @@ class Streamlines2D(WakeFrame):
                 tdata = TData.from_points(
                     data[:, :, i, :3],
                     data={
-                        v: np.full((n_states, n_turbines, 1), np.nan, dtype=FC.DTYPE)
+                        v: np.full(
+                            (n_states, n_turbines, 1), np.nan, dtype=config.dtype_double
+                        )
                         for v in svars
                     },
                     dims={v: (FC.STATE, FC.TARGET, FC.TPOINT) for v in svars},
@@ -151,7 +154,7 @@ class Streamlines2D(WakeFrame):
         del dists, selp
 
         # calculate coordinates:
-        coos = np.full((n_states, n_points, 3), np.nan, dtype=FC.DTYPE)
+        coos = np.full((n_states, n_points, 3), np.nan, dtype=config.dtype_double)
         coos[:, :, 2] = points[:, :, 2] - data[:, :, 2]
         delta = points[:, :, :2] - data[:, :, :2]
         nx = wd2uv(data[:, :, 3])
@@ -193,7 +196,7 @@ class Streamlines2D(WakeFrame):
 
         # calculate streamline x coordinates for turbines rotor centre points:
         # n_states, n_turbines_source, n_turbines_target
-        coosx = np.zeros((n_states, n_turbines, n_turbines), dtype=FC.DTYPE)
+        coosx = np.zeros((n_states, n_turbines, n_turbines), dtype=config.dtype_double)
         for ti in range(n_turbines):
             coosx[:, ti, :] = self.get_wake_coos(algo, mdata, fdata, tdata, ti)[
                 :, :, 0, 0
@@ -201,7 +204,7 @@ class Streamlines2D(WakeFrame):
 
         # derive turbine order:
         # TODO: Remove loop over states
-        order = np.zeros((n_states, n_turbines), dtype=FC.ITYPE)
+        order = np.zeros((n_states, n_turbines), dtype=config.dtype_int)
         for si in range(n_states):
             order[si] = np.lexsort(keys=coosx[si])
 
@@ -273,7 +276,7 @@ class Streamlines2D(WakeFrame):
         xs = self.step * np.arange(n_spts)
 
         # 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] = np.minimum(x, xs[-1])
         qts = qts.reshape(n_states * n_points, 2)