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

foxes/input/yaml/yaml.py

@@ -0,0 +1,103 @@
+import argparse
+from pathlib import Path
+
+from foxes.utils import Dict
+
+from .dict import run_dict
+
+
+def foxes_yaml():
+    """
+    Command line tool for running foxes from yaml file input.
+
+    Examples
+    --------
+    >>> foxes_yaml input.yaml
+
+    :group: input.yaml
+
+    """
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "yml_file",
+        help="The input yaml file",
+    )
+    parser.add_argument("-o", "--out_dir", help="The output directory", default=".")
+    parser.add_argument("-r", "--rotor", help="The rotor model", default=None)
+    parser.add_argument(
+        "-p", "--pwakes", help="The partial wakes models", default=None, nargs="+"
+    )
+    parser.add_argument(
+        "-w",
+        "--wakes",
+        help="The wake models",
+        default=None,
+        nargs="+",
+    )
+    parser.add_argument("-f", "--frame", help="The wake frame", default=None)
+    parser.add_argument("-e", "--engine", help="The engine", default=None)
+    parser.add_argument(
+        "-n", "--n_procs", help="The number of processes", default=None, type=int
+    )
+    parser.add_argument(
+        "-c",
+        "--chunksize_states",
+        help="The chunk size for states",
+        default=None,
+        type=int,
+    )
+    parser.add_argument(
+        "-C",
+        "--chunksize_points",
+        help="The chunk size for points",
+        default=None,
+        type=int,
+    )
+    parser.add_argument(
+        "-it", "--iterative", help="Use iterative algorithm", action="store_true"
+    )
+    parser.add_argument(
+        "-nf", "--nofig", help="Do not show figures", action="store_true"
+    )
+    parser.add_argument(
+        "-v",
+        "--verbosity",
+        help="The verbosity level, 0 = silent",
+        type=int,
+        default=None,
+    )
+    args = parser.parse_args()
+
+    v = 1 if args.verbosity is None else args.verbosity
+    fpath = Path(args.yml_file)
+    idata = Dict.from_yaml(fpath, verbosity=v)
+
+    if (
+        args.engine is not None
+        or args.n_procs is not None
+        or args.chunksize_states is not None
+        or args.chunksize_points is not None
+    ):
+        epars = dict(
+            engine_type=args.engine,
+            n_procs=args.n_procs,
+            chunk_size_states=args.chunksize_states,
+            chunk_size_points=args.chunksize_points,
+            verbosity=v,
+        )
+    else:
+        epars = None
+
+    run_dict(
+        idata,
+        rotor_model=args.rotor,
+        partial_wakes=args.pwakes,
+        wake_models=args.wakes,
+        wake_frame=args.frame,
+        engine_pars=epars,
+        iterative=args.iterative,
+        work_dir=fpath.parent,
+        out_dir=args.out_dir,
+        verbosity=args.verbosity,
+    )

foxes/models/partial_wakes/axiwake.py

@@ -2,6 +2,7 @@ import numpy as np
 
 from foxes.models.wake_models.axisymmetric import AxisymmetricWakeModel
 from foxes.utils.two_circles import calc_area
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -130,11 +131,11 @@ class PartialAxiwake(PartialCentre):
         x = wcoos[..., 0, 0]
         n = wcoos[..., 0, 1:3]
         R = np.linalg.norm(n, axis=-1)
-        r = np.zeros((n_states, n_targets, self.n), dtype=FC.DTYPE)
+        r = np.zeros((n_states, n_targets, self.n), dtype=config.dtype_double)
         del wcoos
 
         # prepare circle section area calculation:
-        A = np.zeros((n_states, n_targets, self.n), dtype=FC.DTYPE)
+        A = np.zeros((n_states, n_targets, self.n), dtype=config.dtype_double)
         weights = np.zeros_like(A)
 
         # get normalized 2D vector between rotor and wake centres:
@@ -148,12 +149,12 @@ class PartialAxiwake(PartialCentre):
         sel = (x > 1e-8) & (R > D / 2)
         if np.any(sel):
             n_sel = np.sum(sel)
-            Rsel = np.zeros((n_sel, self.n + 1), dtype=FC.DTYPE)
+            Rsel = np.zeros((n_sel, self.n + 1), dtype=config.dtype_double)
             Rsel[:] = R[sel][:, None]
             Dsel = D[sel][:, None]
 
             # equal delta R2:
-            R1 = np.zeros((n_sel, self.n + 1), dtype=FC.DTYPE)
+            R1 = np.zeros((n_sel, self.n + 1), dtype=config.dtype_double)
             R1[:] = Dsel / 2
             steps = np.linspace(0.0, 1.0, self.n + 1, endpoint=True) - 0.5
             R2 = np.zeros_like(R1)
@@ -170,12 +171,12 @@ class PartialAxiwake(PartialCentre):
         sel = (x > 0) & (R < D / 2)
         if np.any(sel):
             n_sel = np.sum(sel)
-            Rsel = np.zeros((n_sel, self.n + 1), dtype=FC.DTYPE)
+            Rsel = np.zeros((n_sel, self.n + 1), dtype=config.dtype_double)
             Rsel[:] = R[sel][:, None]
             Dsel = D[sel][:, None]
 
             # equal delta R2:
-            R1 = np.zeros((n_sel, self.n + 1), dtype=FC.DTYPE)
+            R1 = np.zeros((n_sel, self.n + 1), dtype=config.dtype_double)
             R1[:, 1:] = Dsel / 2
             R2 = np.zeros_like(R1)
             # R2[:, 1:] = Rsel[:, :-1] + Dsel/2

foxes/models/partial_wakes/centre.py

@@ -1,7 +1,8 @@
 import numpy as np
 
 import foxes.variables as FV
-import foxes.constants as FC
+from foxes.config import config
+
 from .rotor_points import RotorPoints
 
 
@@ -37,4 +38,4 @@ class PartialCentre(RotorPoints):
             The target point weights, shape: (n_tpoints,)
 
         """
-        return fdata[FV.TXYH][:, :, None], np.ones(1, dtype=FC.DTYPE)
+        return fdata[FV.TXYH][:, :, None], np.ones(1, dtype=config.dtype_double)

foxes/models/partial_wakes/segregated.py

@@ -1,6 +1,7 @@
 import numpy as np
 
 from foxes.core import PartialWakesModel
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -143,7 +144,9 @@ class PartialSegregated(PartialWakesModel):
         else:
             ares = {}
             for v, d in amb_res.items():
-                ares[v] = np.zeros((n_states, 1, tdata.n_tpoints), dtype=FC.DTYPE)
+                ares[v] = np.zeros(
+                    (n_states, 1, tdata.n_tpoints), dtype=config.dtype_double
+                )
                 ares[v][:] = np.einsum("sp,p->s", d[:, downwind_index], rpoint_weights)[
                     :, None, None
                 ]
@@ -151,7 +154,7 @@ class PartialSegregated(PartialWakesModel):
         wmodel.finalize_wake_deltas(algo, mdata, fdata, ares, wdel)
 
         for v in wdel.keys():
-            hdel = np.zeros((n_states, n_rotor_points), dtype=FC.DTYPE)
+            hdel = np.zeros((n_states, n_rotor_points), dtype=config.dtype_double)
             hdel[:] = np.einsum("sp,p->s", wdel[v][:, 0], gweights)[:, None]
             wdel[v] = hdel
 

foxes/models/point_models/set_uniform_data.py

@@ -2,8 +2,8 @@ import pandas as pd
 
 from foxes.core.point_data_model import PointDataModel
 from foxes.utils import PandasFileHelper
+from foxes.config import config
 import foxes.constants as FC
-import foxes.variables as FV
 
 
 class SetUniformData(PointDataModel):
@@ -84,7 +84,7 @@ class SetUniformData(PointDataModel):
         if isinstance(self.data_source, pd.DataFrame):
             data = self.data_source[
                 [self.var2col.get(v, v) for v in self.ovars]
-            ].to_numpy(FC.DTYPE)
+            ].to_numpy(config.dtype_double)
         elif isinstance(self.data_source, dict):
             pass
         else:
@@ -93,7 +93,9 @@ class SetUniformData(PointDataModel):
             rpars = dict(index_col=0)
             rpars.update(self._rpars)
             data = PandasFileHelper().read_file(self.data_source, **rpars)
-            data = data[[self.var2col.get(v, v) for v in self.ovars]].to_numpy(FC.DTYPE)
+            data = data[[self.var2col.get(v, v) for v in self.ovars]].to_numpy(
+                config.dtype_double
+            )
 
         idata = super().load_data(algo, verbosity)
         idata["coords"][self.VARS] = self.ovars

foxes/models/rotor_models/centre.py

@@ -3,7 +3,7 @@ import numpy as np
 from foxes.core import RotorModel
 from foxes.utils import wd2uv, uv2wd
 import foxes.variables as FV
-import foxes.constants as FC
+from foxes.config import config
 
 
 class CentreRotor(RotorModel):
@@ -155,7 +155,7 @@ class CentreRotor(RotorModel):
         vdone = []
         for v in self.calc_vars:
             if v not in fdata:
-                fdata[v] = np.zeros((n_states, n_turbines), dtype=FC.DTYPE)
+                fdata[v] = np.zeros((n_states, n_turbines), dtype=config.dtype_double)
 
             if v == FV.WD or v == FV.YAW:
                 if wd is None:

foxes/models/rotor_models/grid.py

@@ -1,7 +1,7 @@
 import numpy as np
 
 from foxes.core import RotorModel
-import foxes.constants as FC
+from foxes.config import config
 
 
 class GridRotor(RotorModel):
@@ -75,12 +75,12 @@ class GridRotor(RotorModel):
         x = [-1.0 + (i + 0.5) * delta for i in range(self.n)]
         x, y = np.meshgrid(x, x, indexing="ij")
 
-        self.__dpoints = np.zeros([N, 3], dtype=FC.DTYPE)
+        self.__dpoints = np.zeros([N, 3], dtype=config.dtype_double)
         self.__dpoints[:, 1] = x.reshape(N)
         self.__dpoints[:, 2] = y.reshape(N)
 
         if self.reduce:
-            self.__weights = np.zeros((self.n, self.n), dtype=FC.DTYPE)
+            self.__weights = np.zeros((self.n, self.n), dtype=config.dtype_double)
             for i in range(0, self.n):
                 for j in range(0, self.n):
                     d = delta / self.nint
@@ -90,7 +90,7 @@ class GridRotor(RotorModel):
                     hy = [
                         y[i, j] - delta / 2.0 + (k + 0.5) * d for k in range(self.nint)
                     ]
-                    pts = np.zeros((self.nint, self.nint, 2), dtype=FC.DTYPE)
+                    pts = np.zeros((self.nint, self.nint, 2), dtype=config.dtype_double)
                     pts[:, :, 0], pts[:, :, 1] = np.meshgrid(hx, hy, indexing="ij")
 
                     d = np.linalg.norm(pts, axis=2)
@@ -105,7 +105,7 @@ class GridRotor(RotorModel):
         else:
             self.__dpoints[:, 1] = x.reshape(N)
             self.__dpoints[:, 2] = y.reshape(N)
-            self.__weights = np.ones(N, dtype=FC.DTYPE) / N
+            self.__weights = np.ones(N, dtype=config.dtype_double) / N
 
     def n_rotor_points(self):
         """

foxes/models/rotor_models/levels.py

@@ -1,7 +1,7 @@
 import numpy as np
 
 from foxes.core import RotorModel
-import foxes.constants as FC
+from foxes.config import config
 
 
 class LevelRotor(RotorModel):
@@ -69,20 +69,20 @@ class LevelRotor(RotorModel):
 
         delta = 2.0 / self.n
         y = [-1.0 + (i + 0.5) * delta for i in range(self.n)]
-        x = np.zeros(self.n, dtype=FC.DTYPE)
+        x = np.zeros(self.n, dtype=config.dtype_double)
 
-        self.dpoints = np.zeros([self.n, 3], dtype=FC.DTYPE)
+        self.dpoints = np.zeros([self.n, 3], dtype=config.dtype_double)
         self.dpoints[:, 1] = x
         self.dpoints[:, 2] = y
 
         if self.reduce:
-            self.weights = np.zeros((self.n), dtype=FC.DTYPE)
+            self.weights = np.zeros((self.n), dtype=config.dtype_double)
             hx = np.linspace(1, -1, self.nint)
 
             for i in range(0, self.n):
                 d = delta / self.nint
                 hy = [y[i] - delta / 2.0 + (k + 0.5) * d for k in range(self.nint)]
-                pts = np.zeros((self.nint, self.nint, 2), dtype=FC.DTYPE)
+                pts = np.zeros((self.nint, self.nint, 2), dtype=config.dtype_double)
                 pts[:, :, 0], pts[:, :, 1] = np.meshgrid(hx, hy, indexing="ij")
 
                 d = np.linalg.norm(pts, axis=2)
@@ -96,7 +96,7 @@ class LevelRotor(RotorModel):
         else:
             self.dpoints[:, 1] = x
             self.dpoints[:, 2] = y
-            self.weights = np.ones(self.n, dtype=FC.DTYPE) / self.n
+            self.weights = np.ones(self.n, dtype=config.dtype_double) / self.n
 
     def n_rotor_points(self):
         """

foxes/models/turbine_models/kTI_model.py

@@ -1,6 +1,7 @@
 import numpy as np
 
 from foxes.core import TurbineModel
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -128,7 +129,8 @@ class kTI(TurbineModel):
         )
 
         k = fdata.get(
-            self.k_var, np.zeros((fdata.n_states, fdata.n_turbines), dtype=FC.DTYPE)
+            self.k_var,
+            np.zeros((fdata.n_states, fdata.n_turbines), dtype=config.dtype_double),
         )
 
         k[st_sel] = kti * ti + kb

foxes/models/turbine_models/lookup_table.py

@@ -4,6 +4,7 @@ import xarray as xr
 
 from foxes.core import TurbineModel
 from foxes.utils import PandasFileHelper
+from foxes.config import config, get_path
 import foxes.constants as FC
 
 
@@ -127,9 +128,10 @@ class LookupTable(TurbineModel):
             if isinstance(self.data_source, pd.DataFrame):
                 data = self.data_source
             else:
+                fpath = get_path(self.data_source)
                 if verbosity > 0:
-                    print(f"{self.name}: Reading file {self.data_source}")
-                data = PandasFileHelper.read_file(self.data_source, **self._rpars)
+                    print(f"{self.name}: Reading file {fpath}")
+                data = PandasFileHelper.read_file(fpath, **self._rpars)
 
             if verbosity > 0:
                 print(f"{self.name}: Preparing interpolation data")
@@ -138,7 +140,8 @@ class LookupTable(TurbineModel):
             data = data[self.input_vars + self.output_vars]
             data.sort_values(by=self.input_vars, inplace=True)
             coords = {
-                v: np.asarray(data[v].unique(), dtype=FC.DTYPE) for v in self.input_vars
+                v: np.asarray(data[v].unique(), dtype=config.dtype_double)
+                for v in self.input_vars
             }
 
             dvars = {}
@@ -146,7 +149,7 @@ class LookupTable(TurbineModel):
                 pivot_matrix = data.pivot_table(index=self.input_vars, values=[oname])
                 dvars[oname] = (
                     self.input_vars,
-                    pivot_matrix.to_numpy(FC.DTYPE).reshape(
+                    pivot_matrix.to_numpy(config.dtype_double).reshape(
                         pivot_matrix.index.levshape
                     ),
                 )

foxes/models/turbine_models/power_mask.py

@@ -1,9 +1,9 @@
 import numpy as np
 
 from foxes.core import TurbineModel
-import foxes.variables as FV
-import foxes.constants as FC
+from foxes.config import config
 from foxes.utils import cubic_roots
+import foxes.variables as FV
 
 
 class PowerMask(TurbineModel):
@@ -33,7 +33,13 @@ class PowerMask(TurbineModel):
 
     """
 
-    def __init__(self, var_ws_P=FV.REWS3, factor_P=1.0e3, P_lim=100, induction="Betz"):
+    def __init__(
+        self,
+        var_ws_P=FV.REWS3,
+        factor_P=1.0e3,
+        P_lim=100,
+        induction="Betz",
+    ):
         """
         Constructor.
 
@@ -110,13 +116,13 @@ class PowerMask(TurbineModel):
 
         self._P_rated = []
         for t in algo.farm_controller.turbine_types:
-            Pnom = FC.DTYPE(t.P_nominal)
+            Pnom = config.dtype_double(t.P_nominal)
             if np.isnan(Pnom):
                 raise ValueError(
                     f"Model '{self.name}': P_nominal is NaN for turbine type '{t.name}'"
                 )
             self._P_rated.append(Pnom)
-        self._P_rated = np.array(self._P_rated, dtype=FC.DTYPE)
+        self._P_rated = np.array(self._P_rated, dtype=config.dtype_double)
 
     def calculate(self, algo, mdata, fdata, st_sel):
         """
@@ -183,9 +189,9 @@ class PowerMask(TurbineModel):
 
             # find roots:
             N = len(cp)
-            a3 = np.full(N, 4.0, dtype=FC.DTYPE)
-            a2 = np.full(N, -8.0, dtype=FC.DTYPE)
-            a1 = np.full(N, 4.0, dtype=FC.DTYPE)
+            a3 = np.full(N, 4.0, dtype=config.dtype_double)
+            a2 = np.full(N, -8.0, dtype=config.dtype_double)
+            a1 = np.full(N, 4.0, dtype=config.dtype_double)
             a0 = -cp / e
             rts = cubic_roots(a0, a1, a2, a3)
             rts[np.isnan(rts)] = np.inf

foxes/models/turbine_models/sector_management.py

@@ -3,6 +3,7 @@ import pandas as pd
 
 from foxes.core import TurbineModel
 from foxes.utils import PandasFileHelper
+from foxes.config import get_path
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -90,9 +91,10 @@ class SectorManagement(TurbineModel):
         if isinstance(self.source, pd.DataFrame):
             data = self.source
         else:
+            fpath = get_path(self.source)
             if verbosity > 0:
-                print(f"{self.name}: Reading file {self.source}")
-            data = PandasFileHelper.read_file(self.source, **self._rpars)
+                print(f"{self.name}: Reading file {fpath}")
+            data = PandasFileHelper.read_file(fpath, **self._rpars)
 
         if self._trbs is None:
             if self._col_i is not None and self._col_t is None:

foxes/models/turbine_models/set_farm_vars.py

@@ -1,8 +1,9 @@
 import numpy as np
 
 from foxes.core import TurbineModel
-import foxes.constants as FC
+from foxes.config import config
 import foxes.variables as FV
+import foxes.constants as FC
 
 
 class SetFarmVars(TurbineModel):
@@ -13,12 +14,14 @@ class SetFarmVars(TurbineModel):
     ----------
     vars: list of str
         The variables to be set
+    once: bool
+        Flag for running only once
 
     :group: models.turbine_models
 
     """
 
-    def __init__(self, pre_rotor=False):
+    def __init__(self, pre_rotor=False, once=False):
         """
         Constructor.
 
@@ -27,9 +30,12 @@ class SetFarmVars(TurbineModel):
         pre_rotor: bool
             Flag for running this model before
             running the rotor model.
+        once: bool
+            Flag for running only once
 
         """
         super().__init__(pre_rotor=pre_rotor)
+        self.once = once
         self.reset()
 
     def add_var(self, var, data):
@@ -51,7 +57,7 @@ class SetFarmVars(TurbineModel):
         if self.running:
             raise ValueError(f"Model '{self.name}': Cannot add_var while running")
         self.vars.append(var)
-        self.__vdata.append(np.asarray(data, dtype=FC.DTYPE))
+        self.__vdata.append(np.asarray(data, dtype=config.dtype_double))
 
     def reset(self):
         """
@@ -62,6 +68,23 @@ class SetFarmVars(TurbineModel):
         self.vars = []
         self.__vdata = []
 
+    def initialize(self, algo, verbosity=0, force=False):
+        """
+        Initializes the model.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        verbosity: int
+            The verbosity level, 0 = silent
+        force: bool
+            Overwrite existing data
+
+        """
+        super().initialize(algo, verbosity, force)
+        self.__once_done = set()
+
     def output_farm_vars(self, algo):
         """
         The variables which are being modified by the model.
@@ -105,7 +128,9 @@ class SetFarmVars(TurbineModel):
         idata = super().load_data(algo, verbosity)
 
         for i, v in enumerate(self.vars):
-            data = np.full((algo.n_states, algo.n_turbines), np.nan, dtype=FC.DTYPE)
+            data = np.full(
+                (algo.n_states, algo.n_turbines), np.nan, dtype=config.dtype_double
+            )
             vdata = self.__vdata[i]
 
             # handle special case of call during vectorized optimization:
@@ -117,7 +142,7 @@ class SetFarmVars(TurbineModel):
                 n_pop = algo.states.n_pop
                 n_ost = algo.states.states.size()
                 n_trb = algo.n_turbines
-                vdata = np.zeros((n_pop, n_ost, n_trb), dtype=FC.DTYPE)
+                vdata = np.zeros((n_pop, n_ost, n_trb), dtype=config.dtype_double)
                 vdata[:] = self.__vdata[i][None, :]
                 vdata = vdata.reshape(n_pop * n_ost, n_trb)
 
@@ -130,7 +155,7 @@ class SetFarmVars(TurbineModel):
                 for ti in range(algo.n_turbines):
                     t = algo.farm.turbines[ti]
                     if len(t.xy.shape) == 1:
-                        xy = np.zeros((algo.n_states, 2), dtype=FC.DTYPE)
+                        xy = np.zeros((algo.n_states, 2), dtype=config.dtype_double)
                         xy[:] = t.xy[None, :]
                         t.xy = xy
                     t.xy[:, i] = np.where(
@@ -141,7 +166,7 @@ class SetFarmVars(TurbineModel):
             if v in [FV.D, FV.H]:
                 for ti in range(algo.n_turbines):
                     t = algo.farm.turbines[ti]
-                    x = np.zeros(algo.n_states, dtype=FC.DTYPE)
+                    x = np.zeros(algo.n_states, dtype=config.dtype_double)
                     if v == FV.D:
                         x[:] = t.D
                         t.D = x
@@ -243,21 +268,26 @@ class SetFarmVars(TurbineModel):
             Values: numpy.ndarray with shape (n_states, n_turbines)
 
         """
-        if self.pre_rotor:
-            order = np.s_[:]
-            ssel = np.s_[:]
-        else:
-            order = fdata[FV.ORDER]
-            ssel = fdata[FV.ORDER_SSEL]
-
-        bsel = np.zeros((fdata.n_states, fdata.n_turbines), dtype=bool)
-        bsel[st_sel] = True
-
-        for v in self.vars:
-            data = mdata[self.var(v)][ssel, order]
-            hsel = ~np.isnan(data)
-            tsel = bsel & hsel
-
-            fdata[v][tsel] = data[tsel]
+        i0 = mdata.states_i0(counter=True)
+        if not self.once or i0 not in self.__once_done:
+
+            if self.pre_rotor:
+                order = np.s_[:]
+                ssel = np.s_[:]
+            else:
+                order = fdata[FV.ORDER]
+                ssel = fdata[FV.ORDER_SSEL]
+
+            bsel = np.zeros((fdata.n_states, fdata.n_turbines), dtype=bool)
+            bsel[st_sel] = True
+
+            for v in self.vars:
+                data = mdata[self.var(v)][ssel, order]
+                hsel = ~np.isnan(data)
+                tsel = bsel & hsel
+
+                fdata[v][tsel] = data[tsel]
+
+            self.__once_done.add(i0)
 
         return {v: fdata[v] for v in self.vars}

foxes/models/turbine_models/table_factors.py

@@ -4,7 +4,7 @@ from scipy.interpolate import interpn
 
 from foxes.core import TurbineModel
 from foxes.utils import PandasFileHelper
-import foxes.constants as FC
+from foxes.config import config, get_path
 
 
 class TableFactors(TurbineModel):
@@ -106,15 +106,16 @@ class TableFactors(TurbineModel):
         if isinstance(self.data_source, pd.DataFrame):
             self._data = self.data_source
         else:
+            fpath = get_path(self.data_source)
             if verbosity > 0:
-                print(f"{self.name}: Reading file {self.data_source}")
+                print(f"{self.name}: Reading file {fpath}")
             rpars = dict(index_col=0)
             rpars.update(self._rpars)
-            self._data = PandasFileHelper.read_file(self.data_source, **rpars)
+            self._data = PandasFileHelper.read_file(fpath, **rpars)
 
-        self._rvals = self._data.index.to_numpy(FC.DTYPE)
-        self._cvals = self._data.columns.to_numpy(FC.DTYPE)
-        self._data = self._data.to_numpy(FC.DTYPE)
+        self._rvals = self._data.index.to_numpy(config.dtype_double)
+        self._cvals = self._data.columns.to_numpy(config.dtype_double)
+        self._data = self._data.to_numpy(config.dtype_double)
 
     def calculate(self, algo, mdata, fdata, st_sel):
         """
@@ -143,7 +144,7 @@ class TableFactors(TurbineModel):
 
         """
         n_sel = np.sum(st_sel)
-        qts = np.zeros((n_sel, 2), dtype=FC.DTYPE)
+        qts = np.zeros((n_sel, 2), dtype=config.dtype_double)
         qts[:, 0] = fdata[self.row_var][st_sel]
         qts[:, 1] = fdata[self.col_var][st_sel]
 

foxes/models/turbine_models/yaw2yawm.py

@@ -1,6 +1,5 @@
 from foxes.core import TurbineModel
 import foxes.variables as FV
-import foxes.constants as FC
 from foxes.utils import delta_wd
 
 

foxes/models/turbine_models/yawm2yaw.py

@@ -2,7 +2,6 @@ import numpy as np
 
 from foxes.core import TurbineModel
 import foxes.variables as FV
-import foxes.constants as FC
 
 
 class YAWM2YAW(TurbineModel):