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

foxes/input/yaml/dict.py

@@ -20,8 +20,9 @@ def read_dict(
     engine_pars=None,
     iterative=None,
     verbosity=None,
-    work_dir=".",
-    out_dir=".",
+    work_dir=None,
+    input_dir=None,
+    output_dir=None,
     **algo_pars,
 ):
     """
@@ -48,9 +49,11 @@ def read_dict(
     verbosity: int, optional
         Force a verbosity level, 0 = silent, overrules
         settings from idict
-    work_dir: str or pathlib.Path
+    work_dir: str or pathlib.Path, optional
         Path to the working directory
-    out_dir: str or pathlib.Path
+    input_dir: str or pathlib.Path, optional
+        The default input directory
+    output_dir: str or pathlib.Path, optional
         The default output directory
     algo_pars: dict, optional
         Additional parameters for the algorithm, overrules
@@ -72,45 +75,75 @@ def read_dict(
             print(*args, **kwargs)
 
     # set working directory:
-    config[FC.WORK_DIR] = work_dir
-    config[FC.OUT_DIR] = out_dir
-    _print("Working directory:", config.work_dir)
-    _print("Output directory :", config.out_dir)
+    l = 0
+    for c, d in zip(
+        [FC.WORK_DIR, FC.INPUT_DIR, FC.OUTPUT_DIR], [work_dir, input_dir, output_dir]
+    ):
+        if d is not None:
+            config[c] = d
+            l = max(l, len(str(d)))
+    _print("\n--------------------- Reading foxes parameter dict ---------------------")
+    _print("Working directory  :", config.work_dir)
+    _print("Input directory    :", config.input_dir)
+    _print("Output directory   :", config.output_dir)
 
     # create states:
     if states is None:
-        _print("Creating states")
-        states = States.new(**idict["states"])
+        if algo is None:
+            _print("Creating states")
+            states = States.new(**idict["states"])
+        else:
+            states = algo.states
+    else:
+        assert (
+            algo is None
+        ), f"Cannot handle both the algo and the states argument, please drop one"
 
     # create model book:
     if mbook is None:
-        mbook = ModelBook()
-        if "model_book" in idict:
-            _print("Creating model book")
-            mdict = idict.get_item("model_book")
-            for s, mlst in mdict.items():
-                t = mbook.sources.get_item(s)
-                c = mbook.base_classes.get_item(s)
-                ms = [Dict(m, name=f"{mdict.name}.s{i}") for i, m in enumerate(mlst)]
-                for m in ms:
-                    mname = m.pop_item("name")
-                    _print(f"  Adding {s}.{mname}")
-                    t[mname] = c.new(**m)
+        if algo is None:
+            mbook = ModelBook()
+            if "model_book" in idict:
+                _print("Creating model book")
+                mdict = idict.get_item("model_book")
+                for s, mlst in mdict.items():
+                    t = mbook.sources.get_item(s)
+                    c = mbook.base_classes.get_item(s)
+                    ms = [
+                        Dict(m, name=f"{mdict.name}.s{i}") for i, m in enumerate(mlst)
+                    ]
+                    for m in ms:
+                        mname = m.pop_item("name")
+                        _print(f"  Adding {s}.{mname}")
+                        t[mname] = c.new(**m)
+        else:
+            mbook = algo.mbook
+    else:
+        assert (
+            algo is None
+        ), f"Cannot handle both the algo and the mbook argument, please drop one"
 
     # create farm:
     if farm is None:
-        _print("Creating wind farm")
-        fdict = idict.get_item("wind_farm")
-        lyts = [
-            Dict(l, name=f"{fdict.name}.layout{i}")
-            for i, l in enumerate(fdict.pop_item("layouts"))
-        ]
-        farm = WindFarm(**fdict)
-        for lyt in lyts:
-            add_fun = getattr(farm_layout, lyt.pop_item("function"))
-            if verbosity is not None:
-                lyt["verbosity"] = verbosity - 1
-            add_fun(farm, **lyt)
+        if algo is None:
+            _print("Creating wind farm")
+            fdict = idict.get_item("wind_farm")
+            lyts = [
+                Dict(l, name=f"{fdict.name}.layout{i}")
+                for i, l in enumerate(fdict.pop_item("layouts"))
+            ]
+            farm = WindFarm(**fdict)
+            for lyt in lyts:
+                add_fun = getattr(farm_layout, lyt.pop_item("function"))
+                if verbosity is not None:
+                    lyt["verbosity"] = verbosity - 1
+                add_fun(farm, **lyt)
+        else:
+            farm = algo.farm
+    else:
+        assert (
+            algo is None
+        ), f"Cannot handle both the algo and the farm argument, please drop one"
 
     # create engine:
     engine = None
@@ -127,10 +160,10 @@ def read_dict(
 
     # create algorithm:
     if algo is None:
-        _print("Creating algorithm")
         adict = idict.get_item("algorithm")
         if iterative is not None and iterative:
             adict["algo_type"] = "Iterative"
+        _print("Creating algorithm :", adict["algo_type"])
         adict.update(dict(farm=farm, states=states, mbook=mbook))
         if verbosity is not None:
             adict["verbosity"] = verbosity - 1
@@ -138,14 +171,181 @@ def read_dict(
             adict.update({v: d for v, d in algo_pars.items() if d is not None})
         algo = Algorithm.new(**adict)
 
+    _print("------------------------------------------------------------------------\n")
+
     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"Running function {type(obj).__name__}.{fname}")
+    plt_show = fdict.pop_item("plt_show", False)
+    plt_close = fdict.pop_item("plt_close", False)
+    rlbs = fdict.pop_item("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_item("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,
 ):
     """
@@ -161,16 +361,22 @@ def run_outputs(
         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
-        Force a verbosity level, 0 = silent, overrules
-        settings from idict
+        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
+        where results is a list that represents one
         entry per function call
+    rlabels: dict, optional
+        The results variables
 
     :group: input.yaml
 
@@ -181,131 +387,58 @@ def run_outputs(
             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"])
         ]
 
-        rlabels = Dict(name="result_labels")
-
-        def _get_object(rlabels, d):
-            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]
-
         for i, d in enumerate(odicts):
-
             if "output_type" in d:
                 ocls = d.pop_item("output_type")
-                _print(f"  Output {i}: {ocls}")
+                _print(f"\nRunning output {i}: {ocls}")
                 d0 = dict(output_type=ocls)
                 d0.update(d)
+
                 flist = [
-                    Dict(f, name=f"{d.name}.function{i}")
-                    for i, f in enumerate(d.pop_item("functions"))
+                    Dict(f, name=f"{d.name}.function{j}")
+                    for j, f in enumerate(d.pop_item("functions"))
                 ]
-                cls = new_cls(Output, ocls)
-                prs = list(signature(cls.__init__).parameters.keys())
-                if "algo" in prs:
-                    assert (
-                        algo is not None
-                    ), f"Output {i} of type '{ocls}' requires algo"
-                    d["algo"] = algo
-                if "farm" in prs:
-                    d["farm"] = algo.farm
-                if "farm_results" in prs:
-                    if farm_results is None:
-                        print(f"No farm results; skipping output {ocls}")
-                        for fdict in flist:
-                            out += (d0, None)
-                        continue
-                    d["farm_results"] = farm_results
-                if "point_results" in prs:
-                    d["point_results"] = point_results
-                o = cls(**d)
+
+                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")
+                ocls = d.pop_item("object")
+                _print(f"Running output {i}: Object {ocls}")
                 o = _get_object(rlabels, ocls)
                 d0 = dict(object=ocls)
                 d0.update(d)
                 flist = [
-                    Dict(f, name=f"{d.name}.function{i}")
-                    for i, f in enumerate(d.pop_item("functions"))
+                    Dict(f, name=f"{d.name}.function{j}")
+                    for j, f in enumerate(d.pop_item("functions"))
                 ]
 
             else:
                 raise KeyError(
-                    f"Output {i} of type '{ocls}': Please specify either 'output_type' or 'object'"
+                    f"Output {i}: Please specify either 'output_type' or 'object'"
                 )
 
             fres = []
             for fdict in flist:
-                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:
-                assert hasattr(
-                    o, fname
-                ), f"Output {i} of type '{ocls}': Function '{fname}' not found"
-                f = getattr(o, 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)
-
+                results = run_obj_function(o, fdict, algo, rlabels, verbosity)
                 fres.append(results)
             out.append((d0, fres))
 
-    return out
+        if len(odicts):
+            _print()
+
+    return out if not ret_rlabels else out, rlabels
 
 
 def run_dict(idict, *args, verbosity=None, **kwargs):
@@ -332,7 +465,7 @@ def run_dict(idict, *args, verbosity=None, **kwargs):
         The point results
     outputs: list of tuple
         For each output enty, a tuple (dict, results),
-        where results is a tuple that represents one
+        where results is a list that represents one
         entry per function call
 
     :group: input.yaml
@@ -371,7 +504,7 @@ def run_dict(idict, *args, verbosity=None, **kwargs):
         out += (point_results,)
 
     # run outputs:
-    out += (run_outputs(idict, algo, farm_results, point_results, verbosity),)
+    out += (run_outputs(idict, algo, farm_results, point_results, verbosity=verbosity),)
 
     # shutdown engine, if created above:
     if engine is not None:

foxes/input/yaml/windio/__init__.py

@@ -1,4 +1,5 @@
 from .windio import foxes_windio, read_windio
+from .read_site import read_site
 from .read_fields import read_wind_resource_field
-from .read_farm import read_layout, read_turbine_types
+from .read_farm import read_layout, read_turbine_types, read_farm
 from .read_attributes import read_attributes

foxes/input/yaml/windio/read_attributes.py

@@ -2,8 +2,6 @@ from foxes.utils import Dict
 from foxes.core import WakeModel, WakeFrame
 import foxes.variables as FV
 
-from .read_outputs import read_outputs
-
 
 def _read_wind_deficit(
     wake_model_key,
@@ -29,7 +27,7 @@ def _read_wind_deficit(
     ws_sup_dict = Dict(
         {
             "Linear": "ws_linear",
-            "Quadratic": "ws_quadratic",
+            "Squared": "ws_quadratic",
             "Product": "ws_product",
         },
         name="ws_sup_dict",
@@ -37,14 +35,14 @@ def _read_wind_deficit(
     ws_sup_amb_dict = Dict(
         {
             "Linear": "ws_linear_amb",
-            "Quadratic": "ws_quadratic_amb",
+            "Squared": "ws_quadratic_amb",
             "Product": "ws_product",
         },
         name="ws_sup_dict",
     )
 
-    wname = wind_deficit.pop("name")
-    eff_ws = wind_deficit.pop("use_effective_ws", True)
+    wname = wind_deficit.pop_item("name")
+    eff_ws = wind_deficit.pop_item("use_effective_ws", True)
     if verbosity > 2:
         print("    Reading", wake_model_key)
         print("      Name    :", wname)
@@ -53,8 +51,8 @@ def _read_wind_deficit(
     wind_def_dict = Dict(wmodel_type=wind_def_map[wname], induction=induction)
     kcoef = Dict(wind_deficit["wake_expansion_coefficient"], name="kcoef")
     ka = kcoef["k_a"]
-    kb = kcoef.get("k_b", 0.0)
-    amb_ti = kcoef.get("free_stream_ti", False)
+    kb = kcoef.get_item("k_b", 0.0)
+    amb_ti = kcoef.get_item("free_stream_ti", False)
     if ka is None or ka == 0.0:
         wind_def_dict["k"] = kb
         if verbosity > 2:
@@ -108,12 +106,12 @@ def _read_turbulence(
     ti_sup_dict = Dict(
         {
             "Linear": "ti_linear",
-            "Quadratic": "ti_quadratic",
+            "Squared": "ti_quadratic",
         },
         name="ti_sup_dict",
     )
 
-    wname = turbulence_model.pop("name")
+    wname = turbulence_model.pop_item("name")
     if verbosity > 2:
         print("    Reading turbulence_model")
         print("      Name:", wname)
@@ -126,8 +124,8 @@ def _read_turbulence(
         if "wake_expansion_coefficient" in turbulence_model:
             kcoef = Dict(turbulence_model["wake_expansion_coefficient"], name="kcoef")
             ka = kcoef["k_a"]
-            kb = kcoef.get("k_b", 0.0)
-            amb_ti = kcoef.get("free_stream_ti", False)
+            kb = kcoef.get_item("k_b", 0.0)
+            amb_ti = kcoef.get_item("free_stream_ti", False)
         if ka is None or ka == 0.0:
             tiwake_dict["k"] = kb
             if verbosity > 2:
@@ -161,7 +159,7 @@ def _read_blockage(blockage_model, induction, algo_dict, mbook, verbosity):
         name="twake_def_map",
     )
 
-    wname = blockage_model.pop("name")
+    wname = blockage_model.pop_item("name")
     if verbosity > 2:
         print("    Reading blockage_model")
         print("      Name:", wname)
@@ -238,7 +236,7 @@ def _read_deflection(deflection, induction, algo_dict, mbook, verbosity):
         name="defl_def_map",
     )
 
-    wname = deflection.pop("name")
+    wname = deflection.pop_item("name")
     if verbosity > 2:
         print("    Reading deflection_model")
         print("      Name:", wname)
@@ -276,7 +274,7 @@ def _read_analysis(wio_ana, idict, mbook, verbosity):
         },
         name="induction mapping",
     )
-    induction = imap[wio_ana.get("axial_induction_model", "1D")]
+    induction = imap[wio_ana.get_item("axial_induction_model", "1D")]
     if verbosity > 2:
         print("    axial induction model:", induction)
 
@@ -337,14 +335,14 @@ def _read_analysis(wio_ana, idict, mbook, verbosity):
         print("deflection_model not found, using default settings")
 
 
-def read_attributes(wio, idict, mbook, verbosity=1):
+def read_attributes(wio_attrs, idict, mbook, verbosity=1):
     """
     Reads the attributes part of windio
 
     Parameters
     ----------
-    wio: foxes.utils.Dict
-        The windio data
+    wio_attrs: foxes.utils.Dict
+        The windio attributes data
     idict: foxes.utils.Dict
         The foxes input data dictionary
     mbook: foxes.models.ModelBook
@@ -352,15 +350,9 @@ def read_attributes(wio, idict, mbook, verbosity=1):
     verbosity: int
         The verbosity level, 0=silent
 
-    Returns
-    -------
-    odir: pathlib.Path
-        The output directory
-
     :group: input.yaml.windio
 
     """
-    wio_attrs = Dict(wio["attributes"], name=wio.name + ".attributes")
     if verbosity > 1:
         print("Reading attributes")
         print("  Contents:", [k for k in wio_attrs.keys()])
@@ -368,7 +360,7 @@ def read_attributes(wio, idict, mbook, verbosity=1):
     # read flow model:
     if "flow_model" in wio_attrs:
         flow_model = Dict(wio_attrs["flow_model"], name="flow_model")
-        fmname = flow_model.pop("name")
+        fmname = flow_model.pop_item("name")
         if verbosity > 2:
             print("    Reading flow_model")
             print("      Name:", fmname)
@@ -379,12 +371,3 @@ def read_attributes(wio, idict, mbook, verbosity=1):
     # read analysis:
     wio_ana = Dict(wio_attrs["analysis"], name=wio_attrs.name + ".analysis")
     _read_analysis(wio_ana, idict, mbook, verbosity)
-
-    # outputs:
-    odict = idict["outputs"]
-    odir = "."
-    if "outputs" in wio_attrs:
-        outputs = Dict(wio_attrs["outputs"], name=wio_attrs.name + ".outputs")
-        odir = read_outputs(outputs, odict, verbosity=verbosity)
-
-    return odir