foxes 1.2.5__py3-none-any.whl → 1.3__py3-none-any.whl

foxes/input/states/wrg_states.py

@@ -1,4 +1,5 @@
 import numpy as np
+from scipy.interpolate import interpn
 
 from foxes.core.states import States
 from foxes.config import config, get_input_path
@@ -25,6 +26,8 @@ class WRGStates(States):
     bounds_extra_space: float or str
         The extra space, either float in m,
         or str for units of D, e.g. '2.5D'
+    interpn_pars: dict
+        Additional parameters for scipy.interpolate.interpn
 
     :group: input.states
 
@@ -36,7 +39,7 @@ class WRGStates(States):
         ws_bins,
         fixed_vars={},
         bounds_extra_space="1D",
-        **kwargs,
+        **interpn_pars,
     ):
         """
         Constructor
@@ -54,15 +57,16 @@ class WRGStates(States):
         bounds_extra_space: float or str, optional
             The extra space, either float in m,
             or str for units of D, e.g. '2.5D'
-        kwargs: dict, optional
-            Parameters for the base class
+        interpn_pars: dict, optional
+            Additional parameters for scipy.interpolate.interpn
 
         """
-        super().__init__(**kwargs)
+        super().__init__()
         self.wrg_fname = wrg_fname
         self.ws_bins = np.asarray(ws_bins)
         self.fixed_vars = fixed_vars
         self.bounds_extra_space = bounds_extra_space
+        self.interpn_pars = interpn_pars
 
     def load_data(self, algo, verbosity=0):
         """
@@ -100,11 +104,14 @@ class WRGStates(States):
         elif verbosity:
             print(f"States '{self.name}': Reading file {fpath}")
         wrg = ReaderWRG(fpath)
-        self._p0 = np.array([wrg.x0, wrg.y0], dtype=config.dtype_double)
-        self._nx = wrg.nx
-        self._ny = wrg.ny
-        self._ns = wrg.n_sectors
-        self._res = wrg.resolution
+        p0 = np.array([wrg.x0, wrg.y0], dtype=config.dtype_double)
+        nx = wrg.nx
+        ny = wrg.ny
+        ns = wrg.n_sectors
+        res = wrg.resolution
+        p1 = p0 + np.array([nx * res, ny * res])
+        if verbosity > 0:
+            print(f"States '{self.name}': Data bounds {p0} - {p1}")
 
         # find bounds:
         if self.bounds_extra_space is not None:
@@ -112,48 +119,56 @@ class WRGStates(States):
                 extra_space=self.bounds_extra_space, algo=algo
             )
             if verbosity > 0:
-                print(
-                    f"States '{self.name}': Restricting to bounds {xy_min} - {xy_max}"
-                )
-            xy_min -= self._p0
-            xy_max -= self._p0
-            ij_min = np.asarray(xy_min / self._res, dtype=config.dtype_int)
-            ij_max = np.asarray(xy_max / self._res, dtype=config.dtype_int) + 1
+                print(f"States '{self.name}': Farm bounds {xy_min} - {xy_max}")
+            ij_min = np.asarray((xy_min - p0) / res, dtype=config.dtype_int)
+            ij_max = np.asarray((xy_max - p0) / res, dtype=config.dtype_int) + 1
             sx = slice(ij_min[0], ij_max[0])
             sy = slice(ij_min[1], ij_max[1])
         else:
             sx = np.s_[:]
             sy = np.s_[:]
+        self._x = p0[0] + np.arange(nx) * res
+        self._x = self._x[sx]
+        self._y = p0[1] + np.arange(ny) * res
+        self._y = self._y[sy]
+        if len(self._x) < 2 or len(self._y) < 2:
+            raise ValueError(f"No overlap between data bounds and farm bounds")
+        p0[0] = np.min(self._x)
+        p0[1] = np.min(self._y)
+        p1[0] = np.max(self._x)
+        p1[1] = np.max(self._y)
+        if verbosity > 0:
+            print(f"States '{self.name}':  New bounds {p0} - {p1}")
 
         # store data:
         A = []
         k = []
-        fs = []
-        for s in range(self._ns):
-            A.append(wrg.data[f"A_{s}"].to_numpy().reshape(self._ny, self._nx)[sy, sx])
-            k.append(wrg.data[f"k_{s}"].to_numpy().reshape(self._ny, self._nx)[sy, sx])
-            fs.append(
-                wrg.data[f"fs_{s}"].to_numpy().reshape(self._ny, self._nx)[sy, sx]
-            )
+        f = []
+        for s in range(ns):
+            A.append(wrg.data[f"As_{s}"].to_numpy().reshape(ny, nx)[sy, sx])
+            k.append(wrg.data[f"Ks_{s}"].to_numpy().reshape(ny, nx)[sy, sx])
+            f.append(wrg.data[f"fs_{s}"].to_numpy().reshape(ny, nx)[sy, sx])
         del wrg
         A = np.stack(A, axis=0).T
         k = np.stack(k, axis=0).T
-        fs = np.stack(fs, axis=0).T
-        self._data = np.stack([A, k, fs], axis=-1)  # (x, y, wd, AKfs)
+        f = np.stack(f, axis=0).T
+        self._data = np.stack([A, k, f], axis=-1)  # (x, y, wd, AKfs)
 
         # store ws and wd:
-        self.WSWD = self.var("WSWD")
-        self._wds = np.arange(0.0, 360.0, 360 / self._ns)
+        self.VARS = self.var("VARS")
+        self.DATA = self.var("DATA")
+        self._wds = np.arange(0.0, 360.0, 360 / ns)
         self._wsd = self.ws_bins[1:] - self.ws_bins[:-1]
         self._wss = 0.5 * (self.ws_bins[:-1] + self.ws_bins[1:])
-        self._N = len(self._wss) * self._ns
-        wswd = np.zeros((len(self._wss), self._ns, 2), dtype=config.dtype_double)
-        wswd[..., 0] = self._wss[:, None]
-        wswd[..., 1] = self._wds[None, :]
-        wswd = wswd.reshape(self._N, 2)
+        self._N = len(self._wss) * ns
+        data = np.zeros((len(self._wss), ns, 3), dtype=config.dtype_double)
+        data[..., 0] = self._wss[:, None]
+        data[..., 1] = self._wds[None, :]
+        data[..., 2] = self._wsd[:, None]
+        data = data.reshape(self._N, 3)
         idata = super().load_data(algo, verbosity)
-        idata.coords[self.WSWD] = [self.var(FV.WS), self.var(FV.WD)]
-        idata.data_vars[self.WSWD] = ((FC.STATE, self.WSWD), wswd)
+        idata["coords"][self.VARS] = ["ws", "wd", "dws"]
+        idata["data_vars"][self.DATA] = ((FC.STATE, self.VARS), data)
 
         return idata
 
@@ -184,6 +199,103 @@ class WRGStates(States):
             The output variable names
 
         """
-        ovars = set([FV.WS, FV.WD, FV.WEIGHT])
-        ovars.update(self.fixed_vars.values())
+        ovars = set([FV.WS, FV.WD])
+        ovars.update(self.fixed_vars.keys())
         return list(ovars)
+
+    def calculate(self, algo, mdata, fdata, tdata):
+        """
+        The main model calculation.
+
+        This function is executed on a single chunk of data,
+        all computations should be based on numpy arrays.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        mdata: foxes.core.MData
+            The model data
+        fdata: foxes.core.FData
+            The farm data
+        tdata: foxes.core.TData
+            The target point data
+
+        Returns
+        -------
+        results: dict
+            The resulting data, keys: output variable str.
+            Values: numpy.ndarray with shape
+            (n_states, n_targets, n_tpoints)
+
+        """
+
+        # prepare:
+        n_states = tdata.n_states
+        n_targets = tdata.n_targets
+        n_tpoints = tdata.n_tpoints
+        n_pts = n_states * n_targets * n_tpoints
+        points = tdata[FC.TARGETS]
+        ws = mdata[self.DATA][:, 0]
+        wd = mdata[self.DATA][:, 1]
+        wsd = mdata[self.DATA][:, 2]
+
+        out = {}
+
+        out[FV.WS] = tdata[FV.WS]
+        out[FV.WS][:] = ws[:, None, None]
+
+        out[FV.WD] = tdata[FV.WD]
+        out[FV.WD][:] = wd[:, None, None]
+
+        for v, d in self.fixed_vars.items():
+            out[v] = tdata[v]
+            out[v][:] = d
+
+        # interpolate A, k, f from x, y, wd
+        z = points[..., 2].copy()
+        points[..., 2] = wd[:, None, None]
+        pts = points.reshape(n_pts, 3)
+        gvars = (self._x, self._y, self._wds)
+        try:
+            ipars = dict(bounds_error=True, fill_value=None)
+            ipars.update(self.interpn_pars)
+            data = interpn(gvars, self._data, pts, **ipars).reshape(
+                n_states, n_targets, n_tpoints, 3
+            )
+        except ValueError as e:
+            print(f"\nStates '{self.name}': Interpolation error")
+            print("INPUT VARS: (x, y, wd)")
+            print(
+                "DATA BOUNDS:",
+                [float(np.min(d)) for d in gvars],
+                [float(np.max(d)) for d in gvars],
+            )
+            print(
+                "EVAL BOUNDS:",
+                [float(np.min(p)) for p in pts.T],
+                [float(np.max(p)) for p in pts.T],
+            )
+            print(
+                "\nMaybe you want to try the option 'bounds_error=False'? This will extrapolate the data.\n"
+            )
+            raise e
+
+        A = data[..., 0]
+        k = data[..., 1]
+        f = data[..., 2]
+        points[..., 2] = z
+        del data, gvars, pts, z, wd
+
+        tdata.add(
+            FV.WEIGHT,
+            f,
+            dims=(FC.STATE, FC.TARGET, FC.TPOINT),
+        )
+
+        wsA = out[FV.WS] / A
+        tdata[FV.WEIGHT] *= wsd[:, None, None] * (
+            k / A * wsA ** (k - 1) * np.exp(-(wsA**k))
+        )
+
+        return out

foxes/models/partial_wakes/rotor_points.py

@@ -91,8 +91,14 @@ class RotorPoints(PartialWakesModel):
             of shape (n_states, n_rotor_points)
 
         """
-        ares = {v: d[:, downwind_index, None] for v, d in amb_res.items()}
-        wdel = {v: d[:, downwind_index, None].copy() for v, d in wake_deltas.items()}
+        ares = {
+            v: d[:, downwind_index, None] if d.shape[1] > 1 else d[:, 0, None]
+            for v, d in amb_res.items()
+        }
+        wdel = {
+            v: d[:, downwind_index, None].copy() if d.shape[1] > 1 else d[:, 0, None]
+            for v, d in wake_deltas.items()
+        }
         wmodel.finalize_wake_deltas(algo, mdata, fdata, ares, wdel)
 
         return {v: d[:, 0] for v, d in wdel.items()}

foxes/models/partial_wakes/segregated.py

@@ -140,16 +140,21 @@ class PartialSegregated(PartialWakesModel):
         wdel = {v: d[:, downwind_index, None].copy() for v, d in wake_deltas.items()}
 
         if n_rotor_points == tdata.n_tpoints:
-            ares = {v: d[:, downwind_index, None] for v, d in amb_res.items()}
+            ares = {
+                v: d[:, downwind_index, None] if d.shape[1] > 1 else d[:, 0, None]
+                for v, d in amb_res.items()
+            }
         else:
             ares = {}
             for v, d in amb_res.items():
                 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
-                ]
+                ares[v][:] = np.einsum(
+                    "sp,p->s",
+                    d[:, downwind_index] if d.shape[1] > 1 else d[:, 0],
+                    rpoint_weights,
+                )[:, None, None]
 
         wmodel.finalize_wake_deltas(algo, mdata, fdata, ares, wdel)
 

foxes/models/rotor_models/centre.py

@@ -89,7 +89,7 @@ class CentreRotor(RotorModel):
         mdata,
         fdata,
         rpoint_results,
-        weights,
+        rpoint_weights,
         downwind_index=None,
         copy_to_ambient=False,
     ):
@@ -124,9 +124,9 @@ class CentreRotor(RotorModel):
             variables after calculation
 
         """
-        if len(weights) > 1:
+        if len(rpoint_weights) > 1:
             return super().eval_rpoint_results(
-                algo, mdata, fdata, rpoint_results, weights, downwind_index
+                algo, mdata, fdata, rpoint_results, rpoint_weights, downwind_index
             )
 
         n_states = mdata.n_states
@@ -192,7 +192,9 @@ class CentreRotor(RotorModel):
         del uvp
 
         for v in self.calc_vars:
-            if v not in vdone:
+            if v not in vdone and (
+                fdata[v].shape[1] > 1 or downwind_index is None or downwind_index == 0
+            ):
                 res = rpoint_results[v][:, :, 0]
                 self._set_res(fdata, v, res, downwind_index)
                 del res

foxes/models/wake_frames/seq_dynamic_wakes.py

@@ -186,12 +186,15 @@ class SeqDynamicWakes(FarmOrder):
 
             # compute wind vectors at wake traces:
             # TODO: dz from U_z is missing here
-            hpdata = TData.from_points(points=self._traces_p[None, :N, downwind_index])
+            svrs = algo.states.output_point_vars(algo)
+            hpdata = TData.from_points(
+                points=self._traces_p[None, :N, downwind_index], variables=svrs
+            )
             res = algo.states.calculate(algo, mdata, fdata, hpdata)
             self._traces_v[:N, downwind_index, :2] = wd2uv(
                 res[FV.WD][0, :, 0], res[FV.WS][0, :, 0]
             )
-            del hpdata, res
+            del hpdata, res, svrs
 
         # find nearest wake point:
         dists = cdist(points[0], self._traces_p[:N, downwind_index])

foxes/models/wake_frames/timelines.py

@@ -105,6 +105,7 @@ class Timelines(WakeFrame):
 
         # calculate all heights:
         self.timelines_data = {"dxy": (("height", FC.STATE, "dir"), [])}
+        weight_data = None
         for h in heights:
 
             if verbosity > 0:
@@ -118,6 +119,13 @@ class Timelines(WakeFrame):
             )
 
             res = states.calculate(algo, mdata, fdata, tdata)
+
+            if weight_data is None:
+                weight_data = ((FC.STATE,), tdata[FV.WEIGHT][:, 0, 0])
+            elif not np.all(tdata[FV.WEIGHT] == weight_data[1]):
+                raise AssertionError(
+                    f"States '{self.name}': weight data mismatch between heights"
+                )
             del tdata
 
             uv = wd2uv(res[FV.WD], res[FV.WS])[:, 0, 0, :2]
@@ -163,6 +171,8 @@ class Timelines(WakeFrame):
             },
         )
 
+        return weight_data
+
     def initialize(self, algo, verbosity=0):
         """
         Initializes the model.

foxes/output/farm_layout.py

@@ -5,8 +5,9 @@ import matplotlib.pyplot as plt
 from mpl_toolkits.axes_grid1 import make_axes_locatable
 
 from foxes.config import config
-import foxes.variables as FV
 from foxes.output.output import Output
+import foxes.variables as FV
+import foxes.constants as FC
 
 
 class FarmLayoutOutput(Output):
@@ -229,9 +230,16 @@ class FarmLayoutOutput(Output):
                 if self.fres is None:
                     raise ValueError(f"Missing farm_results for color_by '{color_by}'")
                 if color_by[:5] == "mean_":
-                    kw["c"] = np.einsum(
-                        "st,st->t", self.fres[color_by[5:]], self.fres[FV.WEIGHT]
-                    )
+                    weights = self.fres[FV.WEIGHT]
+                    if weights.dims == (FC.STATE,):
+                        wx = "s"
+                    elif weights.dims == (FC.STATE, FC.TURBINE):
+                        wx = "st"
+                    else:
+                        raise ValueError(
+                            f"Unsupported dimensions for '{FV.WEIGHT}': Expecting '{(FC.STATE,)}' or '{(FC.STATE, FC.TURBINE)}', got '{weights.dims}'"
+                        )
+                    kw["c"] = np.einsum(f"st,{wx}->t", self.fres[color_by[5:]], weights)
                 elif color_by[:4] == "sum_":
                     kw["c"] = np.sum(self.fres[color_by[4:]], axis=0)
                 elif color_by[:4] == "min_":

foxes/output/farm_results_eval.py

@@ -76,22 +76,46 @@ class FarmResultsEval(Output):
                 nas = np.zeros_like(fields[-1], dtype=bool)
             nas = nas | np.isnan(fields[-1])
 
-        inds = ["st" for v in fields] + ["st"]
-        expr = ",".join(inds) + "->" + rhs
+        inds = ["st" for __ in fields]
+        if self.results[FV.WEIGHT].dims == (FC.STATE,):
+            inds += ["s"]
+
+            if np.any(nas):
+                sel = ~np.any(nas, axis=1)
+                fields = [f[sel] for f in fields]
+
+                weights0 = self.results[FV.WEIGHT].to_numpy()
+                w0 = np.sum(weights0)
+                weights = weights0[sel]
+                w1 = np.sum(weights)
+                weights *= w0 / w1
+                fields.append(weights)
+
+            else:
+                fields.append(self.results[FV.WEIGHT].to_numpy())
+
+        elif self.results[FV.WEIGHT].dims == (FC.STATE, FC.TURBINE):
+            inds += ["st"]
 
-        if np.any(nas):
-            sel = ~np.any(nas, axis=1)
-            fields = [f[sel] for f in fields]
+            if np.any(nas):
+                sel = ~np.any(nas, axis=1)
+                fields = [f[sel] for f in fields]
 
-            weights0 = self.results[FV.WEIGHT].to_numpy()
-            w0 = np.sum(weights0, axis=0)[None, :]
-            weights = weights0[sel]
-            w1 = np.sum(weights, axis=0)[None, :]
-            weights *= w0 / w1
-            fields.append(weights)
+                weights0 = self.results[FV.WEIGHT].to_numpy()
+                w0 = np.sum(weights0, axis=0)[None, :]
+                weights = weights0[sel]
+                w1 = np.sum(weights, axis=0)[None, :]
+                weights *= w0 / w1
+                fields.append(weights)
+
+            else:
+                fields.append(self.results[FV.WEIGHT].to_numpy())
 
         else:
-            fields.append(self.results[FV.WEIGHT].to_numpy())
+            raise ValueError(
+                f"Expecting '{FV.WEIGHT}' variable with dimensions {(FC.STATE,)} or {(FC.STATE, FC.TURBINE)}, got {self.results[FV.WEIGHT].dims}"
+            )
+        expr = ",".join(inds) + "->" + rhs
 
         return np.einsum(expr, *fields)
 

foxes/output/rose_plot.py

@@ -151,9 +151,19 @@ class RosePlotOutput(Output):
             The plot data
 
         """
+        if self.results[FV.WEIGHT].dims == (FC.STATE,):
+            w = self.results[FV.WEIGHT].to_numpy()
+        elif self.results[FV.WEIGHT].dims == (FC.STATE, FC.TURBINE):
+            w = self.results[FV.WEIGHT].to_numpy()[:, turbine]
+        elif self.results[FV.WEIGHT].dims == (FC.STATE, FC.POINT):
+            w = self.results[FV.WEIGHT].to_numpy()[:, point]
+        else:
+            raise ValueError(
+                f"Wrong dimensions for '{FV.WEIGHT}'. Expecting {(FC.STATE,)}, {(FC.STATE, FC.TURBINE)} or {(FC.STATE, FC.POINT)}, got {self.results[FV.WEIGHT].dims}"
+            )
+
         if add_inf:
             ws_bins = list(ws_bins) + [np.inf]
-        w = self.results[FV.WEIGHT].to_numpy()[:, turbine]
         t = turbine if self._rtype == FC.TURBINE else point
         ws = self.results[ws_var].to_numpy()[:, t]
         wd = self.results[wd_var].to_numpy()[:, t].copy()
@@ -449,8 +459,16 @@ class WindRoseBinPlot(Output):
             The plot data
 
         """
+        if self.farm_results[FV.WEIGHT].dims == (FC.STATE,):
+            w = self.farm_results[FV.WEIGHT].to_numpy()
+        elif self.farm_results[FV.WEIGHT].dims == (FC.STATE, FC.TURBINE):
+            w = self.farm_results[FV.WEIGHT].to_numpy()[:, turbine]
+        else:
+            raise ValueError(
+                f"Wrong dimensions for '{FV.WEIGHT}'. Expecting {(FC.STATE,)} or {(FC.STATE, FC.TURBINE)}, got {self.farm_results[FV.WEIGHT].dims}"
+            )
+
         var = self.farm_results[variable].to_numpy()[:, turbine]
-        w = self.farm_results[FV.WEIGHT].to_numpy()[:, turbine]
         ws = self.farm_results[ws_var].to_numpy()[:, turbine]
         wd = self.farm_results[wd_var].to_numpy()[:, turbine].copy()
         wd_delta = 360 / wd_sectors

foxes/output/slice_data.py

@@ -123,7 +123,6 @@ class SliceData(Output):
         label_map,
         vmin,
         vmax,
-        weight_turbine,
         to_file,
         write_pars,
         ret_states,
@@ -147,12 +146,22 @@ class SliceData(Output):
         del g_pts
 
         # take mean over states:
-        weights = self.fres[FV.WEIGHT][:, weight_turbine].to_numpy()
-        data = {
-            v: np.einsum("s,sp->p", weights, point_results[v].to_numpy())
-            for v in variables
-        }
-        del point_results
+        weights = point_results[FV.WEIGHT].to_numpy()
+        if point_results[FV.WEIGHT].dims == (FC.STATE,):
+            data = {
+                v: np.einsum("s,sp->p", weights, point_results[v].to_numpy())
+                for v in variables
+            }
+        elif point_results[FV.WEIGHT].dims == (FC.STATE, FC.POINT):
+            data = {
+                v: np.einsum("sp,sp->p", weights, point_results[v].to_numpy())
+                for v in variables
+            }
+        else:
+            raise ValueError(
+                f"Wrong dimensions for '{FV.WEIGHT}': Expecting {(FC.STATE,)} or {(FC.STATE, FC.POINT)}, got {point_results[FV.WEIGHT].dims}"
+            )
+        del point_results, weights
 
         # apply data modification:
         a_pos, b_pos, c_pos, data = self._data_mod(
@@ -207,7 +216,6 @@ class SliceData(Output):
         vmax={},
         states_sel=None,
         states_isel=None,
-        weight_turbine=0,
         to_file=None,
         write_pars={},
         ret_states=False,
@@ -260,8 +268,6 @@ class SliceData(Output):
             Reduce to selected states
         states_isel: list, optional
             Reduce to the selected states indices
-        weight_turbine: int, optional
-            Index of the turbine from which to take the weight
         to_file: str, optional
             Write data to this file name
         write_pars: dict
@@ -314,7 +320,6 @@ class SliceData(Output):
             label_map,
             vmin,
             vmax,
-            weight_turbine,
             to_file,
             write_pars,
             ret_states,
@@ -352,7 +357,6 @@ class SliceData(Output):
         vmax={},
         states_sel=None,
         states_isel=None,
-        weight_turbine=0,
         to_file=None,
         write_pars={},
         ret_states=False,
@@ -407,8 +411,6 @@ class SliceData(Output):
             Reduce to selected states
         states_isel: list, optional
             Reduce to the selected states indices
-        weight_turbine: int, optional
-            Index of the turbine from which to take the weight
         to_file: str, optional
             Write data to this file name
         write_pars: dict
@@ -463,7 +465,6 @@ class SliceData(Output):
             label_map,
             vmin,
             vmax,
-            weight_turbine,
             to_file,
             write_pars,
             ret_states,
@@ -501,7 +502,6 @@ class SliceData(Output):
         vmax={},
         states_sel=None,
         states_isel=None,
-        weight_turbine=0,
         to_file=None,
         write_pars={},
         ret_states=False,
@@ -556,8 +556,6 @@ class SliceData(Output):
             Reduce to selected states
         states_isel: list, optional
             Reduce to the selected states indices
-        weight_turbine: int, optional
-            Index of the turbine from which to take the weight
         to_file: str, optional
             Write data to this file name
         write_pars: dict
@@ -612,7 +610,6 @@ class SliceData(Output):
             label_map,
             vmin,
             vmax,
-            weight_turbine,
             to_file,
             write_pars,
             ret_states,

{foxes-1.2.5.dist-info → foxes-1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: foxes
-Version: 1.2.5
+Version: 1.3
 Summary: Farm Optimization and eXtended yield Evaluation Software
 Author: Jonas Schulte
 Maintainer: Jonas Schulte
@@ -191,15 +191,17 @@ For detailed examples of how to run _foxes_, check the `examples` and `notebooks
 ```python
 import foxes
 
-states = foxes.input.states.Timeseries("timeseries_3000.csv.gz", ["WS", "WD","TI","RHO"])
+if __name__ == "__main__":
 
-farm = foxes.WindFarm()
-foxes.input.farm_layout.add_from_file(farm, "test_farm_67.csv", turbine_models=["NREL5MW"])
+    states = foxes.input.states.Timeseries("timeseries_3000.csv.gz", ["WS", "WD","TI","RHO"])
 
-algo = foxes.algorithms.Downwind(farm, states, ["Jensen_linear_k007"])
-farm_results = algo.calc_farm()
+    farm = foxes.WindFarm()
+    foxes.input.farm_layout.add_from_file(farm, "test_farm_67.csv", turbine_models=["NREL5MW"])
 
-print(farm_results)
+    algo = foxes.algorithms.Downwind(farm, states, ["Jensen_linear_k007"])
+    farm_results = algo.calc_farm()
+
+    print(farm_results)
 ```
 
 ## Testing