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

foxes/output/farm_results_eval.py

@@ -4,6 +4,7 @@ from cycler import cycler
 import matplotlib.pyplot as plt
 
 from .output import Output
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -63,7 +64,12 @@ class FarmResultsEval(Output):
         fields = []
         for v in vars:
             if isinstance(v, str):
-                fields.append(self.results[v].to_numpy())
+                vdata = self.results[v].to_numpy()
+                nns = np.sum(np.isnan(vdata))
+                assert (
+                    nns == 0
+                ), f"Found {nns} nan values for variable '{v}' of shape {vdata.shape}"
+                fields.append(vdata)
             else:
                 fields.append(v)
             if nas is None:
@@ -98,7 +104,7 @@ class FarmResultsEval(Output):
         vars_op: dict
             The operation per variable. Key: str, the variable
             name. Value: str, the operation, choices
-            are: sum, mean, min, max.
+            are: weights, mean_no_weights, sum, min, max.
 
         Returns
         -------
@@ -110,23 +116,27 @@ class FarmResultsEval(Output):
 
         rdata = {}
         for v, op in vars_op.items():
-            if op == "mean":
-                rdata[v] = self.weinsum("t", v)
+            vdata = self.results[v].to_numpy()
+            nns = np.sum(np.isnan(vdata))
+            assert (
+                nns == 0
+            ), f"Found {nns} nan values for variable '{v}' of shape {vdata.shape}"
+
+            if op == "weights":
+                rdata[v] = self.weinsum("t", vdata)
+            elif op == "mean_no_weights":
+                rdata[v] = np.mean(vdata, axis=0)
             elif op == "sum":
-                vdata = self.results[v].to_numpy()
                 rdata[v] = np.sum(vdata, axis=0)
             elif op == "min":
-                vdata = self.results[v].to_numpy()
                 rdata[v] = np.min(vdata, axis=0)
             elif op == "max":
-                vdata = self.results[v].to_numpy()
                 rdata[v] = np.max(vdata, axis=0)
             elif op == "std":
-                vdata = self.results[v].to_numpy()
                 rdata[v] = np.std(vdata, axis=0)
             else:
                 raise KeyError(
-                    f"Unknown operation '{op}' for variable '{v}'. Please choose: sum, mean, min, max"
+                    f"Unknown operation '{op}' for variable '{v}'. Please choose: weights, mean_no_weights, sum, min, max"
                 )
 
         data = pd.DataFrame(index=range(n_turbines), data=rdata)
@@ -143,7 +153,7 @@ class FarmResultsEval(Output):
         vars_op: dict
             The operation per variable. Key: str, the variable
             name. Value: str, the operation, choices
-            are: sum, mean, min, max.
+            are: weights, mean_no_weights, sum, min, max.
 
         Returns
         -------
@@ -155,20 +165,25 @@ class FarmResultsEval(Output):
 
         rdata = {}
         for v, op in vars_op.items():
-            if op == "mean":
-                rdata[v] = self.weinsum("s", v)
+            vdata = self.results[v].to_numpy()
+            nns = np.sum(np.isnan(vdata))
+            assert (
+                nns == 0
+            ), f"Found {nns} nan values for variable '{v}' of shape {vdata.shape}"
+
+            if op == "weights":
+                rdata[v] = self.weinsum("s", vdata)
+            elif op == "mean_no_weights":
+                rdata[v] = np.mean(vdata, axis=1)
             elif op == "sum":
-                vdata = self.results[v].to_numpy()
                 rdata[v] = np.sum(vdata, axis=1)
             elif op == "min":
-                vdata = self.results[v].to_numpy()
                 rdata[v] = np.min(vdata, axis=1)
             elif op == "max":
-                vdata = self.results[v].to_numpy()
                 rdata[v] = np.max(vdata, axis=1)
             else:
                 raise KeyError(
-                    f"Unknown operation '{op}' for variable '{v}'. Please choose: sum, mean, min, max"
+                    f"Unknown operation '{op}' for variable '{v}'. Please choose: weights, mean_no_weights, sum, min, max"
                 )
 
         data = pd.DataFrame(index=states, data=rdata)
@@ -204,29 +219,32 @@ class FarmResultsEval(Output):
         rdata = {}
         for v, op in turbines_op.items():
             vdata = sdata[v].to_numpy()
-            if op == "mean":
-                if states_op[v] == "mean":
+            nns = np.sum(np.isnan(vdata))
+            assert (
+                nns == 0
+            ), f"Found {nns} nan values for variable '{v}' of shape {vdata.shape}"
+
+            if op == "weights":
+                if states_op[v] == "weights":
                     rdata[v] = self.weinsum("", v)
                 else:
-                    vdata = sdata[v].to_numpy()
                     rdata[v] = self.weinsum("", vdata[None, :])
+            elif op == "mean_no_weights":
+                rdata[v] = np.sum(vdata)
             elif op == "sum":
-                vdata = sdata[v].to_numpy()
                 rdata[v] = np.sum(vdata)
             elif op == "min":
-                vdata = sdata[v].to_numpy()
                 rdata[v] = np.min(vdata)
             elif op == "max":
-                vdata = sdata[v].to_numpy()
                 rdata[v] = np.max(vdata)
             else:
                 raise KeyError(
-                    f"Unknown operation '{op}' for variable '{v}'. Please choose: sum, mean, min, max"
+                    f"Unknown operation '{op}' for variable '{v}'. Please choose: sum, mean, min, max, weights"
                 )
 
         return rdata
 
-    def calc_states_mean(self, vars):
+    def calc_states_mean(self, vars, use_weights=True):
         """
         Calculates the mean wrt states.
 
@@ -234,6 +252,8 @@ class FarmResultsEval(Output):
         ----------
         vars: list of str
             The variables
+        use_weights: bool
+            Flag for using states weights for the mean
 
         Returns
         -------
@@ -241,9 +261,10 @@ class FarmResultsEval(Output):
             The results per turbine
 
         """
+        r = "weights" if use_weights else "mean_no_weights"
         if isinstance(vars, str):
-            return self.reduce_states({vars: "mean"})
-        return self.reduce_states({v: "mean" for v in vars})
+            return self.reduce_states({vars: r})
+        return self.reduce_states({v: r for v in vars})
 
     def calc_states_sum(self, vars):
         """
@@ -290,7 +311,7 @@ class FarmResultsEval(Output):
             The results per state
 
         """
-        return self.reduce_turbines({v: "mean" for v in vars})
+        return self.reduce_turbines({v: "mean_no_weights" for v in vars})
 
     def calc_turbine_sum(self, vars):
         """
@@ -324,7 +345,7 @@ class FarmResultsEval(Output):
             The fully contracted results
 
         """
-        op = {v: "mean" for v in vars}
+        op = {v: "weights" for v in vars}
         return self.reduce_all(states_op=op, turbines_op=op)
 
     def calc_farm_sum(self, vars):
@@ -361,7 +382,7 @@ class FarmResultsEval(Output):
 
         """
         v = FV.P if not ambient else FV.AMB_P
-        cdata = self.reduce_all(states_op={v: "mean"}, turbines_op={v: "sum"})
+        cdata = self.reduce_all(states_op={v: "weights"}, turbines_op={v: "sum"})
         return cdata[v]
 
     def calc_turbine_yield(
@@ -409,7 +430,7 @@ class FarmResultsEval(Output):
         if algo is not None and P_unit_W is None:
             P_unit_W = np.array(
                 [FC.P_UNITS[t.P_unit] for t in algo.farm_controller.turbine_types],
-                dtype=FC.DTYPE,
+                dtype=config.dtype_double,
             )[:, None]
         elif algo is None and P_unit_W is not None:
             pass
@@ -472,10 +493,10 @@ class FarmResultsEval(Output):
         if algo is not None and P_nom is None:
             P_nom = np.array(
                 [t.P_nominal for t in algo.farm_controller.turbine_types],
-                dtype=FC.DTYPE,
+                dtype=config.dtype_double,
             )
         elif algo is None and P_nom is not None:
-            P_nom = np.array(P_nom, dtype=FC.DTYPE)
+            P_nom = np.array(P_nom, dtype=config.dtype_double)
         else:
             raise KeyError("Expecting either 'algo' or 'P_nom'")
 
@@ -535,10 +556,12 @@ class FarmResultsEval(Output):
             The verbosity level, 0 = silent
 
         """
-        P = self.results[FV.P]
-        P0 = self.results[FV.AMB_P] + 1e-14
-        self.results[FV.EFF] = P / P0  # add to farm results
-        if verbosity:
+        P = self.results[FV.P].to_numpy()
+        P0 = np.maximum(self.results[FV.AMB_P].to_numpy(), 1e-12)
+        eff = np.minimum(P / P0, 1)
+        eff[P < 1e-10] = 0
+        self.results[FV.EFF] = (self.results[FV.AMB_P].dims, eff)
+        if verbosity > 0:
             print("Efficiency added to farm results")
 
     def calc_farm_efficiency(self):
@@ -552,8 +575,8 @@ class FarmResultsEval(Output):
 
         """
         P = self.calc_mean_farm_power()
-        P0 = self.calc_mean_farm_power(ambient=True) + 1e-14
-        return P / P0
+        P0 = np.maximum(self.calc_mean_farm_power(ambient=True), 1e-14)
+        return np.minimum(P / P0, 1)
 
     def gen_stdata(
         self,

foxes/output/grids.py

@@ -3,6 +3,7 @@ import pandas as pd
 from xarray import Dataset
 
 from foxes.utils import wd2uv, write_nc
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -151,7 +152,7 @@ def get_grid_xy(
     N_x, N_y = len(x_pos), len(y_pos)
     n_pts = len(x_pos) * len(y_pos)
     z_pos = 0.5 * (z_min + z_max)
-    g_pts = np.zeros((n_states, N_x, N_y, 3), dtype=FC.DTYPE)
+    g_pts = np.zeros((n_states, N_x, N_y, 3), dtype=config.dtype_double)
     g_pts[:, :, :, 0] = x_pos[None, :, None]
     g_pts[:, :, :, 1] = y_pos[None, None, :]
     g_pts[:, :, :, 2] = z_pos
@@ -248,7 +249,7 @@ def get_grid_xz(
     n_y = np.cross(n_z, n_x)
 
     # project to axes:
-    xyz = np.zeros((n_states, n_turbines, 3), dtype=FC.DTYPE)
+    xyz = np.zeros((n_states, n_turbines, 3), dtype=config.dtype_double)
     xyz[:, :, 0] = farm_results[FV.X]
     xyz[:, :, 1] = farm_results[FV.Y]
     xyz[:, :, 2] = farm_results[FV.H]
@@ -297,7 +298,7 @@ def get_grid_xz(
     N_x, N_z = len(x_pos), len(z_pos)
     n_pts = len(x_pos) * len(z_pos)
     y_pos = 0.5 * (y_min + y_max)
-    g_pts = np.zeros((n_states, N_x, N_z, 3), dtype=FC.DTYPE)
+    g_pts = np.zeros((n_states, N_x, N_z, 3), dtype=config.dtype_double)
     g_pts[:] += x_pos[None, :, None, None] * n_x[None, None, None, :]
     g_pts[:] += y_pos * n_y[None, None, None, :]
     g_pts[:] += z_pos[None, None, :, None] * n_z[None, None, None, :]
@@ -394,7 +395,7 @@ def get_grid_yz(
     n_y = np.cross(n_z, n_x)
 
     # project to axes:
-    xyz = np.zeros((n_states, n_turbines, 3), dtype=FC.DTYPE)
+    xyz = np.zeros((n_states, n_turbines, 3), dtype=config.dtype_double)
     xyz[:, :, 0] = farm_results[FV.X]
     xyz[:, :, 1] = farm_results[FV.Y]
     xyz[:, :, 2] = farm_results[FV.H]
@@ -443,7 +444,7 @@ def get_grid_yz(
     N_y, N_z = len(y_pos), len(z_pos)
     n_pts = len(y_pos) * len(z_pos)
     x_pos = 0.5 * (x_min + x_max)
-    g_pts = np.zeros((n_states, N_y, N_z, 3), dtype=FC.DTYPE)
+    g_pts = np.zeros((n_states, N_y, N_z, 3), dtype=config.dtype_double)
     g_pts[:] += x_pos * n_x[None, None, None, :]
     g_pts[:] += y_pos[None, :, None, None] * n_y[None, None, None, :]
     g_pts[:] += z_pos[None, None, :, None] * n_z[None, None, None, :]
@@ -491,7 +492,7 @@ def np2np_p(data, a_pos, b_pos):
     n_a = len(a_pos)
     n_b = len(b_pos)
     n_v = len(data)
-    out = np.zeros((n_a, n_b, n_v), dtype=FC.DTYPE)
+    out = np.zeros((n_a, n_b, n_v), dtype=config.dtype_double)
     for vi, (v, d) in enumerate(data.items()):
         out[:, :, vi] = d.reshape(n_a, n_b)
     return out
@@ -526,7 +527,7 @@ def np2np_sp(data, states, a_pos, b_pos):
     n_a = len(a_pos)
     n_b = len(b_pos)
     n_v = len(data)
-    out = np.zeros((n_s, n_a, n_b, n_v), dtype=FC.DTYPE)
+    out = np.zeros((n_s, n_a, n_b, n_v), dtype=config.dtype_double)
     for vi, (v, d) in enumerate(data.items()):
         out[:, :, :, vi] = d.reshape(n_s, n_a, n_b)
     return out

foxes/output/output.py

@@ -1,6 +1,7 @@
 from pathlib import Path
 
-from foxes.utils import PandasFileHelper, all_subclasses
+from foxes.config import config, get_path
+from foxes.utils import PandasFileHelper, new_instance, all_subclasses
 
 
 class Output:
@@ -33,9 +34,13 @@ class Output:
             Modifies file names by f(fname)
 
         """
-        self.out_dir = Path(out_dir) if out_dir is not None else None
+        self.out_dir = get_path(out_dir) if out_dir is not None else config.out_dir
         self.out_fname_fun = out_fname_fun
 
+        if not self.out_dir.is_dir():
+            print(f"{type(self).__name__}: Creating output dir {self.out_dir}")
+            self.out_dir.mkdir(parents=True)
+
     def get_fpath(self, fname):
         """
         Gets the total file path
@@ -54,7 +59,7 @@ class Output:
         fnm = Path(fname)
         if self.out_fname_fun is not None:
             fnm = self.out_fname_fun(fnm)
-        return self.out_dir / fnm if self.out_dir is not None else fnm
+        return self.out_dir / fnm if self.out_dir is not None else get_path(fnm)
 
     def write(self, file_name, data, format_col2var={}, format_dict={}, **kwargs):
         """
@@ -111,20 +116,4 @@ class Output:
             Additional parameters for the constructor
 
         """
-
-        if output_type is None:
-            return None
-
-        allc = all_subclasses(cls)
-        found = output_type in [scls.__name__ for scls in allc]
-
-        if found:
-            for scls in allc:
-                if scls.__name__ == output_type:
-                    return scls(*args, **kwargs)
-
-        else:
-            estr = "Output type '{}' is not defined, available types are \n {}".format(
-                output_type, sorted([i.__name__ for i in allc])
-            )
-            raise KeyError(estr)
+        return new_instance(cls, output_type, *args, **kwargs)

foxes/output/plt.py

@@ -0,0 +1,19 @@
+from matplotlib import pyplot
+
+from .output import Output
+
+
+class plt(Output):
+    """
+    Class that runs plt commands
+
+    :group: output
+
+    """
+
+    def __getattr__(self, name):
+        return getattr(pyplot, name)
+
+    def savefig(self, fname, *args, **kwargs):
+        fpath = super().get_fpath(fname)
+        pyplot.savefig(fpath, *args, **kwargs)

foxes/output/results_writer.py

@@ -1,8 +1,8 @@
 import pandas as pd
 from xarray import Dataset
 
-import foxes.constants as FC
 from foxes.utils import write_nc
+import foxes.constants as FC
 
 from .output import Output
 
@@ -70,7 +70,7 @@ class ResultsWriter(Output):
 
     def write_csv(
         self,
-        file_path,
+        file_name,
         variables=None,
         turbine_names=False,
         state_turbine_table=False,
@@ -82,8 +82,8 @@ class ResultsWriter(Output):
 
         Parameters
         ----------
-        file_path: str
-            Path for the csv file
+        file_name: str
+            Name of the csv file
         variables: dict or list of str, optional
             The variables to be written. If a dict, then
             the keys are the foxes variables and the values
@@ -101,7 +101,7 @@ class ResultsWriter(Output):
 
         """
         if verbosity:
-            print(f"ResultsWriter: Writing file '{file_path}'")
+            print(f"ResultsWriter: Writing file '{file_name}'")
 
         data, variables = self._get_data_vars(variables)
         data.reset_index(inplace=True)
@@ -133,12 +133,11 @@ class ResultsWriter(Output):
         else:
             data.set_index([FC.STATE, tix], inplace=True)
 
-        fpath = self.get_fpath(file_path)
-        super().write(fpath, data, format_col2var=fc2v, **kwargs)
+        super().write(file_name, data, format_col2var=fc2v, **kwargs)
 
     def write_nc(
         self,
-        file_path,
+        file_name,
         variables=None,
         turbine_names=False,
         verbosity=1,
@@ -149,8 +148,8 @@ class ResultsWriter(Output):
 
         Parameters
         ----------
-        file_path: str
-            Path for the nc file
+        file_name: str
+            The nc file name
         variables: dict or list of str, optional
             The variables to be written. If a dict, then
             the keys are the foxes variables and the values
@@ -185,5 +184,5 @@ class ResultsWriter(Output):
             },
         )
 
-        fpath = self.get_fpath(file_path)
+        fpath = self.get_fpath(file_name)
         write_nc(ds, fpath, verbosity=verbosity, **kwargs)