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

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

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

@@ -6,7 +6,7 @@ from foxes.core import Turbine, TurbineType
 import foxes.variables as FV
 
 
-def read_turbine_types(wio_farm, algo_dict, ws_exp_P, ws_exp_ct, verbosity):
+def read_turbine_types(wio_farm, mbook, ws_exp_P, ws_exp_ct, verbosity):
     """
     Reads the turbine type from windio
 
@@ -14,8 +14,8 @@ def read_turbine_types(wio_farm, algo_dict, ws_exp_P, ws_exp_ct, verbosity):
     ----------
     wio_farm: dict
         The windio farm data
-    algo_dict: dict
-        The algorithm dictionary
+    mbook: foxes.models.ModelBook
+        The model book
     ws_exp_P: int
         The REWS exponent for power
     ws_exp_ct: int
@@ -29,9 +29,14 @@ def read_turbine_types(wio_farm, algo_dict, ws_exp_P, ws_exp_ct, verbosity):
         Mapping from turbine type key to turbine
         type name in the model book
 
-    :group: input.windio
+    :group: input.yaml.windio
 
     """
+
+    def _print(*args, level=1, **kwargs):
+        if verbosity >= level:
+            print(*args, **kwargs)
+
     if "turbine_types" not in wio_farm:
         wio_farm["turbine_types"] = {0: wio_farm["turbines"]}
 
@@ -39,29 +44,25 @@ def read_turbine_types(wio_farm, algo_dict, ws_exp_P, ws_exp_ct, verbosity):
     for k, wio_trbns in wio_farm["turbine_types"].items():
         tname = wio_trbns.pop("name")
         ttypes[k] = tname
-        if verbosity > 2:
-            print("    Reading turbine type", k)
-            print("      Name:", tname)
-            print("      Contents:", [k for k in wio_trbns.keys()])
+        _print("    Reading turbine type", k, level=3)
+        _print("      Name:", tname, level=3)
+        _print("      Contents:", [k for k in wio_trbns.keys()], level=3)
 
         # read performance:
         performance = Dict(wio_trbns["performance"], name="performance")
-        if verbosity > 2:
-            print("        Reading performance")
-            print("          Contents:", [k for k in performance.keys()])
+        _print("        Reading performance", level=3)
+        _print("          Contents:", [k for k in performance.keys()], level=3)
 
         # P, ct data:
         if "power_curve" in performance:
             power_curve = Dict(performance["power_curve"], name="power_curve")
-            if verbosity > 2:
-                print("            Reading power_curve")
-                print("              Contents:", [k for k in power_curve.keys()])
+            _print("            Reading power_curve", level=3)
+            _print("              Contents:", [k for k in power_curve.keys()], level=3)
             P = power_curve["power_values"]
             ws_P = power_curve["power_wind_speeds"]
             ct_curve = Dict(performance["Ct_curve"], name="Ct_values")
-            if verbosity > 2:
-                print("            Reading Ct_curve")
-                print("              Contents:", [k for k in ct_curve.keys()])
+            _print("            Reading Ct_curve", level=3)
+            _print("              Contents:", [k for k in ct_curve.keys()], level=3)
             ct = ct_curve["Ct_values"]
             ws_ct = ct_curve["Ct_wind_speeds"]
 
@@ -75,10 +76,9 @@ def read_turbine_types(wio_farm, algo_dict, ws_exp_P, ws_exp_ct, verbosity):
                     )
                 return FV.REWS if wse == 1 else (FV.REWS2 if wse == 2 else FV.REWS3)
 
-            if verbosity > 2:
-                print(f"            Creating model '{tname}'")
-                print(f"              Turbine type class: PCtFromTwo")
-            algo_dict["mbook"].turbine_types[tname] = TurbineType.new(
+            _print(f"            Creating model '{tname}'", level=3)
+            _print(f"              Turbine type class: PCtFomTwo", level=3)
+            mbook.turbine_types[tname] = TurbineType.new(
                 ttype_type="PCtFromTwo",
                 data_source_P=data_P,
                 data_source_ct=data_ct,
@@ -92,31 +92,27 @@ def read_turbine_types(wio_farm, algo_dict, ws_exp_P, ws_exp_ct, verbosity):
                 var_ws_P=_get_wse_var(ws_exp_P),
                 rho=1.225,
             )
-            if verbosity > 2:
-                print("               ", algo_dict["mbook"].turbine_types[tname])
+            _print("               ", mbook.turbine_types[tname], level=3)
 
         # P, ct data:
         elif "Cp_curve" in performance:
             cp_curve = Dict(performance["Cp_curve"], name="Cp_curve")
-            if verbosity > 2:
-                print("            Reading Cp_curve")
-                print("              Contents:", [k for k in cp_curve.keys()])
+            _print("            Reading Cp_curve", level=3)
+            _print("              Contents:", [k for k in cp_curve.keys()], level=3)
             cp = cp_curve["Cp_values"]
             ws_cp = cp_curve["Cp_wind_speeds"]
             ct_curve = Dict(performance["Ct_curve"], name="Ct_values")
-            if verbosity > 2:
-                print("            Reading Ct_curve")
-                print("              Contents:", [k for k in ct_curve.keys()])
+            _print("            Reading Ct_curve", level=3)
+            _print("              Contents:", [k for k in ct_curve.keys()], level=3)
             ct = ct_curve["Ct_values"]
             ws_ct = ct_curve["Ct_wind_speeds"]
 
             data_cp = pd.DataFrame(data={"ws": ws_cp, "cp": cp})
             data_ct = pd.DataFrame(data={"ws": ws_ct, "ct": ct})
 
-            if verbosity > 2:
-                print(f"            Creating model '{tname}'")
-                print(f"              Turbine type class: CpCtFromTwo")
-            algo_dict["mbook"].turbine_types[tname] = TurbineType.new(
+            _print(f"            Creating model '{tname}'", level=3)
+            _print(f"              Turbine type class: CpCtFromTwo", level=3)
+            mbook.turbine_types[tname] = TurbineType.new(
                 ttype_type="CpCtFromTwo",
                 data_source_cp=data_cp,
                 data_source_ct=data_ct,
@@ -127,6 +123,7 @@ def read_turbine_types(wio_farm, algo_dict, ws_exp_P, ws_exp_ct, verbosity):
                 H=wio_trbns["hub_height"],
                 D=wio_trbns["rotor_diameter"],
             )
+            _print("               ", mbook.turbine_types[tname], level=3)
 
         else:
             raise KeyError(f"Expecting either 'power_curve' or 'Cp_curve'")
@@ -134,7 +131,7 @@ def read_turbine_types(wio_farm, algo_dict, ws_exp_P, ws_exp_ct, verbosity):
     return ttypes
 
 
-def read_layout(lname, ldict, algo_dict, ttypes, verbosity=1):
+def read_layout(lname, ldict, farm, ttypes, verbosity=1):
     """
     Read wind farm layout from windio input
 
@@ -144,26 +141,20 @@ def read_layout(lname, ldict, algo_dict, ttypes, verbosity=1):
         The layout name
     ldict: dict
         The layout data
-    algo_dict: dict
-        The algorithm dictionary
+    farm: foxes.core.WindFarm
+        The wind farm
     ttypes: dict
         Mapping from turbine type key to turbine
         type name in the model book
     verbosity: int
         The verbosity level, 0=silent
 
-    Returns
-    -------
-    states: foxes.core.States
-        The states object
-
-    :group: input.windio
+    :group: input.yaml.windio
 
     """
     if verbosity > 2:
         print(f"        Reading '{lname}'")
     cdict = Dict(ldict["coordinates"], name="coordinates")
-    farm = algo_dict["farm"]
     tmap = ldict.get("turbine_types", None)
     if verbosity > 2:
         print(f"          Turbine type map:", tmap)

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

@@ -1,11 +1,12 @@
 import numpy as np
 from numbers import Number
 
-import foxes.constants as FC
 import foxes.variables as FV
+import foxes.constants as FC
+
 
 """ Mapping from windio to foxes variables
-:group: input.windio
+:group: input.yaml.windio
 """
 wio2foxes = {
     "time": FC.TIME,
@@ -24,14 +25,14 @@ wio2foxes = {
 }
 
 """ Mapping from foxes to windio variables
-:group: input.windio
+:group: input.yaml.windio
 """
 foxes2wio = {d: k for k, d in wio2foxes.items()}
 
 
 def _read_nondimensional_coordinate(name, wio_data, coords):
     """read nondimensional coordinate
-    :group: input.windio
+    :group: input.yaml.windio
     """
     if isinstance(wio_data, Number):
         coords[wio2foxes[name]] = wio_data
@@ -41,7 +42,7 @@ def _read_nondimensional_coordinate(name, wio_data, coords):
 
 def _read_dimensional_coordinate(name, wio_data, coords):
     """read dimensional coordinate
-    :group: input.windio
+    :group: input.yaml.windio
     """
     if isinstance(wio_data, list):
         wio_data = np.array(wio_data)
@@ -53,7 +54,7 @@ def _read_dimensional_coordinate(name, wio_data, coords):
 
 def _read_multi_dimensional_coordinate(name, wio_data, coords):
     """Read multi dimensional coordinate
-    :group: input.windio
+    :group: input.yaml.windio
     """
     return _read_nondimensional_coordinate(
         name, wio_data, coords
@@ -62,7 +63,7 @@ def _read_multi_dimensional_coordinate(name, wio_data, coords):
 
 def _read_nondimensional_data(name, wio_data, fields, dims):
     """read nondimensional data
-    :group: input.windio
+    :group: input.yaml.windio
     """
     if isinstance(wio_data, Number):
         v = wio2foxes[name]
@@ -74,7 +75,7 @@ def _read_nondimensional_data(name, wio_data, fields, dims):
 
 def _read_dimensional_data(name, wio_data, fields, dims):
     """read dimensional data
-    :group: input.windio
+    :group: input.yaml.windio
     """
     if isinstance(wio_data, dict) and "data" in wio_data and "dims" in wio_data:
         d = wio_data["data"]
@@ -91,7 +92,7 @@ def _read_dimensional_data(name, wio_data, fields, dims):
 
 def _read_multi_dimensional_data(name, wio_data, fields, dims):
     """Read multi dimensional data
-    :group: input.windio
+    :group: input.yaml.windio
     """
     return _read_nondimensional_data(
         name, wio_data, fields, dims
@@ -129,7 +130,7 @@ def read_wind_resource_field(
     success: bool
         Flag for successful data extraction
 
-    :group: input.windio
+    :group: input.yaml.windio
 
     """
     if name in [

foxes/input/yaml/windio/read_outputs.py

@@ -0,0 +1,147 @@
+from pathlib import Path
+
+from foxes.utils import Dict
+import foxes.variables as FV
+import foxes.constants as FC
+
+from .read_fields import foxes2wio
+
+
+def _read_turbine_outputs(wio_outs, odict, verbosity):
+    """Reads the turbine outputs request"""
+    if "turbine_outputs" in wio_outs and wio_outs["turbine_outputs"].get(
+        "report", True
+    ):
+        turbine_outputs = Dict(
+            wio_outs["turbine_outputs"], name=wio_outs.name + ".turbine_outputs"
+        )
+        turbine_nc_filename = turbine_outputs.pop(
+            "turbine_nc_filename", "turbine_outputs.nc"
+        )
+        output_variables = turbine_outputs["output_variables"]
+        if verbosity > 2:
+            print("      Reading turbine_outputs")
+            print("        File name:", turbine_nc_filename)
+            print("        output_variables:", output_variables)
+
+        vmap = Dict(
+            power=FV.P,
+            rotor_effective_velocity=FV.REWS,
+        )
+        ivmap = {d: k for k, d in vmap.items()}
+        ivmap.update(
+            {
+                FC.STATE: "time",
+                FC.TURBINE: "turbine",
+            }
+        )
+
+        odict["StateTurbineTable"] = Dict(
+            functions=[
+                dict(
+                    name="get_dataset",
+                    variables=[vmap[v] for v in output_variables],
+                    name_map=ivmap,
+                    to_file=turbine_nc_filename,
+                    round={vw: FV.get_default_digits(vf) for vw, vf in vmap.items()},
+                    verbosity=verbosity,
+                )
+            ],
+            name=odict.name + ".StateTurbineTable",
+        )
+
+
+def _read_flow_field(wio_outs, odict, verbosity):
+    """Reads the flow field request"""
+    if "flow_field" in wio_outs and wio_outs["flow_field"].get("report", True):
+        flow_field = Dict(wio_outs["flow_field"], name=wio_outs.name + ".flow_field")
+        flow_nc_filename = flow_field.pop("flow_nc_filename", "flow_field.nc")
+        output_variables = flow_field.pop("output_variables")
+        z_planes = Dict(flow_field.pop("z_planes"), name=flow_field.name + ".z_planes")
+        z_sampling = z_planes["z_sampling"]
+        xy_sampling = z_planes["xy_sampling"]
+        cases_run = Dict(
+            flow_field.pop("cases_run", {}), name=flow_field.name + ".cases_run"
+        )
+        states_isel = cases_run.get("subset", None)
+        if "all_occurences" in cases_run and cases_run.pop("all_occurences"):
+            states_isel = None
+        if verbosity > 2:
+            print("      Reading flow_field")
+            print("        File name       :", flow_nc_filename)
+            print("        output_variables:", output_variables)
+            print("        states subset   :", states_isel)
+            print("        z_sampling      :", z_sampling)
+            print("        xy_sampling     :", xy_sampling)
+
+        vmap = Dict(
+            wind_speed=FV.WS,
+            wind_direction=FV.WD,
+        )
+
+        if z_sampling in ["hub_height", "default"]:
+            z = None
+        elif isinstance(z_sampling, (int, float)):
+            z = z_sampling
+        else:
+            raise NotImplementedError(
+                f"z_sampling '{z_sampling}' of type '{type(z_sampling).__name__}' is not supported (yet). Please give 'hub_height', 'default' or a float."
+            )
+
+        if xy_sampling == "default":
+            odict["SliceData"] = Dict(
+                verbosity_delta=3,
+                functions=[
+                    dict(
+                        name="get_states_data_xy",
+                        states_isel=states_isel,
+                        n_img_points=(100, 100),
+                        variables=[vmap[v] for v in output_variables],
+                        z=z,
+                        to_file=flow_nc_filename,
+                        label_map=foxes2wio,
+                        verbosity=verbosity,
+                    )
+                ],
+                name=odict.name + ".SliceData",
+            )
+        else:
+            raise NotImplementedError(
+                f"xy_sampling '{xy_sampling}' is not supported (yet)"
+            )
+
+
+def read_outputs(wio_outs, odict, verbosity=1):
+    """
+    Reads the windio outputs
+
+    Parameters
+    ----------
+    wio_outs: foxes.utils.Dict
+        The windio output data dict
+    odict: foxes.utils.Dict
+        The foxes output dictionary
+    verbosity: int
+        The verbosity level, 0=silent
+
+    Returns
+    -------
+    odir: pathlib.Path
+        The output directory
+
+    :group: input.yaml.windio
+
+    """
+    odir = wio_outs.pop("output_folder", ".")
+    if verbosity > 2:
+        print("  Reading outputs")
+        print("    Output dir:", odir)
+        print("    Contents  :", [k for k in wio_outs.keys()])
+
+    # read turbine_outputs:
+    _read_turbine_outputs(wio_outs, odict, verbosity)
+
+    # read flow field:
+    _read_flow_field(wio_outs, odict, verbosity)
+
+    return odir