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

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)

foxes/models/wake_frames/timelines.py

@@ -4,6 +4,7 @@ from xarray import Dataset
 from foxes.core import WakeFrame, MData, FData, 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
 
@@ -69,10 +70,16 @@ class Timelines(WakeFrame):
                 raise KeyError(
                     f"{self.name}: Expecting 'dt_min' for single step timeseries"
                 )
-            dt = (times[1:] - times[:-1]).astype("timedelta64[s]").astype(FC.ITYPE)
+            dt = (
+                (times[1:] - times[:-1])
+                .astype("timedelta64[s]")
+                .astype(config.dtype_int)
+            )
         else:
             n = max(len(times) - 1, 1)
-            dt = np.full(n, self.dt_min * 60, dtype="timedelta64[s]").astype(FC.ITYPE)
+            dt = np.full(n, self.dt_min * 60, dtype="timedelta64[s]").astype(
+                config.dtype_int
+            )
 
         # prepare mdata:
         data = algo.get_model_data(states)["coords"]
@@ -90,11 +97,11 @@ class Timelines(WakeFrame):
         # prepare tdata:
         n_states = states.size()
         data = {
-            v: np.zeros((n_states, 1, 1), dtype=FC.DTYPE)
+            v: np.zeros((n_states, 1, 1), dtype=config.dtype_double)
             for v in states.output_point_vars(algo)
         }
         pdims = {v: (FC.STATE, FC.TARGET, FC.TPOINT) for v in data.keys()}
-        points = np.zeros((n_states, 1, 3), dtype=FC.DTYPE)
+        points = np.zeros((n_states, 1, 3), dtype=config.dtype_double)
 
         # calculate all heights:
         self.timelines_data = {"dxy": (("height", FC.STATE, "dir"), [])}
@@ -175,7 +182,7 @@ class Timelines(WakeFrame):
         super().initialize(algo, verbosity)
 
         # find turbine hub heights:
-        t2h = np.zeros(algo.n_turbines, dtype=FC.DTYPE)
+        t2h = np.zeros(algo.n_turbines, dtype=config.dtype_double)
         for ti, t in enumerate(algo.farm.turbines):
             t2h[ti] = (
                 t.H if t.H is not None else algo.farm_controller.turbine_types[ti].H
@@ -285,7 +292,7 @@ class Timelines(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
 
@@ -331,26 +338,26 @@ class Timelines(WakeFrame):
         heights = self.timelines_data["height"].to_numpy()
         data_dxy = self.timelines_data["dxy"].to_numpy()
 
-        D = np.zeros((n_states, n_points), dtype=FC.DTYPE)
+        D = np.zeros((n_states, n_points), dtype=config.dtype_double)
         D[:] = fdata[FV.D][:, downwind_index, None]
 
-        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)
         wcoosx = wcoos[:, :, 0]
         wcoosy = wcoos[:, :, 1]
         wcoos[:, :, 2] = points[:, :, 2] - rxyz[:, None, 2]
 
         i0 = mdata.states_i0(counter=True)
         i1 = i0 + mdata.n_states
-        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]
         for hi, h in enumerate(heights):
             dxy = data_dxy[hi][:i1]
             precond = theights[:, None] == h
 
-            trace_p = np.zeros((n_states, n_points, 2), dtype=FC.DTYPE)
+            trace_p = np.zeros((n_states, n_points, 2), dtype=config.dtype_double)
             trace_p[:] = points[:, :, :2] - rxyz[:, None, :2]
-            trace_l = np.zeros((n_states, n_points), dtype=FC.DTYPE)
-            trace_d = np.full((n_states, n_points), np.inf, dtype=FC.DTYPE)
+            trace_l = np.zeros((n_states, n_points), dtype=config.dtype_double)
+            trace_d = np.full((n_states, n_points), np.inf, dtype=config.dtype_double)
             h_trace_si = trace_si.copy()
 
             # flake8: noqa: F821
@@ -446,12 +453,12 @@ class Timelines(WakeFrame):
         heights = self.timelines_data["height"].to_numpy()
         data_dxy = self.timelines_data["dxy"].to_numpy()
 
-        points = np.zeros((n_states, n_points, 3), dtype=FC.DTYPE)
+        points = np.zeros((n_states, n_points, 3), dtype=config.dtype_double)
         points[:] = rxyz[:, None, :]
 
         trace_dp = np.zeros_like(points[..., :2])
         trace_l = x.copy()
-        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[:] = np.arange(n_states)[:, None]
 
         for hi, h in enumerate(heights):

foxes/models/wake_frames/yawed_wakes.py

@@ -5,8 +5,10 @@ from foxes.models.wake_models.wind.bastankhah16 import (
     Bastankhah2016Model,
     Bastankhah2016,
 )
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
+
 from .rotor_wd import RotorWD
 
 
@@ -200,7 +202,7 @@ class YawedWakes(WakeFrame):
         if np.any(st_sel):
             # prepare:
             n_st_sel = np.sum(st_sel)
-            ydef = np.zeros((n_st_sel,), dtype=FC.DTYPE)
+            ydef = np.zeros((n_st_sel,), dtype=config.dtype_double)
 
             # collect data:
             near = self.model.get_data(Bastankhah2016Model.NEAR, mdata)

foxes/models/wake_models/induction/vortex_sheet.py

@@ -1,7 +1,6 @@
 import numpy as np
 
 from foxes.core import TurbineInductionModel
-from foxes.utils import uv2wd, wd2uv
 import foxes.variables as FV
 import foxes.constants as FC
 

foxes/models/wake_models/ti/crespo_hernandez.py

@@ -2,6 +2,7 @@ import numpy as np
 
 from foxes.core import WakeK
 from foxes.models.wake_models.top_hat import TopHatWakeModel
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -299,7 +300,7 @@ class CrespoHernandezTIWake(TopHatWakeModel):
         twoa = 2 * self.induction.ct2a(ct)
 
         # prepare output:
-        wake_deltas = np.zeros(n_targts, dtype=FC.DTYPE)
+        wake_deltas = np.zeros(n_targts, dtype=config.dtype_double)
 
         # calc near wake length, if not given
         if self.near_wake_D is None:

foxes/models/wake_models/wind/bastankhah14.py

@@ -2,6 +2,7 @@ import numpy as np
 
 from foxes.core import WakeK
 from foxes.models.wake_models.gaussian import GaussianWakeModel
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -187,7 +188,7 @@ class Bastankhah2014(GaussianWakeModel):
         else:
             st_sel = np.zeros_like(x, dtype=bool)
             n_sp = np.sum(st_sel)
-            ampld = np.zeros(n_sp, dtype=FC.DTYPE)
-            sigma = np.zeros(n_sp, dtype=FC.DTYPE)
+            ampld = np.zeros(n_sp, dtype=config.dtype_double)
+            sigma = np.zeros(n_sp, dtype=config.dtype_double)
 
         return {FV.WS: (ampld, sigma)}, st_sel

foxes/models/wake_models/wind/bastankhah16.py

@@ -2,6 +2,7 @@ import numpy as np
 
 from foxes.models.wake_models.dist_sliced import DistSlicedWakeModel
 from foxes.core import Model, WakeK
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -570,7 +571,7 @@ class Bastankhah2016(DistSlicedWakeModel):
         # select targets:
         st_sel = self.model.get_data(Bastankhah2016Model.ST_SEL, mdata)
         n_sp_sel = np.sum(st_sel)
-        wdeltas = {FV.WS: np.zeros((n_sp_sel, n_y_per_z), dtype=FC.DTYPE)}
+        wdeltas = {FV.WS: np.zeros((n_sp_sel, n_y_per_z), dtype=config.dtype_double)}
         if np.any(st_sel):
             # apply filter:
             yz = yz[st_sel]

foxes/models/wake_models/wind/turbopark.py

@@ -2,6 +2,7 @@ import numpy as np
 
 from foxes.core import WakeK
 from foxes.models.wake_models.gaussian import GaussianWakeModel
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -188,8 +189,7 @@ class TurbOParkWake(GaussianWakeModel):
                 fdata=fdata,
                 tdata=tdata,
                 downwind_index=downwind_index,
-                upcast=False,
-                selection=st_sel,
+                upcast=True,
             )
 
             # get k:
@@ -211,6 +211,7 @@ class TurbOParkWake(GaussianWakeModel):
             epsilon = self.sbeta_factor * np.sqrt(beta)
             del a, beta
 
+            ati = ati[st_sel]
             alpha = self.c1 * ati
             beta = self.c2 * ati / np.sqrt(ct)
 
@@ -218,7 +219,6 @@ class TurbOParkWake(GaussianWakeModel):
             sigma = D * (
                 epsilon
                 + k
-                * ati
                 / beta
                 * (
                     np.sqrt((alpha + beta * x / D) ** 2 + 1)
@@ -246,8 +246,8 @@ class TurbOParkWake(GaussianWakeModel):
         else:
             st_sel = np.zeros_like(x, dtype=bool)
             n_sp = np.sum(st_sel)
-            ampld = np.zeros(n_sp, dtype=FC.DTYPE)
-            sigma = np.zeros(n_sp, dtype=FC.DTYPE)
+            ampld = np.zeros(n_sp, dtype=config.dtype_double)
+            sigma = np.zeros(n_sp, dtype=config.dtype_double)
 
         return {FV.WS: (ampld, sigma)}, st_sel
 
@@ -318,6 +318,8 @@ class TurbOParkWakeIX(GaussianWakeModel):
         self.induction = induction
         self.wake_k = WakeK(**wake_k)
 
+        assert not self.wake_k.is_kTI, f"{self.name}: Cannot apply ka or ambka setup"
+
     def __repr__(self):
         iname = (
             self.induction if isinstance(self.induction, str) else self.induction.name
@@ -507,8 +509,8 @@ class TurbOParkWakeIX(GaussianWakeModel):
         else:
             st_sel = np.zeros_like(x, dtype=bool)
             n_sp = np.sum(st_sel)
-            ampld = np.zeros(n_sp, dtype=FC.DTYPE)
-            sigma = np.zeros(n_sp, dtype=FC.DTYPE)
+            ampld = np.zeros(n_sp, dtype=config.dtype_double)
+            sigma = np.zeros(n_sp, dtype=config.dtype_double)
 
         return {FV.WS: (ampld, sigma)}, st_sel
 

foxes/models/wake_superpositions/ws_product.py

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

foxes/output/calc_points.py

@@ -1,9 +1,10 @@
 import numpy as np
 from xarray import Dataset
 
-import foxes.constants as FC
-import foxes.variables as FV
+from foxes.config import config
 from foxes.utils import write_nc
+import foxes.variables as FV
+import foxes.constants as FC
 
 from .output import Output
 
@@ -67,7 +68,7 @@ class PointCalculator(Output):
         weight_turbine: int, optional
             Index of the turbine from which to take the weight
         to_file: str, optional
-            Path to the output netCDF file
+            The output netCDF file name
         write_vars: list of str
             The variables to be written to file, or None
             for all
@@ -87,7 +88,9 @@ class PointCalculator(Output):
             pts = points
             p_has_s = True
         elif points.shape[-1] == 3 and len(points.shape) == 2:
-            pts = np.zeros([self.algo.n_states] + list(points.shape), dtype=FC.DTYPE)
+            pts = np.zeros(
+                [self.algo.n_states] + list(points.shape), dtype=config.dtype_double
+            )
             pts[:] = points[None, :]
             p_has_s = False
         else:

foxes/output/farm_layout.py

@@ -4,7 +4,7 @@ import pandas as pd
 import matplotlib.pyplot as plt
 from mpl_toolkits.axes_grid1 import make_axes_locatable
 
-import foxes.constants as FC
+from foxes.config import config
 import foxes.variables as FV
 from foxes.output.output import Output
 
@@ -31,7 +31,13 @@ class FarmLayoutOutput(Output):
     """
 
     def __init__(
-        self, farm, farm_results=None, from_results=False, results_state=None, D=None
+        self,
+        farm,
+        farm_results=None,
+        from_results=False,
+        results_state=None,
+        D=None,
+        **kwargs,
     ):
         """
         Constructor.
@@ -48,8 +54,11 @@ class FarmLayoutOutput(Output):
             The state index, for from_res
         D: float, optional
             The rotor diameter, if not from data
+        kwargs: dict, optional
+            Additional parameters for the base class
 
         """
+        super().__init__(**kwargs)
         self.farm = farm
         self.fres = farm_results
         self.from_res = from_results
@@ -75,7 +84,7 @@ class FarmLayoutOutput(Output):
 
         """
 
-        data = np.zeros([self.farm.n_turbines, 3], dtype=FC.DTYPE)
+        data = np.zeros([self.farm.n_turbines, 3], dtype=config.dtype_double)
 
         if self.from_res:
             data[:, 0] = self.fres[FV.X][self.rstate]
@@ -284,14 +293,14 @@ class FarmLayoutOutput(Output):
 
         return ax
 
-    def write_plot(self, file_path=None, fontsize=8, **kwargs):
+    def write_plot(self, file_name=None, fontsize=8, **kwargs):
         """
         Writes the layout plot to file.
 
         Parameters
         ----------
-        file_path: str
-            The file into which to plot, or None
+        file_name: str
+            Name of the file into which to plot, or None
             for default
         fontsize: int
             Size of the turbine numbers
@@ -303,8 +312,9 @@ class FarmLayoutOutput(Output):
         ax = self.get_figure(fontsize=fontsize, ret_im=False, **kwargs)
         fig = ax.get_figure()
 
-        fname = file_path if file_path is not None else self.farm.name + ".png"
-        fig.savefig(fname, bbox_inches="tight")
+        fname = file_name if file_name is not None else self.farm.name + ".png"
+        fpath = self.get_fpath(fname)
+        fig.savefig(fpath, bbox_inches="tight")
 
         plt.close(fig)
 
@@ -325,14 +335,14 @@ class FarmLayoutOutput(Output):
         fname = file_path if file_path is not None else self.farm.name + ".xyh"
         np.savetxt(fname, data, header="x y h")
 
-    def write_csv(self, file_path=None, type_col=None, algo=None):
+    def write_csv(self, file_name=None, type_col=None, algo=None):
         """
         Writes csv layout file.
 
         Parameters
         ----------
-        file_path: str
-            The file into which to plot, or None
+        file_name: str
+            Name of the file into which to plot, or None
             for default
         type_col: str, optional
             Name of the turbine type column
@@ -343,7 +353,8 @@ class FarmLayoutOutput(Output):
 
         data = self.get_layout_data()
 
-        fname = file_path if file_path is not None else self.farm.name + ".csv"
+        fname = file_name if file_name is not None else self.farm.name + ".csv"
+        fpath = self.get_fpath(fname)
 
         lyt = pd.DataFrame(index=range(len(data)), columns=["name", "x", "y", "h", "D"])
         lyt.index.name = "index"
@@ -356,22 +367,23 @@ class FarmLayoutOutput(Output):
         if type_col is not None:
             lyt[type_col] = [m.name for m in algo.farm_controller.turbine_types]
 
-        lyt.to_csv(fname)
+        lyt.to_csv(fpath)
 
-    def write_json(self, file_path=None):
+    def write_json(self, file_name=None):
         """
         Writes xyh layout file.
 
         Parameters
         ----------
-        file_path: str
-            The file into which to plot, or None
+        file_name: str
+            Name of the file into which to plot, or None
             for default
 
         """
 
         data = self.get_layout_dict()
 
-        fname = file_path if file_path is not None else self.farm.name + ".json"
-        with open(fname, "w") as outfile:
+        fname = file_name if file_name is not None else self.farm.name + ".json"
+        fpath = self.get_fpath(fname)
+        with open(fpath, "w") as outfile:
             json.dump(data, outfile, indent=4)