foxes 1.4__tar.gz → 1.5__tar.gz

{foxes-1.4/foxes.egg-info → foxes-1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: foxes
-Version: 1.4
+Version: 1.5
 Summary: Farm Optimization and eXtended yield Evaluation Software
 Author: Jonas Schulte
 Maintainer: Jonas Schulte
@@ -36,7 +36,6 @@ Classifier: Topic :: Scientific/Engineering
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -45,60 +44,41 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Development Status :: 4 - Beta
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: matplotlib
-Requires-Dist: numpy
-Requires-Dist: pandas
-Requires-Dist: xarray
-Requires-Dist: scipy
-Requires-Dist: cycler
-Requires-Dist: tqdm
-Requires-Dist: pyyaml
-Requires-Dist: h5netcdf
+Requires-Dist: cycler>=0.10
+Requires-Dist: h5netcdf>=1.0
+Requires-Dist: matplotlib>=3.8
+Requires-Dist: numpy>=1.26
+Requires-Dist: pandas>=2.0
+Requires-Dist: pyyaml>=4.0
+Requires-Dist: scipy>=1.12
+Requires-Dist: tqdm>=2.0
+Requires-Dist: xarray>=2023
 Provides-Extra: opt
-Requires-Dist: foxes-opt; extra == "opt"
+Requires-Dist: foxes-opt>=0.5; extra == "opt"
 Provides-Extra: dask
-Requires-Dist: dask; extra == "dask"
-Requires-Dist: distributed; extra == "dask"
-Requires-Dist: dask-jobqueue; extra == "dask"
-Requires-Dist: setuptools; extra == "dask"
-Provides-Extra: eng
-Requires-Dist: multiprocess; extra == "eng"
-Requires-Dist: dask; extra == "eng"
-Requires-Dist: distributed; extra == "eng"
-Requires-Dist: dask-jobqueue; extra == "eng"
-Requires-Dist: setuptools; extra == "eng"
-Requires-Dist: mpi4py; extra == "eng"
-Requires-Dist: ray; extra == "eng"
-Provides-Extra: eng0
-Requires-Dist: multiprocess; extra == "eng0"
-Requires-Dist: dask; extra == "eng0"
-Requires-Dist: distributed; extra == "eng0"
-Requires-Dist: dask-jobqueue; extra == "eng0"
-Requires-Dist: setuptools; extra == "eng0"
-Requires-Dist: ray; extra == "eng0"
-Provides-Extra: test
-Requires-Dist: flake8; extra == "test"
-Requires-Dist: pytest; extra == "test"
+Requires-Dist: dask>=2022.0; extra == "dask"
+Requires-Dist: distributed>=2022.0; extra == "dask"
+Requires-Dist: dask-jobqueue>=0.8; extra == "dask"
+Requires-Dist: setuptools>=61.0; extra == "dask"
 Provides-Extra: doc
-Requires-Dist: setuptools; extra == "doc"
-Requires-Dist: sphinx; extra == "doc"
-Requires-Dist: sphinx-immaterial; extra == "doc"
-Requires-Dist: nbsphinx; extra == "doc"
-Requires-Dist: ipykernel; extra == "doc"
-Requires-Dist: ipywidgets; extra == "doc"
-Requires-Dist: m2r2; extra == "doc"
-Requires-Dist: lxml_html_clean; extra == "doc"
-Requires-Dist: dask; extra == "doc"
-Requires-Dist: distributed; extra == "doc"
-Provides-Extra: dev
-Requires-Dist: flake8; extra == "dev"
-Requires-Dist: pytest; extra == "dev"
-Requires-Dist: jupyter; extra == "dev"
-Requires-Dist: objsize; extra == "dev"
-Requires-Dist: ruff; extra == "dev"
+Requires-Dist: setuptools>=61.0; extra == "doc"
+Requires-Dist: sphinx>=5.0; extra == "doc"
+Requires-Dist: sphinx-immaterial>=0.10; extra == "doc"
+Requires-Dist: nbsphinx>=0.5; extra == "doc"
+Requires-Dist: ipykernel>=5.0; extra == "doc"
+Requires-Dist: ipywidgets>=5.0; extra == "doc"
+Requires-Dist: m2r2>=0.2; extra == "doc"
+Requires-Dist: lxml_html_clean>=0.4; extra == "doc"
+Requires-Dist: dask>=2022.0; extra == "doc"
+Requires-Dist: distributed>=2022.0; extra == "doc"
+Provides-Extra: test
+Requires-Dist: flake8>=0.1; extra == "test"
+Requires-Dist: pytest>=7.0; extra == "test"
+Provides-Extra: utils
+Requires-Dist: objsize>=0.5; extra == "utils"
 Dynamic: license-file
 
 # Welcome to foxes
@@ -159,7 +139,7 @@ Evaluation Software"`
 
 ## Requirements
 
-The supported Python versions are `Python 3.8`...`3.13`.
+The supported Python versions are `Python 3.9`...`3.13`.
 
 ## Installation
 

{foxes-1.4 → foxes-1.5}/README.md

@@ -56,7 +56,7 @@ Evaluation Software"`
 
 ## Requirements
 
-The supported Python versions are `Python 3.8`...`3.13`.
+The supported Python versions are `Python 3.9`...`3.13`.
 
 ## Installation
 

{foxes-1.4 → foxes-1.5}/docs/source/conf.py

@@ -68,7 +68,7 @@ intersphinx_mapping = {
 
 # The suffix(es) of source filenames.
 #
-source_suffix = {'.rst': 'restructuredtext', '.md': 'restructuredtext'}
+source_suffix = {".rst": "restructuredtext", ".md": "restructuredtext"}
 
 # The master toctree document.
 master_doc = "index"

{foxes-1.4 → foxes-1.5}/examples/field_data_nc/run.py

@@ -70,7 +70,7 @@ if __name__ == "__main__":
     )
     args = parser.parse_args()
 
-    states = foxes.input.states.FieldDataNC(
+    states = foxes.input.states.FieldData(
         args.file_pattern,
         output_vars=[FV.WS, FV.WD, FV.TI, FV.RHO],
         load_mode=args.load_mode,

{foxes-1.4 → foxes-1.5}/examples/streamline_wakes/run.py

@@ -97,7 +97,7 @@ if __name__ == "__main__":
         mbook.turbine_models["set_yawm"].add_var(FV.YAWM, yawm)
         ymodels = ["set_yawm"]
 
-    states = foxes.input.states.FieldDataNC(
+    states = foxes.input.states.FieldData(
         args.file_pattern,
         states_coord="state",
         x_coord="x",
@@ -108,7 +108,7 @@ if __name__ == "__main__":
         var2ncvar={FV.WS: "ws", FV.WD: "wd"},
         fixed_vars={FV.RHO: 1.225, FV.TI: 0.1},
         load_mode=args.load_mode,
-        bounds_error=False,
+        interpn_pars=dict(bounds_error=False),
     )
 
     farm = foxes.WindFarm()

{foxes-1.4 → foxes-1.5}/examples/yawed_wake/run.py

@@ -82,7 +82,9 @@ if __name__ == "__main__":
 
     # set turbines in yaw
     yawm = np.array([[args.yawm, args.yawm2]])
-    mbook.turbine_models["set_yawm"] = foxes.models.turbine_models.SetFarmVars()
+    mbook.turbine_models["set_yawm"] = foxes.models.turbine_models.SetFarmVars(
+        pre_rotor=True
+    )
     mbook.turbine_models["set_yawm"].add_var(FV.YAWM, yawm)
 
     # create states

{foxes-1.4 → foxes-1.5}/foxes/algorithms/downwind/downwind.py

@@ -477,7 +477,7 @@ class Downwind(Algorithm):
         # 2) calculate ambient rotor results:
         mlist.models.append(self.rotor_model)
         calc_pars.append(calc_parameters.get(mlist.models[-1].name, {}))
-        calc_pars[-1].update({"store": True})
+        calc_pars[-1]["store"] = True
 
         # 3) run post-rotor turbine models via farm controller:
         mlist.models.append(self.farm_controller)
@@ -508,7 +508,7 @@ class Downwind(Algorithm):
     def _launch_parallel_farm_calc(
         self,
         mlist,
-        *data,
+        model_data,
         outputs=None,
         normalize=False,
         **kwargs,
@@ -520,8 +520,8 @@ class Downwind(Algorithm):
         ----------
         mlist: foxes.models.FarmDataModelList
             The model list
-        data: tuple of xarray.Dataset
-            The (mdata, fdata) inputs
+        model_data: xarray.Dataset
+            The initial model data
         outputs: list of str, optional
             The output variables, or None for defaults
         normalize: bool
@@ -538,7 +538,7 @@ class Downwind(Algorithm):
         """
         out_vars = self.farm_vars if outputs is None else outputs
         farm_results = get_engine().run_calculation(
-            self, mlist, *data, out_vars=out_vars, **kwargs
+            self, mlist, model_data, out_vars=out_vars, **kwargs
         )
 
         if normalize:

{foxes-1.4 → foxes-1.5}/foxes/algorithms/downwind/models/init_farm_data.py

@@ -74,17 +74,17 @@ class InitFarmData(FarmDataModel):
         n_states = fdata.n_states
         n_turbines = algo.n_turbines
 
-        # define FV.TXYH as vector [X, Y, H]:
-        fdata[FV.TXYH] = np.full(
-            (n_states, n_turbines, 3), np.nan, dtype=config.dtype_double
+        # add and set X, Y, H, D:
+        fdata.add(
+            FV.TXYH,
+            np.zeros((n_states, n_turbines, 3), dtype=config.dtype_double),
+            (FC.STATE, FC.TURBINE, FC.XYH),
+        )
+        fdata.add(
+            FV.D,
+            np.zeros((n_states, n_turbines), dtype=config.dtype_double),
+            (FC.STATE, FC.TURBINE),
         )
-        fdata.dims[FV.TXYH] = (FC.STATE, FC.TURBINE, FC.XYH)
-        for i, v in enumerate([FV.X, FV.Y, FV.H]):
-            fdata[v] = fdata[FV.TXYH][..., i]
-            fdata.dims[v] = (FC.STATE, FC.TURBINE)
-
-        # set X, Y, H, D:
-        fdata[FV.D] = np.zeros((n_states, n_turbines), dtype=config.dtype_double)
         for ti, t in enumerate(algo.farm.turbines):
             if len(t.xy.shape) == 1:
                 fdata[FV.TXYH][:, ti, :2] = t.xy[None, :]
@@ -103,34 +103,64 @@ class InitFarmData(FarmDataModel):
                 D = algo.farm_controller.turbine_types[ti].D
             fdata[FV.D][:, ti] = D
 
-        # calc WD and YAW at rotor centres:
+        # calc WD at rotor centres:
         svrs = algo.states.output_point_vars(algo)
         tdata = TData.from_points(points=fdata[FV.TXYH], variables=svrs)
         sres = algo.states.calculate(algo, mdata, fdata, tdata)
-        fdata[FV.WD] = sres[FV.WD][:, :, 0]
+        fdata.add(
+            FV.WD,
+            sres[FV.WD][:, :, 0],
+            (FC.STATE, FC.TURBINE),
+        )
+        fdata.add(
+            FV.AMB_WD,
+            fdata[FV.WD].copy(),
+            (FC.STATE, FC.TURBINE),
+        )
         del tdata, sres, svrs
 
-        # calculate and inverse:
+        # calculate downwind order:
         order = algo.wake_frame.calc_order(algo, mdata, fdata)
         ssel = np.zeros_like(order)
         ssel[:] = np.arange(n_states)[:, None]
-        fdata[FV.ORDER] = order
-        fdata[FV.ORDER_SSEL] = ssel
-        fdata[FV.ORDER_INV] = np.zeros_like(order)
-        fdata[FV.ORDER_INV][ssel, order] = np.arange(n_turbines)[None, :]
 
         # apply downwind order to all data:
-        fdata[FV.TXYH] = fdata[FV.TXYH][ssel, order]
+        for data in [fdata, mdata]:
+            for k in data.keys():
+                if (
+                    k not in [FV.X, FV.Y, FV.H]
+                    and tuple(data.dims[k][:2]) == (FC.STATE, FC.TURBINE)
+                    and np.any(data[k] != data[k][0, 0, None, None])
+                ):
+                    data[k][:] = data[k][ssel, order]
+
+        # add derived data:
         for i, v in enumerate([FV.X, FV.Y, FV.H]):
-            fdata[v] = fdata[FV.TXYH][..., i]
-        for v in [FV.D, FV.WD]:
-            if np.any(fdata[v] != fdata[v][0, 0, None, None]):
-                fdata[v] = fdata[v][ssel, order]
-        fdata[FV.YAW] = fdata[FV.WD].copy()
-        for k in mdata.keys():
-            if tuple(mdata.dims[k][:2]) == (FC.STATE, FC.TURBINE) and np.any(
-                mdata[k] != mdata[k][0, 0, None, None]
-            ):
-                mdata[k] = mdata[k][ssel, order]
+            fdata.add(
+                v,
+                fdata[FV.TXYH][:, :, i],
+                (FC.STATE, FC.TURBINE),
+            )
+        fdata.add(
+            FV.YAW,
+            fdata[FV.WD].copy(),
+            (FC.STATE, FC.TURBINE),
+        )
+        fdata.add(
+            FV.ORDER,
+            order,
+            (FC.STATE, FC.TURBINE),
+        )
+        fdata.add(
+            FV.ORDER_SSEL,
+            ssel,
+            (FC.STATE, FC.TURBINE),
+        )
+        fdata.add(
+            FV.ORDER_INV,
+            np.zeros_like(order),
+            (FC.STATE, FC.TURBINE),
+        )
+        fdata[FV.ORDER_INV][ssel, order] = np.arange(n_turbines)[None, :]
 
         return {v: fdata[v] for v in self.output_farm_vars(algo)}

{foxes-1.4 → foxes-1.5}/foxes/algorithms/downwind/models/set_amb_farm_results.py

@@ -65,5 +65,5 @@ class SetAmbFarmResults(FarmDataModel):
 
         """
         for v in self.vars:
-            fdata[FV.var2amb[v]] = fdata[v].copy()
+            fdata.add(FV.var2amb[v], fdata[v].copy(), fdata.dims[v])
         return {v: fdata[v] for v in self.output_farm_vars(algo)}

{foxes-1.4 → foxes-1.5}/foxes/core/algorithm.py

@@ -63,8 +63,8 @@ class Algorithm(Model):
         self.__farm = farm
         self.__mbook = mbook
         self.__dbook = StaticData() if dbook is None else dbook
-        self.__idata_mem = Dict(name="idata_mem")
-        self.__chunk_store = Dict(name="chunk_store")
+        self.__idata_mem = Dict(_name="idata_mem")
+        self.__chunk_store = Dict(_name="chunk_store")
 
         if len(engine_pars):
             if "engine_type" in engine_pars:
@@ -558,7 +558,7 @@ class Algorithm(Model):
                     "n_states": n_states,
                     "n_targets": n_targets,
                 },
-                name=f"chunk_store_{i0}_{t0}",
+                _name=f"chunk_store_{i0}_{t0}",
             )
 
         self.chunk_store[key][name] = data.copy() if copy else data
@@ -638,11 +638,11 @@ class Algorithm(Model):
         """
         chunk_store = self.chunk_store
         if new_chunk_store is None:
-            self.__chunk_store = Dict(name="chunk_store")
+            self.__chunk_store = Dict(_name="chunk_store")
         elif isinstance(new_chunk_store, Dict):
             self.__chunk_store = new_chunk_store
         else:
-            self.__chunk_store = Dict(name="chunk_store")
+            self.__chunk_store = Dict(_name="chunk_store")
             self.__chunk_store.update(new_chunk_store)
         return chunk_store
 

{foxes-1.4 → foxes-1.5}/foxes/core/data.py

@@ -53,7 +53,7 @@ class Data(Dict):
             The data container name
 
         """
-        super().__init__(name=name)
+        super().__init__(_name=name)
 
         self.update(data)
         self.dims = dims
@@ -109,12 +109,12 @@ class Data(Dict):
             or the corresponding index
 
         """
-        if FC.STATE not in self:
-            return None
-        elif counter:
+        if counter:
             if self.__states_i0 is None:
                 raise KeyError(f"Data '{self.name}': states_i0 requested but not set")
             return self.__states_i0
+        elif FC.STATE not in self:
+            return None
         else:
             return self[FC.STATE][0]
 
@@ -394,6 +394,74 @@ class FData(Data):
                         f"FData '{self.name}': Missing '{x}' in sizes, got {sorted(list(self.sizes.keys()))}"
                     )
 
+    @classmethod
+    def from_sizes(cls, n_states, n_turbines, *args, callback=None, **kwargs):
+        """
+        Create Data object from model data
+
+        Parameters
+        ----------
+        n_states: int
+            The number of states
+        n_turbines: int
+            The number of turbines
+        args: tuple, optional
+            Additional parameters for the constructor
+        callback: Function, optional
+            Function f(data, dims) that manipulates
+            the data and dims dicts before construction
+        kwargs: dict, optional
+            Additional parameters for the constructor
+
+        Returns
+        -------
+        data: Data
+            The data object
+
+        """
+        data = cls(*args, **kwargs)
+        data.sizes[FC.STATE] = n_states
+        data.sizes[FC.TURBINE] = n_turbines
+
+        if callback is not None:
+            callback(data, data.dims)
+
+        return data
+
+    @classmethod
+    def from_mdata(cls, mdata, *args, callback=None, **kwargs):
+        """
+        Create Data object from model data
+
+        Parameters
+        ----------
+        mdata: MData
+            The model data
+        args: tuple, optional
+            Additional parameters for the constructor
+        callback: Function, optional
+            Function f(data, dims) that manipulates
+            the data and dims dicts before construction
+        kwargs: dict, optional
+            Additional parameters for the constructor
+
+        Returns
+        -------
+        data: Data
+            The data object
+
+        """
+        data = cls(*args, **kwargs)
+        for v in [FC.STATE, FC.TURBINE]:
+            data[v] = mdata[v]
+            data.dims[v] = mdata.dims[v]
+            data.sizes[v] = mdata.sizes[v]
+
+        if callback is not None:
+            callback(data, data.dims)
+
+        return data
+
     @classmethod
     def from_dataset(cls, ds, *args, mdata=None, callback=None, **kwargs):
         """
@@ -427,6 +495,9 @@ class FData(Data):
                 if FC.STATE not in data:
                     data[FC.STATE] = mdata[FC.STATE]
                     dims[FC.STATE] = mdata.dims[FC.STATE]
+                if FC.TURBINE not in data:
+                    data[FC.TURBINE] = mdata[FC.TURBINE]
+                    dims[FC.TURBINE] = mdata.dims[FC.TURBINE]
                 if callback is not None:
                     callback(data, dims)
 

{foxes-1.4 → foxes-1.5}/foxes/core/data_calc_model.py

@@ -45,8 +45,10 @@ class DataCalcModel(Model):
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        data: tuple of foxes.core.Data
-            The input data
+        data: tuple of foxes.core.Data, optional
+            The input data, typically either (mdata, fdata) in
+            the case of farm calculations, or (mdata, fdata, tdata)
+            for point data calculations
         parameters: dict, optional
             The calculation parameters
 

{foxes-1.4 → foxes-1.5}/foxes/core/engine.py

@@ -6,7 +6,6 @@ from xarray import Dataset
 
 from .data import MData, FData, TData
 from foxes.utils import new_instance
-from foxes.config import config
 import foxes.constants as FC
 
 __global_engine_data__ = dict(
@@ -350,8 +349,9 @@ class Engine(ABC):
 
         Returns
         -------
-        data: list of foxes.core.Data
-            Either [mdata, fdata] or [mdata, fdata, tdata]
+        data: tuple of foxes.core.Data
+            The input data for the chunk calculation,
+            either (mdata, fdata) or (mdata, fdata, tdata)
 
         """
         # prepare:
@@ -370,51 +370,37 @@ class Engine(ABC):
         )
 
         # create fdata:
-        if point_data is None:
-
-            def cb(data, dims):
-                n_states = i1_states - i0_states
-                for o in set(out_vars).difference(data.keys()):
-                    data[o] = np.full(
-                        (n_states, algo.n_turbines), np.nan, dtype=config.dtype_double
-                    )
-                    dims[o] = (FC.STATE, FC.TURBINE)
-
+        if farm_data is not None:
+            fdata = FData.from_dataset(
+                farm_data,
+                mdata=mdata,
+                s_states=s_states,
+                callback=None,
+                states_i0=i0_states,
+                copy=True,
+            )
         else:
-            cb = None
-        fdata = FData.from_dataset(
-            farm_data,
-            mdata=mdata,
-            s_states=s_states,
-            callback=cb,
-            states_i0=i0_states,
-            copy=True,
-        )
+            fdata = FData.from_mdata(
+                mdata=mdata,
+                states_i0=i0_states,
+            )
 
         # create tdata:
-        tdata = None
-        if point_data is not None:
-
-            def cb(data, dims):
-                n_states = i1_states - i0_states
-                n_targets = i1_targets - i0_targets
-                for o in set(out_vars).difference(data.keys()):
-                    data[o] = np.full(
-                        (n_states, n_targets, 1), np.nan, dtype=config.dtype_double
-                    )
-                    dims[o] = (FC.STATE, FC.TARGET, FC.TPOINT)
-
-            tdata = TData.from_dataset(
+        tdata = (
+            TData.from_dataset(
                 point_data,
                 mdata=mdata,
                 s_states=s_states,
                 s_targets=s_targets,
-                callback=cb,
+                callback=None,
                 states_i0=i0_states,
                 copy=True,
             )
+            if point_data is not None
+            else None
+        )
 
-        return [d for d in [mdata, fdata, tdata] if d is not None]
+        return (mdata, fdata) if tdata is None else (mdata, fdata, tdata)
 
     def combine_results(
         self,
@@ -535,7 +521,14 @@ class Engine(ABC):
         )
 
     @abstractmethod
-    def run_calculation(self, algo, model, model_data, farm_data, point_data=None):
+    def run_calculation(
+        self,
+        algo,
+        model,
+        model_data=None,
+        farm_data=None,
+        point_data=None,
+    ):
         """
         Runs the model calculation
 
@@ -543,12 +536,12 @@ class Engine(ABC):
         ----------
         algo: foxes.core.Algorithm
             The algorithm object
-        model: foxes.core.DataCalcModel
+        model: foxes.core.DataCalcModel, optional
             The model that whose calculate function
             should be run
         model_data: xarray.Dataset
             The initial model data
-        farm_data: xarray.Dataset
+        farm_data: xarray.Dataset, optional
             The initial farm data
         point_data: xarray.Dataset, optional
             The initial point data

{foxes-1.4 → foxes-1.5}/foxes/core/farm_data_model.py

@@ -66,28 +66,29 @@ class FarmDataModel(DataCalcModel):
         """
         return (FC.STATE, FC.TURBINE)
 
-    def ensure_variables(self, algo, mdata, fdata):
+    def ensure_output_vars(self, algo, fdata):
         """
-        Add variables to fdata, initialized with NaN
+        Ensures that the output variables are present in the farm data.
 
         Parameters
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
-            The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
 
         """
-        n_states = fdata.n_states
-        n_turbines = fdata.n_turbines
-        for v in self.output_farm_vars(algo):
-            if v not in fdata:
-                fdata[v] = np.full(
-                    (n_states, n_turbines), np.nan, dtype=config.dtype_double
+        for var in self.output_farm_vars(algo):
+            if var not in fdata:
+                fdata.add(
+                    var,
+                    np.full(
+                        (fdata.n_states, fdata.n_turbines),
+                        np.nan,
+                        dtype=config.dtype_double,
+                    ),
+                    (FC.STATE, FC.TURBINE),
                 )
-                fdata.dims[v] = (FC.STATE, FC.TURBINE)
 
     @abstractmethod
     def calculate(self, algo, mdata, fdata):
@@ -264,7 +265,7 @@ class FarmDataModelList(FarmDataModel):
             The model data
         fdata: foxes.core.FData
             The farm data
-        parameters: list of dict, optional
+        parameters: list of dict
             A list of parameter dicts, one for each model
 
         Returns
@@ -274,6 +275,8 @@ class FarmDataModelList(FarmDataModel):
             Values: numpy.ndarray with shape (n_states, n_turbines)
 
         """
+        self.ensure_output_vars(algo, fdata)
+
         if parameters is None:
             parameters = [{}] * len(self.models)
         elif not isinstance(parameters, list):