foxes 1.2.5__tar.gz → 1.3__tar.gz

{foxes-1.2.5/foxes.egg-info → foxes-1.3}/PKG-INFO

@@ -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

{foxes-1.2.5 → foxes-1.3}/README.md

@@ -86,15 +86,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

foxes-1.3/examples/quickstart/run.py

@@ -0,0 +1,17 @@
+import foxes
+
+if __name__ == "__main__":
+
+    states = foxes.input.states.Timeseries(
+        "timeseries_3000.csv.gz", ["WS", "WD", "TI", "RHO"]
+    )
+
+    farm = foxes.WindFarm()
+    foxes.input.farm_layout.add_from_file(
+        farm, "test_farm_67.csv", turbine_models=["NREL5MW"]
+    )
+
+    algo = foxes.algorithms.Downwind(farm, states, ["Jensen_linear_k007"])
+    farm_results = algo.calc_farm()
+
+    print(farm_results)

{foxes-1.2.5 → foxes-1.3}/foxes/__init__.py

@@ -1,6 +1,6 @@
 """
 Farm Optimization and eXtended yield Evaluation Software
-    
+
 """
 
 from .config import config, get_path  # noqa: F401

{foxes-1.2.5 → foxes-1.3}/foxes/algorithms/downwind/downwind.py

@@ -61,8 +61,6 @@ class Downwind(Algorithm):
         FV.TI,
         FV.CT,
         FV.P,
-        FV.ORDER,
-        FV.WEIGHT,
     ]
 
     def __init__(
@@ -447,9 +445,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_rpoints": True, "store_rweights": True, "store_amb_res": True}
-        )
+        calc_pars[-1].update({"store": True})
 
         # 3) run post-rotor turbine models via farm controller:
         mlist.models.append(self.farm_controller)
@@ -475,13 +471,14 @@ class Downwind(Algorithm):
 
     def _calc_farm_vars(self, mlist):
         """Helper function that gathers the farm variables"""
-        self.farm_vars = sorted(list(set([FV.WEIGHT] + mlist.output_farm_vars(self))))
+        self.farm_vars = sorted(list(mlist.output_farm_vars(self)))
 
     def _launch_parallel_farm_calc(
         self,
         mlist,
         *data,
         outputs=None,
+        normalize=False,
         **kwargs,
     ):
         """
@@ -495,6 +492,8 @@ class Downwind(Algorithm):
             The (mdata, fdata) inputs
         outputs: list of str, optional
             The output variables, or None for defaults
+        normalize: bool
+            Normalize the weights to 1 wrt sum over states
         kwargs: dict, optional
             Additional parameters for running
 
@@ -510,6 +509,9 @@ class Downwind(Algorithm):
             self, mlist, *data, out_vars=out_vars, **kwargs
         )
 
+        if normalize:
+            farm_results[FV.WEIGHT] /= farm_results[FV.WEIGHT].sum(dim=FC.STATE)
+
         return farm_results
 
     def calc_farm(
@@ -679,13 +681,7 @@ class Downwind(Algorithm):
         """
         return (
             get_engine()
-            .run_calculation(
-                self,
-                mlist,
-                *data,
-                out_vars=outputs,
-                **kwargs,
-            )
+            .run_calculation(self, mlist, *data, out_vars=outputs, **kwargs)
             .sel({FC.TPOINT: 0})
             .rename({FC.TARGET: FC.POINT})
         )
@@ -812,8 +808,6 @@ class Downwind(Algorithm):
             point_data,
             outputs=ovars,
             parameters=calc_pars,
-            # sel=sel,
-            # isel=isel,
             **kwargs,
         )
         del model_data, farm_results, point_data

{foxes-1.2.5 → foxes-1.3}/foxes/algorithms/downwind/models/farm_wakes_calc.py

@@ -3,6 +3,7 @@ from copy import deepcopy
 
 from foxes.core import FarmDataModel, TData
 import foxes.constants as FC
+import foxes.variables as FV
 
 
 class FarmWakesCalculation(FarmDataModel):
@@ -58,8 +59,9 @@ class FarmWakesCalculation(FarmDataModel):
         """
         # collect ambient rotor results and weights:
         rotor = algo.rotor_model
-        weights = algo.get_from_chunk_store(FC.ROTOR_WEIGHTS, mdata=mdata)
+        rwghts = algo.get_from_chunk_store(FC.ROTOR_WEIGHTS, mdata=mdata)
         amb_res = algo.get_from_chunk_store(FC.AMB_ROTOR_RES, mdata=mdata)
+        weights = algo.get_from_chunk_store(FC.WEIGHT_RES, mdata=mdata)
 
         # generate all wake evaluation points
         # (n_states, n_order, n_rpoints)
@@ -77,20 +79,24 @@ class FarmWakesCalculation(FarmDataModel):
             return tdata, wdelta
 
         def _evaluate(
-            gmodel, tdata, amb_res, weights, wake_res, wdeltas, oi, wmodel, pwake
+            gmodel, tdata, amb_res, rwghts, wake_res, wdeltas, oi, wmodel, pwake
         ):
             """Helper function for data evaluation at turbines"""
             wres = gmodel.finalize_farm_wakes(
-                algo, mdata, fdata, tdata, amb_res, weights, wdeltas, wmodel, oi, pwake
+                algo, mdata, fdata, tdata, amb_res, rwghts, wdeltas, wmodel, oi, pwake
             )
 
-            hres = {v: d[:, oi, None] for v, d in wake_res.items()}
+            hres = {
+                v: d[:, oi, None] if d.shape[1] > 1 else d[:, 0, None]
+                for v, d in wake_res.items()
+            }
             for v, d in wres.items():
                 if v in wake_res:
                     hres[v] += d[:, None]
+            hres[FV.WEIGHT] = weights
 
             rotor.eval_rpoint_results(
-                algo, mdata, fdata, hres, weights, downwind_index=oi
+                algo, mdata, fdata, hres, rwghts, downwind_index=oi
             )
 
             res = algo.farm_controller.calculate(
@@ -119,7 +125,7 @@ class FarmWakesCalculation(FarmDataModel):
                             gmodel,
                             tdatap,
                             amb_res,
-                            weights,
+                            rwghts,
                             wake_res,
                             wdeltas,
                             oi,
@@ -144,7 +150,7 @@ class FarmWakesCalculation(FarmDataModel):
                             gmodel,
                             tdatap,
                             amb_res,
-                            weights,
+                            rwghts,
                             wake_res,
                             wdeltas,
                             oi,

{foxes-1.2.5 → foxes-1.3}/foxes/algorithms/downwind/models/init_farm_data.py

@@ -43,7 +43,6 @@ class InitFarmData(FarmDataModel):
             FV.WD,
             FV.YAW,
             FV.ORDER,
-            FV.WEIGHT,
             FV.ORDER_SSEL,
             FV.ORDER_INV,
         ]
@@ -106,10 +105,11 @@ class InitFarmData(FarmDataModel):
             fdata[FV.D][:, ti] = D
 
         # calc WD and YAW at rotor centres:
-        tdata = TData.from_points(points=fdata[FV.TXYH])
+        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]
-        del tdata, sres
+        del tdata, sres, svrs
 
         # calculate and inverse:
         order = algo.wake_frame.calc_order(algo, mdata, fdata)
@@ -124,7 +124,7 @@ class InitFarmData(FarmDataModel):
         fdata[FV.TXYH] = fdata[FV.TXYH][ssel, order]
         for i, v in enumerate([FV.X, FV.Y, FV.H]):
             fdata[v] = fdata[FV.TXYH][..., i]
-        for v in [FV.D, FV.WD, FV.WEIGHT]:
+        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()

{foxes-1.2.5 → foxes-1.3}/foxes/algorithms/downwind/models/reorder_farm_output.py

@@ -75,7 +75,11 @@ class ReorderFarmOutput(FarmDataModel):
 
         out = {}
         for v in self.output_farm_vars(algo):
-            if v != FV.ORDER and np.any(fdata[v] != fdata[v][0, 0, None, None]):
+            if (
+                v != FV.ORDER
+                and fdata[v].shape[1] > 1
+                and np.any(fdata[v] != fdata[v][0, 0, None, None])
+            ):
                 out[v] = fdata[v][ssel, order_inv]
             else:
                 out[v] = fdata[v]

{foxes-1.2.5 → foxes-1.3}/foxes/algorithms/downwind/models/set_amb_point_results.py

@@ -58,7 +58,7 @@ class SetAmbPointResults(PointDataModel):
             The output variable names
 
         """
-        return [FV.var2amb[v] for v in self.vars]
+        return [FV.var2amb[v] for v in self.vars] + [FV.WEIGHT]
 
     def calculate(self, algo, mdata, fdata, pdata):
         """

{foxes-1.2.5 → foxes-1.3}/foxes/algorithms/iterative/models/farm_wakes_calc.py

@@ -3,6 +3,7 @@ from copy import deepcopy
 
 from foxes.core import FarmDataModel, TData
 import foxes.constants as FC
+import foxes.variables as FV
 
 
 class FarmWakesCalculation(FarmDataModel):
@@ -88,8 +89,9 @@ class FarmWakesCalculation(FarmDataModel):
         """
         # collect ambient rotor results and weights:
         rotor = algo.rotor_model
-        weights = algo.get_from_chunk_store(FC.ROTOR_WEIGHTS, mdata=mdata)
+        rwghts = algo.get_from_chunk_store(FC.ROTOR_WEIGHTS, mdata=mdata)
         amb_res = algo.get_from_chunk_store(FC.AMB_ROTOR_RES, mdata=mdata)
+        weights = algo.get_from_chunk_store(FC.WEIGHT_RES, mdata=mdata)
 
         # generate all wake evaluation points
         # (n_states, n_order, n_rpoints)
@@ -139,7 +141,7 @@ class FarmWakesCalculation(FarmDataModel):
                     fdata,
                     tdatap,
                     amb_res,
-                    weights,
+                    rwghts,
                     wdeltas,
                     wmodel,
                     oi,
@@ -151,7 +153,8 @@ class FarmWakesCalculation(FarmDataModel):
 
             del pwake, tdatap, wdeltas
 
-        rotor.eval_rpoint_results(algo, mdata, fdata, wake_res, weights)
+        wake_res[FV.WEIGHT] = weights
+        rotor.eval_rpoint_results(algo, mdata, fdata, wake_res, rwghts)
         res = algo.farm_controller.calculate(algo, mdata, fdata, pre_rotor=False)
         if self.urelax is not None:
             res = self.urelax.calculate(algo, mdata, fdata, res)

{foxes-1.2.5 → foxes-1.3}/foxes/algorithms/sequential/models/seq_state.py

@@ -30,7 +30,6 @@ class SeqState(States):
 
         # updated by SequentialIter:
         self._size = states.size()
-        self._weight = None
         self._indx = None
         self._counter = None
 
@@ -100,23 +99,6 @@ class SeqState(States):
         """
         return self._counter
 
-    def weights(self, algo):
-        """
-        The statistical weights of all states.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-
-        Returns
-        -------
-        weights: numpy.ndarray
-            The weights, shape: (n_states, n_turbines)
-
-        """
-        return self._weight[None, :] if self._size == 1 else self.states.weights(algo)
-
     def output_point_vars(self, algo):
         """
         The variables which are being modified by the model.

{foxes-1.2.5 → foxes-1.3}/foxes/algorithms/sequential/sequential.py

@@ -139,7 +139,6 @@ class Sequential(Iterative):
             self.print_deco("calc_farm")
 
             self._inds = self.states0.index()
-            self._weights = self.states0.weights(self)
             self._i = 0
             self._counter = 0
 
@@ -158,12 +157,15 @@ class Sequential(Iterative):
                 print(f"\nOutput farm variables:", ", ".join(self.farm_vars))
                 print()
 
+            sts = self._model_data[FC.STATE].to_numpy()
             self._farm_results = Dataset(
-                coords={FC.STATE: self._model_data[FC.STATE].to_numpy()},
+                coords={FC.STATE: sts},
                 data_vars={
                     v: (
                         (FC.STATE, FC.TURBINE),
-                        np.zeros_like(self._model_data[FV.WEIGHT].to_numpy()),
+                        np.zeros(
+                            (len(sts), self.n_turbines), dtype=config.dtype_double
+                        ),
                     )
                     for v in self.farm_vars
                 },
@@ -191,7 +193,6 @@ class Sequential(Iterative):
             self.states._counter = self._i
             self.states._size = 1
             self.states._indx = self._inds[self._i]
-            self.states._weight = self._weights[self._i]
 
             if self._verbo0 > 0:
                 print(f"{self.name}: Running state {self.states.index()[0]}")
@@ -257,7 +258,6 @@ class Sequential(Iterative):
             self.states._counter = None
             self.states._size = len(self._inds)
             self.states._indx = self._inds
-            self.states._weight = self._weights
 
             for p in self.plugins:
                 p.finalize(self)
@@ -323,19 +323,6 @@ class Sequential(Iterative):
         """
         return self.counter if counter else self.index
 
-    @property
-    def weight(self):
-        """
-        The current weight array
-
-        Returns
-        -------
-        w: numpy.ndarray
-            The current weight array, shape: (n_turbines,)
-
-        """
-        return self.states._weight if self.iterating else None
-
     @property
     def farm_results(self):
         """

{foxes-1.2.5 → foxes-1.3}/foxes/constants.py

@@ -73,11 +73,17 @@ ROTOR_WEIGHTS = "rotor_weights"
 """ Identifier for rotor point weights
 :group: foxes.constants
 """
+
 AMB_ROTOR_RES = "amb_rotor_res"
 """ Identifier for ambient rotor point results
 :group: foxes.constants
 """
 
+WEIGHT_RES = "weight_res"
+""" Identifier for weights results at rotor points
+:group: foxes.constants
+"""
+
 
 VARS = "vars"
 """ Variables identifier

{foxes-1.2.5 → foxes-1.3}/foxes/core/data.py

@@ -156,10 +156,11 @@ class Data(Dict):
                 for li, l in enumerate(self.loop_dims):
                     if data.shape[li] == 1 and (len(dims) < li + 1 or dims[li] != l):
                         self[name] = np.squeeze(data, axis=li)
-
             for ci, c in enumerate(dims):
-                if c not in self.sizes:
+                if c not in self.sizes or self.sizes[c] == 1:
                     self.sizes[c] = self[name].shape[ci]
+                elif self[name].shape[ci] == 1:
+                    pass
                 elif self.sizes[c] != self[name].shape[ci]:
                     raise ValueError(
                         f"Inconsistent size for data entry '{name}', dimension '{c}': Expecting {self.sizes[c]}, found {self[name].shape[ci]} in shape {self[name].shape}"
@@ -288,12 +289,16 @@ class Data(Dict):
                     raise ValueError(
                         f"Expecting coordinate '{FC.STATE}' at position 0 for data variable '{v}', got {d.dims}"
                     )
-                n_states = len(d.to_numpy())
+                n_states = d.shape[0]
                 s = np.s_[:] if s_states is None else s_states
                 data[v] = d.to_numpy()[s].copy() if copy else d.to_numpy()[s]
+                dims[v] = d.dims
+                if v == FV.WEIGHT and d.dims == (FC.STATE,):
+                    data[v] = data[v][:, None]
+                    dims[v] = (FC.STATE, FC.TURBINE)
             else:
                 data[v] = d.to_numpy().copy() if copy else d.to_numpy()
-            dims[v] = d.dims
+                dims[v] = d.dims
 
         if callback is not None:
             callback(data, dims)
@@ -362,8 +367,7 @@ class FData(Data):
         super()._run_entry_checks(name, data, dims)
         data = self[name]
         dims = self.dims[name]
-
-        if name not in self.sizes and name not in FC.TNAME:
+        if name not in self.sizes and name not in [FC.TNAME, FV.WEIGHT]:
             dms = (FC.STATE, FC.TURBINE)
             shp = (self.n_states, self.n_turbines)
             if len(data.shape) < 2:
@@ -418,8 +422,6 @@ class FData(Data):
                 if FC.STATE not in data:
                     data[FC.STATE] = mdata[FC.STATE]
                     dims[FC.STATE] = mdata.dims[FC.STATE]
-                    data[FV.WEIGHT] = mdata[FV.WEIGHT]
-                    dims[FV.WEIGHT] = mdata.dims[FV.WEIGHT]
                 if callback is not None:
                     callback(data, dims)
 
@@ -587,8 +589,9 @@ class TData(Data):
     def from_points(
         cls,
         points,
-        data={},
-        dims={},
+        data=None,
+        dims=None,
+        variables=None,
         name="tdata",
         **kwargs,
     ):
@@ -599,11 +602,14 @@ class TData(Data):
         ----------
         points: np.ndarray
             The points, shape: (n_states, n_points, 3)
-        data: dict
+        data: dict, optional
             The initial data to be stored
-        dims: dict
+        dims: dict, optional
             The dimensions tuples, same or subset
             of data keys
+        variables: list of str
+            Add default empty variables with NaN values
+            and shape (n_states, n_targets, n_tpoints)
         name: str
             The data container name
         kwargs: dict, optional
@@ -619,19 +625,28 @@ class TData(Data):
             raise ValueError(
                 f"Expecting points shape (n_states, n_points, 3), got {points.shape}"
             )
+        data = {} if data is None else data
+        dims = {} if dims is None else dims
         data[FC.TARGETS] = points[:, :, None, :]
         dims[FC.TARGETS] = (FC.STATE, FC.TARGET, FC.TPOINT, FC.XYH)
         data[FC.TWEIGHTS] = np.array([1], dtype=config.dtype_double)
         dims[FC.TWEIGHTS] = (FC.TPOINT,)
-        return cls(data, dims, [FC.STATE, FC.TARGET], name=name, **kwargs)
+        if variables is not None:
+            for v in variables:
+                data[v] = np.full_like(points[:, :, None, 0], np.nan)
+                dims[v] = (FC.STATE, FC.TARGET, FC.TPOINT)
+        return cls(
+            data=data, dims=dims, loop_dims=[FC.STATE, FC.TARGET], name=name, **kwargs
+        )
 
     @classmethod
     def from_tpoints(
         cls,
         tpoints,
         tweights,
-        data={},
-        dims={},
+        data=None,
+        dims=None,
+        variables=None,
         name="tdata",
         **kwargs,
     ):
@@ -646,11 +661,14 @@ class TData(Data):
         tweights: np.ndarray, optional
             The target point weights, shape:
             (n_tpoints,)
-        data: dict
+        data: dict, optional
             The initial data to be stored
-        dims: dict
+        dims: dict, optional
             The dimensions tuples, same or subset
             of data keys
+        variables: list of str
+            Add default empty variables with NaN values
+            and shape (n_states, n_targets, n_tpoints)
         name: str
             The data container name
         kwargs: dict, optional
@@ -666,11 +684,19 @@ class TData(Data):
             raise ValueError(
                 f"Expecting tpoints shape (n_states, n_targets, n_tpoints, 3), got {tpoints.shape}"
             )
+        data = {} if data is None else data
+        dims = {} if dims is None else dims
         data[FC.TARGETS] = tpoints
         dims[FC.TARGETS] = (FC.STATE, FC.TARGET, FC.TPOINT, FC.XYH)
         data[FC.TWEIGHTS] = tweights
         dims[FC.TWEIGHTS] = (FC.TPOINT,)
-        return cls(data, dims, [FC.STATE], name=name, **kwargs)
+        if variables is not None:
+            for v in variables:
+                data[v] = np.full_like(tpoints[..., 0], np.nan)
+                dims[v] = (FC.STATE, FC.TARGET, FC.TPOINT)
+        return cls(
+            data=data, dims=dims, loop_dims=[FC.STATE, FC.TARGET], name=name, **kwargs
+        )
 
     @classmethod
     def from_dataset(

{foxes-1.2.5 → foxes-1.3}/foxes/core/engine.py

@@ -515,9 +515,27 @@ class Engine(ABC):
         if FC.STATE in out_coords and FC.STATE in model_data.coords:
             coords[FC.STATE] = model_data[FC.STATE].to_numpy()
 
+        # reducing weights dimensions:
+        dvars = {}
+        for v, (dims, d) in data_vars.items():
+            if (
+                dims == (FC.STATE, FC.TURBINE)
+                and d.shape[1] == 1
+                and algo.n_turbines > 1
+            ):
+                dvars[v] = ((FC.STATE,), d[:, 0])
+            elif (
+                dims == (FC.STATE, FC.TARGET, FC.TPOINT)
+                and goal_data.sizes[FC.TARGET] > n_chunks_targets
+                and d.shape[1:] == (n_chunks_targets, 1)
+            ):
+                dvars[v] = ((FC.STATE,), d[:, 0, 0])
+            else:
+                dvars[v] = (dims, d)
+
         return Dataset(
             coords=coords,
-            data_vars={v: tuple(d) for v, d in data_vars.items()},
+            data_vars=dvars,
         )
 
     @abstractmethod

{foxes-1.2.5 → foxes-1.3}/foxes/core/farm_data_model.py

@@ -246,6 +246,7 @@ class FarmDataModelList(FarmDataModel):
         ovars = []
         for m in self.models:
             ovars += m.output_farm_vars(algo)
+
         return list(dict.fromkeys(ovars))
 
     def calculate(self, algo, mdata, fdata, parameters=[]):