foxes 0.5.0.2__py3-none-any.whl → 0.5.2__py3-none-any.whl

foxes/output/output.py

@@ -1,5 +1,6 @@
-from foxes.utils import PandasFileHelper, all_subclasses
+from pathlib import Path
 
+from foxes.utils import PandasFileHelper, all_subclasses
 
 class Output:
     """
@@ -8,12 +9,53 @@ class Output:
     The job of this class is to provide handy
     helper functions.
 
+    Attributes
+    ----------
+    out_dir: pathlib.Path
+        The output file directory
+    out_fname_fun: Function, optional
+        Modifies file names by f(fname)
+
     :group: output
 
     """
 
-    @classmethod
-    def write(cls, file_path, data, format_col2var={}, format_dict={}, **kwargs):
+    def __init__(self, out_dir=None, out_fname_fun=None):
+        """
+        Constructor.
+        
+        Parameters
+        ----------
+        out_dir: str, optional
+            The output file directory
+        out_fname_fun: Function, optional
+            Modifies file names by f(fname)
+
+        """
+        self.out_dir = Path(out_dir) if out_dir is not None else None
+        self.out_fname_fun = out_fname_fun
+    
+    def get_fpath(self, fname):
+        """
+        Gets the total file path
+        
+        Parameters
+        ----------
+        fname: str
+            The file name
+        
+        Returns
+        -------
+        fpath: pathlib.Path
+            The total file path
+        
+        """
+        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
+
+    def write(self, file_name, data, format_col2var={}, format_dict={}, **kwargs):
         """
         Writes data to file via pandas.
 
@@ -21,16 +63,16 @@ class Output:
 
         Parameters
         ----------
-        file_path: string
-            The path to the output file
+        file_name: str
+            The output file name
         data: pandas.DataFrame
             The data
         format_col2var: dict
-            Mapping from column names to flappy variables,
+            Mapping from column names to foxes variables,
             for formatting
         format_dict: dict
             Dictionary with format entries for columns, e.g.
-            {FV.P: '{:.4f}'}. Note that the keys are flappy variables
+            {FV.P: '{:.4f}'}. Note that the keys are foxes variables
 
         """
         fdict = {}
@@ -41,8 +83,9 @@ class Output:
             elif v in PandasFileHelper.DEFAULT_FORMAT_DICT:
                 fdict[c] = PandasFileHelper.DEFAULT_FORMAT_DICT[v]
 
-        PandasFileHelper.write_file(data, file_path, fdict, **kwargs)
-
+        fpath = self.get_fpath(file_name)
+        PandasFileHelper.write_file(data, fpath, fdict, **kwargs)
+    
     @classmethod
     def print_models(cls):
         """
@@ -53,7 +96,7 @@ class Output:
             print(n)
 
     @classmethod
-    def new(cls, model_type, **kwargs):
+    def new(cls, model_type, *args, **kwargs):
         """
         Run-time output model factory.
 
@@ -61,6 +104,10 @@ class Output:
         ----------
         model_type: string
             The selected derived class name
+        args: tuple, optional
+            Additional parameters for the constructor
+        kwargs: dict, optional
+            Additional parameters for the constructor
 
         """
 
@@ -73,7 +120,7 @@ class Output:
         if found:
             for scls in allc:
                 if scls.__name__ == model_type:
-                    return scls(**kwargs)
+                    return scls(*args, **kwargs)
 
         else:
             estr = "Output type '{}' is not defined, available types are \n {}".format(

foxes/output/results_writer.py

@@ -1,6 +1,10 @@
-from .output import Output
+import pandas as pd
+from xarray import Dataset
+
 import foxes.constants as FC
+from foxes.utils import write_nc
 
+from .output import Output
 
 class ResultsWriter(Output):
     """
@@ -15,7 +19,7 @@ class ResultsWriter(Output):
 
     """
 
-    def __init__(self, farm_results=None, data=None):
+    def __init__(self, farm_results=None, data=None, **kwargs):
         """
         Constructor.
 
@@ -25,8 +29,12 @@ class ResultsWriter(Output):
             The farm results, if data is None
         data: pandas.DataFrame, optional
             The data, if farm_results is None
+        kwargs: dict, optional
+            Additional parameters for the base class
 
         """
+        super().__init__(**kwargs)
+
         if farm_results is not None and data is None:
             self.data = farm_results.to_dataframe().reset_index()
             self.data[FC.TNAME] = farm_results[FC.TNAME].to_numpy()[
@@ -39,12 +47,32 @@ class ResultsWriter(Output):
             raise KeyError(
                 f"ResultsWriter: Either give 'farm_results' or 'data' arguments"
             )
+    
+    def _get_data_vars(self, variables):
+        """ Helper function for variable gathering """
+        data = self.data
+        if variables is None:
+            pass
+        elif isinstance(variables, dict):
+            inds = {
+                s: variables.pop(s) for s in self.data.index.names if s in variables
+            }
+            if len(variables):
+                data = data[list(variables.keys())].rename(variables, axis=1)
+            if len(inds):
+                for s, ns in inds.items():
+                    data = data.rename_axis(index={s: ns})
+        else:
+            data = self.data[list(variables)]
+        
+        return data, data.columns.tolist()
 
     def write_csv(
         self,
         file_path,
         variables=None,
         turbine_names=False,
+        state_turbine_table=False,
         verbosity=1,
         **kwargs,
     ):
@@ -62,6 +90,9 @@ class ResultsWriter(Output):
             written.
         turbine_names: bool
             Use turbine names instead of turbine indices
+        state_turbine_table: bool
+            Flag for writing a single variable into turbine columns
+            for state rows
         verbosity: int
             The verbosity level, 0 = silent
         kwargs: dict, optional
@@ -71,22 +102,75 @@ class ResultsWriter(Output):
         if verbosity:
             print(f"ResultsWriter: Writing file '{file_path}'")
 
-        if variables is None:
-            data = self.data
-        elif isinstance(variables, dict):
-            inds = {
-                s: variables.pop(s) for s in self.data.index.names if s in variables
-            }
-            data = self.data
-            if len(variables):
-                data = data[list(variables.keys())].rename(variables, axis=1)
-            if len(inds):
-                for s, ns in inds.items():
-                    data = data.rename_axis(index={s: ns})
+        data, variables = self._get_data_vars(variables)
+        data.reset_index(inplace=True)
+        fc2v = kwargs.pop("format_col2var", {})
+        tix = FC.TNAME if turbine_names else FC.TURBINE
+
+        if state_turbine_table:
+            if len(variables) != 1:
+                raise ValueError(f"state_turbine_table can only be written for a single variable, got {variables}")
+            v = variables[0]
+            cnames = {t: f"{v}_T{t:04d}" if tix == FC.TURBINE else f"{v}_{t}" for t in data[tix]}
+            for ti, (t, g) in enumerate(data.reset_index().set_index(FC.STATE).groupby(tix)):
+                if ti == 0:
+                    odata = pd.DataFrame(index=g.index.to_numpy(), columns=list(cnames.values()))
+                    odata.index.name = g.index.name
+                cname = cnames[t]
+                odata[cname] = g[v].to_numpy().copy()
+                fc2v[cname] = v
+            data = odata
         else:
-            data = self.data[list(variables)]
+            data.set_index([FC.STATE, tix], inplace=True)
 
+        fpath = self.get_fpath(file_path)
+        super().write(fpath, data, format_col2var=fc2v, **kwargs)
+
+    def write_nc(
+        self,
+        file_path,
+        variables=None,
+        turbine_names=False,
+        verbosity=1,
+        **kwargs,
+    ):
+        """
+        Writes a netCDF file
+
+        Parameters
+        ----------
+        file_path: str
+            Path the 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
+            the column names. If None, then all data will be
+            written.
+        turbine_names: bool
+            Use turbine names instead of turbine indices
+        verbosity: int
+            The verbosity level, 0 = silent
+        kwargs: dict, optional
+            Additional parameters for write_nc()
+
+        """
+        data, variables = self._get_data_vars(variables)
+        states = data.index.get_level_values(0).unique()
+        n_states = len(states)
+        n_turbines = len(data.index.get_level_values(1).unique())
+
+        crds = {FC.STATE: states}
         if turbine_names:
-            data = data.reset_index().set_index([FC.STATE, FC.TNAME])
+            idx = pd.IndexSlice
+            crds[FC.TURBINE] = self.data.loc[idx[0, :], FC.TNAME].to_numpy()
+        
+        ds = Dataset(
+            coords=crds,
+            data_vars={
+                v: ((FC.STATE, FC.TURBINE), data[v].to_numpy().reshape(n_states, n_turbines))
+                for v in variables
+            }
+        )
 
-        super().write(file_path, data, **kwargs)
+        fpath = self.get_fpath(file_path)
+        write_nc(ds, fpath, verbosity=verbosity, **kwargs)

foxes/output/round.py

@@ -0,0 +1,10 @@
+import foxes.variables as FV
+import foxes.constants as FC
+
+round_defaults = {v: 4 for v in FV.__dict__.keys() if isinstance(v, str)}
+round_defaults[FV.WD] = 3
+round_defaults[FV.YAW] = 3
+round_defaults[FV.TI] = 6
+round_defaults[FV.RHO] = 6
+round_defaults[FC.XYH] = 3
+round_defaults.update({FV.var2amb[v]: round_defaults[v] for v in FV.var2amb.keys()})