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

foxes/input/yaml/dict.py

@@ -0,0 +1,381 @@
+import matplotlib.pyplot as plt
+import pandas as pd
+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.output import Output
+from foxes.utils import Dict, new_cls
+from foxes.config import config
+import foxes.constants as FC
+
+
+def read_dict(
+    idict,
+    farm=None,
+    states=None,
+    mbook=None,
+    algo=None,
+    engine_pars=None,
+    iterative=None,
+    verbosity=None,
+    work_dir=".",
+    out_dir=".",
+    **algo_pars,
+):
+    """
+    Read dictionary input into foxes objects
+
+    Parameters
+    ----------
+    idict: foxes.utils.Dict
+        The input parameter dictionary
+    farm: foxes.core.WindFarm, optional
+        The wind farm, overrules settings from idict
+    states: foxes.core.States, optional
+        The ambient states, overrules settings from idict
+    mbook: foxes.models.ModelBook, optional
+        The model book, overrules settings from idict
+    algo: foxes.core.Algorithm, optional
+        The algorithm, overrules settings from idict
+    engine_pars: dict, optional
+        Parameters for engine creation, overrules
+        settings from idict
+    iterative: bool, optional
+        Force iterative calculations, overrules
+        settings from idict
+    verbosity: int, optional
+        Force a verbosity level, 0 = silent, overrules
+        settings from idict
+    work_dir: str or pathlib.Path
+        Path to the working directory
+    out_dir: str or pathlib.Path
+        The default output directory
+    algo_pars: dict, optional
+        Additional parameters for the algorithm, overrules
+        settings from idict
+
+    Returns
+    -------
+    algo: foxes.core.Algorithm
+        The algorithm
+    engine: foxes.core.Engine
+        The engine, or None if not set
+
+    :group: input.yaml
+
+    """
+
+    def _print(*args, level=1, **kwargs):
+        if verbosity is None or verbosity >= level:
+            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)
+
+    # create states:
+    if states is None:
+        _print("Creating states")
+        states = States.new(**idict["states"])
+
+    # 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)
+
+    # 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)
+
+    # create engine:
+    engine = None
+    if engine_pars is not None:
+        engine = Engine.new(**engine_pars)
+        _print(f"Initializing engine: {engine}")
+        engine.initialize()
+    elif "engine" in idict:
+        if verbosity is not None:
+            idict["verbosity"] = verbosity - 1
+        engine = Engine.new(**idict["engine"])
+        engine.initialize()
+        _print(f"Initializing engine: {engine}")
+
+    # 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"
+        adict.update(dict(farm=farm, states=states, mbook=mbook))
+        if verbosity is not None:
+            adict["verbosity"] = verbosity - 1
+        if algo_pars is not None:
+            adict.update({v: d for v, d in algo_pars.items() if d is not None})
+        algo = Algorithm.new(**adict)
+
+    return algo, engine
+
+
+def run_outputs(
+    idict,
+    algo=None,
+    farm_results=None,
+    point_results=None,
+    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
+    verbosity: int, optional
+        Force a verbosity level, 0 = silent, overrules
+        settings from idict
+
+    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
+
+    :group: input.yaml
+
+    """
+
+    def _print(*args, level=1, **kwargs):
+        if verbosity is None or verbosity >= level:
+            print(*args, **kwargs)
+
+    out = []
+    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}")
+                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"))
+                ]
+                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)
+
+            elif "object" in d:
+                ocls = d.pop("object")
+                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"))
+                ]
+
+            else:
+                raise KeyError(
+                    f"Output {i} of type '{ocls}': 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)
+
+                fres.append(results)
+            out.append((d0, fres))
+
+    return out
+
+
+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", Dict(name=idict.name + ".calc_farm"))
+    if rdict.pop_item("run", True):
+        _print("Running calc_farm")
+        farm_results = algo.calc_farm(**rdict)
+    else:
+        farm_results = None
+    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"):
+            _print("Running calc_points")
+            points = rdict.pop_item("points")
+            if isinstance(points, str):
+                _print("Reading file", points)
+                points = pd.read_csv(points).to_numpy()
+            point_results = algo.calc_points(farm_results, points=points, **rdict)
+        else:
+            point_results = None
+        out += (point_results,)
+
+    # run outputs:
+    out += (run_outputs(idict, algo, farm_results, point_results, verbosity),)
+
+    # shutdown engine, if created above:
+    if engine is not None:
+        _print(f"Finalizing engine: {engine}")
+        engine.finalize()
+
+    return out

foxes/input/yaml/windio/__init__.py

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

foxes/input/{windio → yaml/windio}/get_states.py

@@ -4,13 +4,13 @@ from xarray import Dataset
 from numbers import Number
 
 from foxes.core import States
-import foxes.constants as FC
 import foxes.variables as FV
+import foxes.constants as FC
 
 
 def _get_profiles(coords, fields, dims, ovars, fixval, verbosity):
     """Read ABL profiles information
-    :group: input.windio
+    :group: input.yaml.windio
     """
     profiles = {}
     if FV.Z0 in fields:
@@ -42,7 +42,7 @@ def _get_SingleStateStates(
     coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
 ):
     """Try to generate single state parameters
-    :group: input.windio
+    :group: input.yaml.windio
     """
     for c in coords:
         if not isinstance(c, Number):
@@ -81,7 +81,7 @@ def _get_Timeseries(
     coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
 ):
     """Try to generate time series parameters
-    :group: input.windio
+    :group: input.yaml.windio
     """
     if len(coords) == 1 and FC.TIME in coords:
         if verbosity > 2:
@@ -117,7 +117,7 @@ def _get_MultiHeightNCTimeseries(
     coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
 ):
     """Try to generate time series parameters
-    :group: input.windio
+    :group: input.yaml.windio
     """
     if len(coords) == 2 and FC.TIME in coords and FV.H in coords:
         if verbosity > 2:
@@ -176,11 +176,11 @@ def get_states(coords, fields, dims, verbosity=1):
     states: foxes.core.States
         The states object
 
-    :group: input.windio
+    :group: input.yaml.windio
 
     """
     if verbosity > 2:
-        print("      Preparing states")
+        print("      Creating states")
 
     ovars = [FV.WS, FV.WD, FV.TI, FV.RHO]
     fixval = {FV.TI: 0.05, FV.RHO: 1.225}

foxes/input/{windio → yaml/windio}/read_attributes.py

@@ -6,7 +6,13 @@ from .read_outputs import read_outputs
 
 
 def _read_wind_deficit(
-    wake_model_key, wind_deficit, superposition, induction, algo_dict, verbosity
+    wake_model_key,
+    wind_deficit,
+    superposition,
+    induction,
+    algo_dict,
+    mbook,
+    verbosity,
 ):
     """Reads the wind deficit wake model"""
 
@@ -69,17 +75,25 @@ def _read_wind_deficit(
     supd = ws_sup_dict if eff_ws else ws_sup_amb_dict
     wind_def_dict["superposition"] = supd[superposition["ws_superposition"]]
 
-    algo_dict["mbook"].wake_models[wname] = WakeModel.new(**wind_def_dict)
+    mbook.wake_models[wname] = WakeModel.new(**wind_def_dict)
     if verbosity > 2:
         print(f"      Created wake model '{wname}':")
-        print("       ", algo_dict["mbook"].wake_models[wname])
+        print("       ", mbook.wake_models[wname])
     algo_dict["wake_models"].append(wname)
 
     return ka, kb, amb_ti
 
 
 def _read_turbulence(
-    turbulence_model, superposition, induction, algo_dict, ka, kb, amb_ti, verbosity
+    turbulence_model,
+    superposition,
+    induction,
+    algo_dict,
+    mbook,
+    ka,
+    kb,
+    amb_ti,
+    verbosity,
 ):
     """Reads the ti wake model"""
 
@@ -128,14 +142,14 @@ def _read_turbulence(
             tiwake_dict["ti_var"] = ti_var
         tiwake_dict["superposition"] = ti_sup_dict[superposition["ti_superposition"]]
 
-        algo_dict["mbook"].wake_models[wname] = WakeModel.new(**tiwake_dict)
+        mbook.wake_models[wname] = WakeModel.new(**tiwake_dict)
         if verbosity > 2:
             print(f"      Created wake model '{wname}':")
-            print("       ", algo_dict["mbook"].wake_models[wname])
+            print("       ", mbook.wake_models[wname])
         algo_dict["wake_models"].append(wname)
 
 
-def _read_blockage(blockage_model, induction, algo_dict, verbosity):
+def _read_blockage(blockage_model, induction, algo_dict, mbook, verbosity):
     """Reads the blockage model"""
     indc_def_map = Dict(
         {
@@ -154,10 +168,10 @@ def _read_blockage(blockage_model, induction, algo_dict, verbosity):
         print("      Contents:", [k for k in blockage_model.keys()])
     if wname not in ["None", "none"]:
         indc_dict = Dict(wmodel_type=indc_def_map[wname], induction=induction)
-        algo_dict["mbook"].wake_models[wname] = WakeModel.new(**indc_dict)
+        mbook.wake_models[wname] = WakeModel.new(**indc_dict)
         if verbosity > 2:
             print(f"      Created wake model '{wname}':")
-            print("       ", algo_dict["mbook"].wake_models[wname])
+            print("       ", mbook.wake_models[wname])
         algo_dict["wake_models"].append(wname)
         algo_dict["algo_type"] = "Iterative"
 
@@ -214,7 +228,7 @@ def _read_rotor_averaging(rotor_averaging, algo_dict, verbosity):
         print("        --> partial_wakes   :", algo_dict["partial_wakes"])
 
 
-def _read_deflection(deflection, induction, algo_dict, verbosity):
+def _read_deflection(deflection, induction, algo_dict, mbook, verbosity):
     """Reads deflection model"""
     defl_def_map = Dict(
         {
@@ -231,25 +245,25 @@ def _read_deflection(deflection, induction, algo_dict, verbosity):
         print("      Contents:", [k for k in deflection.keys()])
     indc_dict = Dict(wframe_type=defl_def_map[wname])
     try:
-        algo_dict["mbook"].wake_frames[wname] = WakeFrame.new(
-            **indc_dict, induction=induction
-        )
+        mbook.wake_frames[wname] = WakeFrame.new(**indc_dict, induction=induction)
     except TypeError:
-        algo_dict["mbook"].wake_frames[wname] = WakeFrame.new(**indc_dict)
+        mbook.wake_frames[wname] = WakeFrame.new(**indc_dict)
     if verbosity > 2:
         print(f"      Created wake frame '{wname}':")
-        print("       ", algo_dict["mbook"].wake_frames[wname])
+        print("       ", mbook.wake_frames[wname])
     algo_dict["wake_frame"] = wname
 
 
-def _read_analysis(wio_ana, algo_dict, verbosity):
+def _read_analysis(wio_ana, idict, mbook, verbosity):
     """Reads the windio analyses"""
     if verbosity > 2:
         print("    Reading analysis")
         print("      Contents:", [k for k in wio_ana.keys()])
 
     # superposition:
-    superposition = Dict(wio_ana["superposition_model"], name="superposition_model")
+    superposition = Dict(
+        wio_ana["superposition_model"], name=wio_ana.name + ".superposition_model"
+    )
     if verbosity > 2:
         print("    Reading superposition_model")
         print("      Contents:", [k for k in superposition.keys()])
@@ -270,9 +284,18 @@ def _read_analysis(wio_ana, algo_dict, verbosity):
     wake_model_key = (
         "wind_deficit_model" if "wind_deficit_model" in wio_ana else "wake_model"
     )
-    wind_deficit = Dict(wio_ana[wake_model_key], name=wake_model_key)
+    algo_dict = idict["algorithm"]
+    wind_deficit = Dict(
+        wio_ana[wake_model_key], name=wio_ana.name + "." + wake_model_key
+    )
     ka, kb, amb_ti = _read_wind_deficit(
-        wake_model_key, wind_deficit, superposition, induction, algo_dict, verbosity
+        wake_model_key,
+        wind_deficit,
+        superposition,
+        induction,
+        algo_dict,
+        mbook,
+        verbosity,
     )
 
     # turbulence model:
@@ -283,6 +306,7 @@ def _read_analysis(wio_ana, algo_dict, verbosity):
             superposition,
             induction,
             algo_dict,
+            mbook,
             ka,
             kb,
             amb_ti,
@@ -294,7 +318,7 @@ def _read_analysis(wio_ana, algo_dict, verbosity):
     # blockage model:
     if "blockage_model" in wio_ana:
         blockage_model = Dict(wio_ana["blockage_model"], name="blockage_model")
-        _read_blockage(blockage_model, induction, algo_dict, verbosity)
+        _read_blockage(blockage_model, induction, algo_dict, mbook, verbosity)
     elif verbosity > 0:
         print("blockage_model not found, not using a turbine induction model")
 
@@ -308,37 +332,35 @@ def _read_analysis(wio_ana, algo_dict, verbosity):
     # deflection:
     if "deflection_model" in wio_ana:
         deflection = Dict(wio_ana["deflection_model"], name="deflection_model")
-        _read_deflection(deflection, induction, algo_dict, verbosity)
+        _read_deflection(deflection, induction, algo_dict, mbook, verbosity)
     elif verbosity > 0:
         print("deflection_model not found, using default settings")
 
 
-def read_attributes(wio, algo_dict, verbosity=1, **output_pars):
+def read_attributes(wio, idict, mbook, verbosity=1):
     """
     Reads the attributes part of windio
 
     Parameters
     ----------
-    wio: dict
+    wio: foxes.utils.Dict
         The windio data
-    algo_dict: dict
-        The algorithm dictionary
+    idict: foxes.utils.Dict
+        The foxes input data dictionary
+    mbook: foxes.models.ModelBook
+        The model book
     verbosity: int
         The verbosity level, 0=silent
-    **output_pars: dict, optional
-        Additional parameters for output reading
 
     Returns
     -------
-    out_dicts: list of dict
-        The output dictionaries
     odir: pathlib.Path
-        Path to the output folder
+        The output directory
 
-    :group: input.windio
+    :group: input.yaml.windio
 
     """
-    wio_attrs = Dict(wio["attributes"], name="attributes")
+    wio_attrs = Dict(wio["attributes"], name=wio.name + ".attributes")
     if verbosity > 1:
         print("Reading attributes")
         print("  Contents:", [k for k in wio_attrs.keys()])
@@ -355,15 +377,14 @@ def read_attributes(wio, algo_dict, verbosity=1, **output_pars):
             print(f"Running flow model 'foxes', overruling original choice '{fmname}'")
 
     # read analysis:
-    wio_ana = Dict(wio_attrs["analysis"], name="analyses")
-    _read_analysis(wio_ana, algo_dict, verbosity)
+    wio_ana = Dict(wio_attrs["analysis"], name=wio_attrs.name + ".analysis")
+    _read_analysis(wio_ana, idict, mbook, verbosity)
 
     # outputs:
-    out_dicts = []
+    odict = idict["outputs"]
+    odir = "."
     if "outputs" in wio_attrs:
-        outputs = Dict(wio_attrs["outputs"], name="outputs")
-        out_dicts, odir = read_outputs(
-            outputs, algo_dict, verbosity=verbosity, **output_pars
-        )
+        outputs = Dict(wio_attrs["outputs"], name=wio_attrs.name + ".outputs")
+        odir = read_outputs(outputs, odict, verbosity=verbosity)
 
-    return out_dicts, odir
+    return odir