foxes 1.2.2__py3-none-any.whl → 1.2.4__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,6 +171,8 @@ 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
 
 
@@ -248,10 +283,10 @@ def run_obj_function(
             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)
+    _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__
@@ -271,7 +306,7 @@ def run_obj_function(
             fdict[k] = _get_object(rlabels, d)
 
     # run function:
-    args = fdict.pop("args", tuple())
+    args = fdict.pop_item("args", tuple())
     results = f(*args, **fdict)
 
     # pyplot shortcuts:
@@ -338,7 +373,7 @@ def run_outputs(
     -------
     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
@@ -354,7 +389,6 @@ def run_outputs(
     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"])
@@ -363,7 +397,7 @@ def run_outputs(
         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)
 
@@ -380,8 +414,8 @@ def run_outputs(
                     continue
 
             elif "object" in d:
-                ocls = d.pop("object")
-                _print(f"  Output {i}: Object {ocls}")
+                ocls = d.pop_item("object")
+                _print(f"Running output {i}: Object {ocls}")
                 o = _get_object(rlabels, ocls)
                 d0 = dict(object=ocls)
                 d0.update(d)
@@ -401,6 +435,9 @@ def run_outputs(
                 fres.append(results)
             out.append((d0, fres))
 
+        if len(odicts):
+            _print()
+
     return out if not ret_rlabels else out, rlabels
 
 
@@ -428,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

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

foxes/input/yaml/windio/read_farm.py

@@ -2,7 +2,7 @@ import numpy as np
 import pandas as pd
 
 from foxes.utils import Dict
-from foxes.core import Turbine, TurbineType
+from foxes.core import Turbine, TurbineType, WindFarm
 import foxes.variables as FV
 
 
@@ -42,7 +42,7 @@ def read_turbine_types(wio_farm, mbook, ws_exp_P, ws_exp_ct, verbosity):
 
     ttypes = {}
     for k, wio_trbns in wio_farm["turbine_types"].items():
-        tname = wio_trbns.pop("name")
+        tname = wio_trbns.pop_item("name")
         ttypes[k] = tname
         _print("    Reading turbine type", k, level=3)
         _print("      Name:", tname, level=3)
@@ -155,7 +155,7 @@ def read_layout(lname, ldict, farm, ttypes, verbosity=1):
     if verbosity > 2:
         print(f"        Reading '{lname}'")
     cdict = Dict(ldict["coordinates"], name="coordinates")
-    tmap = ldict.get("turbine_types", None)
+    tmap = ldict.get_item("turbine_types", None)
     if verbosity > 2:
         print(f"          Turbine type map:", tmap)
     for i, xy in enumerate(zip(cdict["x"], cdict["y"])):
@@ -166,3 +166,57 @@ def read_layout(lname, ldict, farm, ttypes, verbosity=1):
         )
     if verbosity > 2:
         print(f"          Added {farm.n_turbines} turbines")
+
+
+def read_farm(wio_dict, mbook, verbosity):
+    """
+    Reads the wind farm information
+
+    Parameters
+    ----------
+    wio_dict: foxes.utils.Dict
+        The windio data
+    verbosity: int
+        The verbosity level, 0=silent
+
+    Returns
+    -------
+    farm: foxes.core.WindFarm
+        The wind farm
+
+    :group: input.yaml.windio
+
+    """
+    wio_farm = Dict(wio_dict["wind_farm"], name=wio_dict.name + ".wind_farm")
+    if verbosity > 1:
+        print("Reading wind farm")
+        print("  Name:", wio_farm.pop_item("name", None))
+        print("  Contents:", [k for k in wio_farm.keys()])
+
+    # find REWS exponents:
+    try:
+        rotor_averaging = wio_dict["attributes"]["analysis"]["rotor_averaging"]
+        ws_exp_P = rotor_averaging["wind_speed_exponent_for_power"]
+        ws_exp_ct = rotor_averaging["wind_speed_exponent_for_ct"]
+    except KeyError:
+        ws_exp_P = 1
+        ws_exp_ct = 1
+
+    # read turbine type:
+    ttypes = read_turbine_types(wio_farm, mbook, ws_exp_P, ws_exp_ct, verbosity)
+
+    # read layouts and create wind farm:
+    farm = WindFarm()
+    wfarm = wio_farm["layouts"]
+    if isinstance(wfarm, dict):
+        layouts = Dict(wfarm, name=wio_farm.name + ".layouts")
+    else:
+        layouts = {str(i): l for i, l in enumerate(wfarm)}
+        layouts = Dict(layouts, name=wio_farm.name + ".layouts")
+    if verbosity > 2:
+        print("    Reading layouts")
+        print("      Contents:", [k for k in layouts.keys()])
+    for lname, ldict in layouts.items():
+        read_layout(lname, ldict, farm, ttypes, verbosity)
+
+    return farm