foxes 1.4__py3-none-any.whl → 1.5__py3-none-any.whl

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"

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,

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()

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/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/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/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/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/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/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/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/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):

foxes/core/model.py

@@ -64,12 +64,30 @@ class Model(ABC):
 
         Returns
         -------
-        str
+        vnm: str
             Model specific variable name
 
         """
         return f"{self.name}_{v}"
 
+    def unvar(self, vnm):
+        """
+        Translates model specific variable name to origninal variable name.
+
+        Parameters
+        ----------
+        vnm: str
+            The vamodel specific variable name
+
+        Returns
+        -------
+        v: str
+            Original variable name
+
+        """
+        lng = len(f"{self.name}_")
+        return vnm[lng:] if vnm.startswith(f"{self.name}_") else None
+
     @property
     def initialized(self):
         """

foxes/core/point_data_model.py

@@ -42,30 +42,33 @@ class PointDataModel(DataCalcModel):
         """
         return (FC.STATE, FC.TARGET, FC.TPOINT)
 
-    def ensure_variables(self, algo, mdata, fdata, tdata):
+    def ensure_output_vars(self, algo, tdata):
         """
-        Add variables to tdata, initialized with NaN
+        Ensures that the output variables are present in the target data.
 
         Parameters
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
-            The model data
-        fdata: foxes.core.Data
-            The farm data
-        tdata: foxes.core.Data
+        tdata: foxes.core.TData
             The target point data
 
         """
-        for v in self.output_point_vars(algo):
-            if v not in tdata:
-                tdata[v] = np.full(
-                    (tdata.n_states, tdata.n_targets, tdata.n_tpoints),
-                    np.nan,
-                    dtype=config.dtype_double,
+        vrs = set(self.output_point_vars(algo))
+        if hasattr(self, "fixed_vars"):
+            vrs.update(self.fixed_vars.keys())
+
+        for var in vrs:
+            if var not in tdata:
+                tdata.add(
+                    var,
+                    np.full(
+                        (tdata.n_states, tdata.n_targets, tdata.n_tpoints),
+                        np.nan,
+                        dtype=config.dtype_double,
+                    ),
+                    (FC.STATE, FC.TARGET, FC.TPOINT),
                 )
-                tdata.dims[v] = (FC.STATE, FC.TARGET, FC.TPOINT)
 
     @abstractmethod
     def calculate(self, algo, mdata, fdata, tdata):
@@ -247,6 +250,8 @@ class PointDataModelList(PointDataModel):
             (n_states, n_targets, n_tpoints)
 
         """
+        self.ensure_output_vars(algo, tdata)
+
         if parameters is None:
             parameters = [{}] * len(self.models)
         elif not isinstance(parameters, list):

foxes/core/rotor_model.py

@@ -362,6 +362,7 @@ class RotorModel(FarmDataModel):
             numpy.ndarray with results, shape: (n_states, n_turbines)
 
         """
+        self.ensure_output_vars(algo, fdata)
 
         if rpoints is None:
             rpoints = mdata.get(

foxes/core/wake_deflection.py

@@ -113,13 +113,13 @@ class WakeDeflection(Model):
         )
 
     @classmethod
-    def new(cls, wframe_type, *args, **kwargs):
+    def new(cls, wdefl_type, *args, **kwargs):
         """
         Run-time wake deflection model factory.
 
         Parameters
         ----------
-        wframe_type: str
+        wdefl_type: str
             The selected derived class name
         args: tuple, optional
             Additional parameters for constructor
@@ -127,4 +127,4 @@ class WakeDeflection(Model):
             Additional parameters for constructor
 
         """
-        return new_instance(cls, wframe_type, *args, **kwargs)
+        return new_instance(cls, wdefl_type, *args, **kwargs)