foxes 1.2__py3-none-any.whl → 1.2.2__py3-none-any.whl

foxes/input/yaml/dict.py

@@ -5,13 +5,13 @@ from inspect import signature
 import foxes.input.farm_layout as farm_layout
 from foxes.core import States, Engine, WindFarm, Algorithm
 from foxes.models import ModelBook
-from foxes import output
-from foxes.utils import Dict
+from foxes.output import Output
+from foxes.utils import Dict, new_cls
 from foxes.config import config
 import foxes.constants as FC
 
 
-def run_dict(
+def read_dict(
     idict,
     farm=None,
     states=None,
@@ -25,7 +25,7 @@ def run_dict(
     **algo_pars,
 ):
     """
-    Runs foxes from dictionary input
+    Read dictionary input into foxes objects
 
     Parameters
     ----------
@@ -58,12 +58,10 @@ def run_dict(
 
     Returns
     -------
-    farm_results: xarray.Dataset, optional
-        The farm results
-    point_results: xarray.Dataset, optional
-        The point results
-    output_i: object
-        For each output either None or the output result
+    algo: foxes.core.Algorithm
+        The algorithm
+    engine: foxes.core.Engine
+        The engine, or None if not set
 
     :group: input.yaml
 
@@ -137,12 +135,316 @@ def run_dict(
         if verbosity is not None:
             adict["verbosity"] = verbosity - 1
         if algo_pars is not None:
-            adict.update(algo_pars)
+            adict.update({v: d for v, d in algo_pars.items() if d is not None})
         algo = Algorithm.new(**adict)
 
+    return algo, engine
+
+
+def get_output_obj(
+    ocls,
+    odict,
+    algo,
+    farm_results=None,
+    point_results=None,
+    base_class=Output,
+    extra_sig={},
+):
+    """
+    Create the output object
+
+    Parameters
+    ----------
+    ocls: str
+        Name of the output class
+    odict: dict
+        The output dict
+    algo: foxes.core.Algorithm
+        The algorithm
+    farm_results: xarray.Dataset, optional
+        The farm results
+    point_results: xarray.Dataset, optional
+        The point results
+    base_class: object
+        The output's base class
+    extra_sig: dict
+        Extra function signature check, sets
+        arguments (key) with data (value)
+
+    Returns
+    -------
+    obj: object or None
+        The output object
+
+    :group: input.yaml
+
+    """
+    cls = new_cls(base_class, ocls)
+    prs = list(signature(cls.__init__).parameters.keys())
+    if "algo" in prs:
+        assert algo is not None, f"Output of type '{ocls}' requires algo"
+        odict["algo"] = algo
+    if "farm" in prs:
+        odict["farm"] = algo.farm
+    if "farm_results" in prs:
+        if farm_results is None:
+            print(f"No farm results; skipping output {ocls}")
+            return None
+        odict["farm_results"] = farm_results
+    if "point_results" in prs:
+        odict["point_results"] = point_results
+    for k, v in extra_sig.items():
+        if k in prs:
+            odict[k] = v
+
+    return cls(**odict)
+
+
+def _get_object(rlabels, d):
+    """Helper function for object extraction"""
+    d = d.replace("]", "")
+    i0 = d.find("[")
+    if i0 > 0:
+        inds = tuple([int(x) for x in d[i0 + 1 :].split(",")])
+        return rlabels[d[:i0]][inds]
+    else:
+        return rlabels[d]
+
+
+def run_obj_function(
+    obj,
+    fdict,
+    algo,
+    rlabels,
+    verbosity=None,
+):
+    """
+    Runs a function of an object
+
+    Parameters
+    ----------
+    obj: object
+        The object
+    fdict: dict
+        The function call dict
+    algo: foxes.core.Algorithm
+        The algorithm
+    rlabels: dict
+        Storage for result variables
+    verbosity: int, optional
+        The verbosity level, 0 = silent
+
+    Returns
+    -------
+    results: object
+        The returns of the function
+
+    :group: input.yaml
+
+    """
+
+    def _print(*args, level=1, **kwargs):
+        if verbosity is None or verbosity >= level:
+            print(*args, **kwargs)
+
+    fname = fdict.pop_item("function")
+    _print(f"  - {fname}")
+    plt_show = fdict.pop("plt_show", False)
+    plt_close = fdict.pop("plt_close", False)
+    rlbs = fdict.pop("result_labels", None)
+
+    # grab function:
+    ocls = type(obj).__name__
+    assert hasattr(obj, fname), f"Output of type '{ocls}': Function '{fname}' not found"
+    f = getattr(obj, fname)
+
+    # add required input data objects:
+    prs = list(signature(f).parameters.keys())
+    if "algo" in prs:
+        fdict["algo"] = algo
+    if "farm" in prs:
+        fdict["farm"] = algo.farm
+
+    # replace result labels by objects:
+    for k, d in fdict.items():
+        if isinstance(d, str) and d[0] == "$":
+            fdict[k] = _get_object(rlabels, d)
+
+    # run function:
+    args = fdict.pop("args", tuple())
+    results = f(*args, **fdict)
+
+    # pyplot shortcuts:
+    if plt_show:
+        plt.show()
+    if plt_close:
+        results = None
+        plt.close()
+
+    # store results under result labels:
+    if rlbs is not None:
+
+        def _set_label(rlabels, k, r):
+            if k not in ["", "none", "None", "_", "__"]:
+                assert (
+                    k[0] == "$"
+                ), f"Output {i} of type '{ocls}', function '{fname}': result labels must start with '$', got '{k}'"
+                assert (
+                    "[" not in k and "]" not in k and "," not in k
+                ), f"Output {i} of type '{ocls}', function '{fname}': result labels cannot contain '[' or ']' or comma, got '{k}'"
+                _print(f"    result label {k}: {type(r).__name__}")
+                rlabels[k] = r
+
+        if isinstance(rlbs, (list, tuple)):
+            for i, k in enumerate(rlbs):
+                _set_label(rlabels, k, results[i])
+        else:
+            _set_label(rlabels, rlbs, results)
+
+    return results
+
+
+def run_outputs(
+    idict,
+    algo=None,
+    farm_results=None,
+    point_results=None,
+    extra_sig={},
+    ret_rlabels=False,
+    verbosity=None,
+):
+    """
+    Run outputs from dict.
+
+    Parameters
+    ----------
+    idict: foxes.utils.Dict
+        The input parameter dictionary
+    algo: foxes.core.Algorithm, optional
+        The algorithm
+    farm_results: xarray.Dataset, optional
+        The farm results
+    point_results: xarray.Dataset, optional
+        The point results
+    extra_sig: dict
+        Extra function signature check, sets
+        arguments (key) with data (value)
+    ret_rlabels: bool
+        Flag for returning results variables
+    verbosity: int, optional
+        The verbosity level, 0 = silent
+
+    Returns
+    -------
+    outputs: list of tuple
+        For each output enty, a tuple (dict, results),
+        where results is a tuple that represents one
+        entry per function call
+    rlabels: dict, optional
+        The results variables
+
+    :group: input.yaml
+
+    """
+
+    def _print(*args, level=1, **kwargs):
+        if verbosity is None or verbosity >= level:
+            print(*args, **kwargs)
+
+    out = []
+    rlabels = Dict(name="result_labels")
+    if "outputs" in idict:
+        _print("Running outputs")
+        odicts = [
+            Dict(odict, name=f"{idict.name}.output{i}")
+            for i, odict in enumerate(idict["outputs"])
+        ]
+
+        for i, d in enumerate(odicts):
+            if "output_type" in d:
+                ocls = d.pop_item("output_type")
+                _print(f"  Output {i}: {ocls}")
+                d0 = dict(output_type=ocls)
+                d0.update(d)
+
+                flist = [
+                    Dict(f, name=f"{d.name}.function{j}")
+                    for j, f in enumerate(d.pop_item("functions"))
+                ]
+
+                o = get_output_obj(
+                    ocls, d, algo, farm_results, point_results, extra_sig=extra_sig
+                )
+                if o is None:
+                    out.append((d0, None))
+                    continue
+
+            elif "object" in d:
+                ocls = d.pop("object")
+                _print(f"  Output {i}: Object {ocls}")
+                o = _get_object(rlabels, ocls)
+                d0 = dict(object=ocls)
+                d0.update(d)
+                flist = [
+                    Dict(f, name=f"{d.name}.function{j}")
+                    for j, f in enumerate(d.pop_item("functions"))
+                ]
+
+            else:
+                raise KeyError(
+                    f"Output {i}: Please specify either 'output_type' or 'object'"
+                )
+
+            fres = []
+            for fdict in flist:
+                results = run_obj_function(o, fdict, algo, rlabels, verbosity)
+                fres.append(results)
+            out.append((d0, fres))
+
+    return out if not ret_rlabels else out, rlabels
+
+
+def run_dict(idict, *args, verbosity=None, **kwargs):
+    """
+    Runs foxes from dictionary input
+
+    Parameters
+    ----------
+    idict: foxes.utils.Dict
+        The input parameter dictionary
+    args: tuple, optional
+        Additional parameters for read_dict
+    verbosity: int, optional
+        Force a verbosity level, 0 = silent, overrules
+        settings from idict
+    kwargs: dict, optional
+        Additional parameters for read_dict
+
+    Returns
+    -------
+    farm_results: xarray.Dataset, optional
+        The farm results
+    point_results: xarray.Dataset, optional
+        The point results
+    outputs: list of tuple
+        For each output enty, a tuple (dict, results),
+        where results is a tuple that represents one
+        entry per function call
+
+    :group: input.yaml
+
+    """
+
+    def _print(*args, level=1, **kwargs):
+        if verbosity is None or verbosity >= level:
+            print(*args, **kwargs)
+
+    # read components:
+    algo, engine = read_dict(idict, *args, verbosity=verbosity, **kwargs)
+
     # run farm calculation:
-    rdict = idict.get_item("calc_farm")
-    if rdict.pop_item("run"):
+    rdict = idict.get_item("calc_farm", Dict(name=idict.name + ".calc_farm"))
+    if rdict.pop_item("run", True):
         _print("Running calc_farm")
         farm_results = algo.calc_farm(**rdict)
     else:
@@ -150,6 +452,7 @@ def run_dict(
     out = (farm_results,)
 
     # run points calculation:
+    point_results = None
     if "calc_points" in idict:
         rdict = idict.get_item("calc_points")
         if rdict.pop_item("run"):
@@ -164,43 +467,7 @@ def run_dict(
         out += (point_results,)
 
     # run outputs:
-    if "outputs" in idict:
-        _print("Running outputs")
-        odict = idict["outputs"]
-        for ocls, d in odict.items():
-            _print(f"  Output {ocls}")
-            flist = [
-                Dict(f, name=f"{d.name}.function{i}")
-                for i, f in enumerate(d.pop_item("functions"))
-            ]
-            try:
-                cls = getattr(output, ocls)
-            except AttributeError as e:
-                print(f"\nClass '{ocls}' not found in outputs. Found:")
-            prs = list(signature(cls.__init__).parameters.keys())
-            if "algo" in prs:
-                d["algo"] = algo
-            if "farm_results" in prs:
-                if farm_results is None:
-                    print(f"No farm results; skipping output {ocls}")
-                    for fdict in flist:
-                        out += (None,)
-                    continue
-                d["farm_results"] = farm_results
-            o = cls(**d)
-            for fdict in flist:
-                fname = fdict.pop_item("name")
-                _print(f"  - {fname}")
-                plt_show = fdict.pop("plt_show", False)
-                f = getattr(o, fname)
-                prs = list(signature(f).parameters.keys())
-                if "algo" in prs:
-                    fdict["algo"] = algo
-                res = f(**fdict)
-                out += (res,) if not isinstance(res, tuple) else res
-                if plt_show:
-                    plt.show()
-                    plt.close()
+    out += (run_outputs(idict, algo, farm_results, point_results, verbosity=verbosity),)
 
     # shutdown engine, if created above:
     if engine is not None:

foxes/input/yaml/yaml.py

@@ -24,18 +24,18 @@ def foxes_yaml():
         help="The input yaml file",
     )
     parser.add_argument("-o", "--out_dir", help="The output directory", default=".")
-    parser.add_argument("-r", "--rotor", help="The rotor model", default="centre")
+    parser.add_argument("-r", "--rotor", help="The rotor model", default=None)
     parser.add_argument(
-        "-p", "--pwakes", help="The partial wakes models", default="centre", nargs="+"
+        "-p", "--pwakes", help="The partial wakes models", default=None, nargs="+"
     )
     parser.add_argument(
         "-w",
         "--wakes",
         help="The wake models",
-        default=["Jensen_linear_k007"],
+        default=None,
         nargs="+",
     )
-    parser.add_argument("-f", "--frame", help="The wake frame", default="rotor_wd")
+    parser.add_argument("-f", "--frame", help="The wake frame", default=None)
     parser.add_argument("-e", "--engine", help="The engine", default=None)
     parser.add_argument(
         "-n", "--n_procs", help="The number of processes", default=None, type=int
@@ -51,7 +51,7 @@ def foxes_yaml():
         "-C",
         "--chunksize_points",
         help="The chunk size for points",
-        default=5000,
+        default=None,
         type=int,
     )
     parser.add_argument(

foxes/output/__init__.py

@@ -6,7 +6,7 @@ from .round import round_defaults
 from .output import Output
 from .farm_layout import FarmLayoutOutput
 from .farm_results_eval import FarmResultsEval
-from .rose_plot import RosePlotOutput, StatesRosePlotOutput
+from .rose_plot import RosePlotOutput, StatesRosePlotOutput, WindRoseBinPlot
 from .results_writer import ResultsWriter
 from .state_turbine_map import StateTurbineMap
 from .turbine_type_curves import TurbineTypeCurves
@@ -15,6 +15,7 @@ from .calc_points import PointCalculator
 from .slice_data import SliceData
 from .rotor_point_plots import RotorPointPlot
 from .state_turbine_table import StateTurbineTable
+from .plt import plt
 
 from .flow_plots_2d import FlowPlots2D
 from .seq_plugins import SeqFlowAnimationPlugin, SeqWakeDebugPlugin

foxes/output/farm_results_eval.py

@@ -64,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:
@@ -99,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
         -------
@@ -111,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)
@@ -144,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
         -------
@@ -156,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)
@@ -205,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.
 
@@ -235,6 +252,8 @@ class FarmResultsEval(Output):
         ----------
         vars: list of str
             The variables
+        use_weights: bool
+            Flag for using states weights for the mean
 
         Returns
         -------
@@ -242,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):
         """
@@ -291,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):
         """
@@ -325,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):
@@ -362,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(
@@ -536,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):
@@ -553,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,