foxes 1.3__py3-none-any.whl → 1.5__py3-none-any.whl

foxes/input/yaml/dict.py

@@ -75,13 +75,13 @@ def read_dict(
             print(*args, **kwargs)
 
     # set working directory:
-    l = 0
+    ld = 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)))
+            ld = max(ld, len(str(d)))
     _print("\n--------------------- Reading foxes parameter dict ---------------------")
     _print("Working directory  :", config.work_dir)
     _print("Input directory    :", config.input_dir)
@@ -95,9 +95,9 @@ def read_dict(
         else:
             states = algo.states
     else:
-        assert (
-            algo is None
-        ), f"Cannot handle both the algo and the states argument, please drop one"
+        assert algo is None, (
+            "Cannot handle both the algo and the states argument, please drop one"
+        )
 
     # create model book:
     if mbook is None:
@@ -110,7 +110,7 @@ def read_dict(
                     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)
+                        Dict(m, _name=f"{mdict.name}.s.{i}") for i, m in enumerate(mlst)
                     ]
                     for m in ms:
                         mname = m.pop_item("name")
@@ -119,19 +119,16 @@ def read_dict(
         else:
             mbook = algo.mbook
     else:
-        assert (
-            algo is None
-        ), f"Cannot handle both the algo and the mbook argument, please drop one"
+        assert algo is None, (
+            "Cannot handle both the algo and the mbook argument, please drop one"
+        )
 
     # create farm:
     if farm is None:
         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"))
-            ]
+            lyts = fdict.pop_item("layouts")
             farm = WindFarm(**fdict)
             for lyt in lyts:
                 add_fun = getattr(farm_layout, lyt.pop_item("function"))
@@ -141,9 +138,9 @@ def read_dict(
         else:
             farm = algo.farm
     else:
-        assert (
-            algo is None
-        ), f"Cannot handle both the algo and the farm argument, please drop one"
+        assert algo is None, (
+            "Cannot handle both the algo and the farm argument, please drop one"
+        )
 
     # create engine:
     engine = None
@@ -251,6 +248,7 @@ def run_obj_function(
     fdict,
     algo,
     rlabels,
+    nofig=False,
     verbosity=None,
 ):
     """
@@ -266,6 +264,8 @@ def run_obj_function(
         The algorithm
     rlabels: dict
         Storage for result variables
+    nofig: bool
+        Do not show figures, overrules settings from fdict
     verbosity: int, optional
         The verbosity level, 0 = silent
 
@@ -310,9 +310,9 @@ def run_obj_function(
     results = f(*args, **fdict)
 
     # pyplot shortcuts:
-    if plt_show:
+    if not nofig and plt_show:
         plt.show()
-    if plt_close:
+    if not nofig and plt_close:
         results = None
         plt.close()
 
@@ -321,12 +321,12 @@ def run_obj_function(
 
         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}'"
+                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
 
@@ -346,6 +346,7 @@ def run_outputs(
     point_results=None,
     extra_sig={},
     ret_rlabels=False,
+    nofig=False,
     verbosity=None,
 ):
     """
@@ -366,6 +367,8 @@ def run_outputs(
         arguments (key) with data (value)
     ret_rlabels: bool
         Flag for returning results variables
+    nofig: bool
+        Do not show figures, overrules settings from idict
     verbosity: int, optional
         The verbosity level, 0 = silent
 
@@ -387,24 +390,19 @@ def run_outputs(
             print(*args, **kwargs)
 
     out = []
-    rlabels = Dict(name="result_labels")
+    rlabels = Dict(_name="result_labels")
     if "outputs" in idict:
-        odicts = [
-            Dict(odict, name=f"{idict.name}.output{i}")
-            for i, odict in enumerate(idict["outputs"])
-        ]
+        odicts = idict["outputs"]
 
         for i, d in enumerate(odicts):
             if "output_type" in d:
+                d["nofig"] = nofig
                 ocls = d.pop_item("output_type")
                 _print(f"\nRunning 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"))
-                ]
+                flist = d.pop_item("functions")
 
                 o = get_output_obj(
                     ocls, d, algo, farm_results, point_results, extra_sig=extra_sig
@@ -419,10 +417,7 @@ def run_outputs(
                 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"))
-                ]
+                flist = d.pop_item("functions")
 
             else:
                 raise KeyError(
@@ -431,7 +426,7 @@ def run_outputs(
 
             fres = []
             for fdict in flist:
-                results = run_obj_function(o, fdict, algo, rlabels, verbosity)
+                results = run_obj_function(o, fdict, algo, rlabels, nofig, verbosity)
                 fres.append(results)
             out.append((d0, fres))
 
@@ -441,7 +436,7 @@ def run_outputs(
     return out if not ret_rlabels else out, rlabels
 
 
-def run_dict(idict, *args, verbosity=None, **kwargs):
+def run_dict(idict, *args, nofig=False, verbosity=None, **kwargs):
     """
     Runs foxes from dictionary input
 
@@ -451,6 +446,8 @@ def run_dict(idict, *args, verbosity=None, **kwargs):
         The input parameter dictionary
     args: tuple, optional
         Additional parameters for read_dict
+    nofig: bool
+        Do not show figures, overrules settings from idict
     verbosity: int, optional
         Force a verbosity level, 0 = silent, overrules
         settings from idict
@@ -480,7 +477,7 @@ def run_dict(idict, *args, verbosity=None, **kwargs):
     algo, engine = read_dict(idict, *args, verbosity=verbosity, **kwargs)
 
     # run farm calculation:
-    rdict = idict.get_item("calc_farm", Dict(name=idict.name + ".calc_farm"))
+    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)
@@ -504,7 +501,11 @@ def run_dict(idict, *args, verbosity=None, **kwargs):
         out += (point_results,)
 
     # run outputs:
-    out += (run_outputs(idict, algo, farm_results, point_results, verbosity=verbosity),)
+    out += (
+        run_outputs(
+            idict, algo, farm_results, point_results, nofig=nofig, verbosity=verbosity
+        ),
+    )
 
     # shutdown engine, if created above:
     if engine is not None:

foxes/input/yaml/windio/__init__.py

@@ -1,5 +1,10 @@
-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, read_farm
-from .read_attributes import read_attributes
+from .windio import foxes_windio as foxes_windio
+from .windio import read_windio as read_windio
+
+from .read_farm import read_layout as read_layout
+from .read_farm import read_turbine_types as read_turbine_types
+from .read_farm import read_farm as read_farm
+
+from .read_site import read_site as read_site
+from .read_fields import read_wind_resource_field as read_wind_resource_field
+from .read_attributes import read_attributes as read_attributes

foxes/input/yaml/windio/read_attributes.py

@@ -1,5 +1,5 @@
 from foxes.utils import Dict
-from foxes.core import WakeModel, WakeFrame
+from foxes.core import WakeModel, WakeDeflection
 import foxes.variables as FV
 
 
@@ -21,7 +21,7 @@ def _read_wind_deficit(
             "Bastankhah2016": "Bastankhah2016",
             "TurbOPark": "TurbOPark",
         },
-        name="wind_def_map",
+        _name="wind_def_map",
     )
 
     ws_sup_dict = Dict(
@@ -29,16 +29,18 @@ def _read_wind_deficit(
             "Linear": "ws_linear",
             "Squared": "ws_quadratic",
             "Product": "ws_product",
+            "Vector": "vector",
         },
-        name="ws_sup_dict",
+        _name="ws_sup_dict",
     )
     ws_sup_amb_dict = Dict(
         {
             "Linear": "ws_linear_amb",
             "Squared": "ws_quadratic_amb",
             "Product": "ws_product",
+            "Vector": "vector",
         },
-        name="ws_sup_dict",
+        _name="ws_sup_dict",
     )
 
     wname = wind_deficit.pop_item("name")
@@ -49,7 +51,7 @@ def _read_wind_deficit(
         print("      Eff ws  :", eff_ws)
         print("      Contents:", [k for k in wind_deficit.keys()])
     wind_def_dict = Dict(wmodel_type=wind_def_map[wname], induction=induction)
-    kcoef = Dict(wind_deficit["wake_expansion_coefficient"], name="kcoef")
+    kcoef = Dict(wind_deficit["wake_expansion_coefficient"], _name="kcoef")
     ka = kcoef["k_a"]
     kb = kcoef.get_item("k_b", 0.0)
     amb_ti = kcoef.get_item("free_stream_ti", False)
@@ -100,7 +102,7 @@ def _read_turbulence(
             "CrespoHernandez": "CrespoHernandezTIWake",
             "IEC-TI-2019": "IECTIWake",
         },
-        name="twake_def_map",
+        _name="twake_def_map",
     )
 
     ti_sup_dict = Dict(
@@ -108,7 +110,7 @@ def _read_turbulence(
             "Linear": "ti_linear",
             "Squared": "ti_quadratic",
         },
-        name="ti_sup_dict",
+        _name="ti_sup_dict",
     )
 
     wname = turbulence_model.pop_item("name")
@@ -122,7 +124,7 @@ def _read_turbulence(
             tiwake_dict["opening_angle"] = None
             tiwake_dict["iec_type"] = "2019"
         if "wake_expansion_coefficient" in turbulence_model:
-            kcoef = Dict(turbulence_model["wake_expansion_coefficient"], name="kcoef")
+            kcoef = Dict(turbulence_model["wake_expansion_coefficient"], _name="kcoef")
             ka = kcoef["k_a"]
             kb = kcoef.get_item("k_b", 0.0)
             amb_ti = kcoef.get_item("free_stream_ti", False)
@@ -156,7 +158,7 @@ def _read_blockage(blockage_model, induction, algo_dict, mbook, verbosity):
             "SelfSimilarityDeficit": "SelfSimilar",
             "SelfSimilarityDeficit2020": "SelfSimilar2020",
         },
-        name="twake_def_map",
+        _name="twake_def_map",
     )
 
     wname = blockage_model.pop_item("name")
@@ -202,7 +204,7 @@ def _read_rotor_averaging(rotor_averaging, algo_dict, verbosity):
     elif background_averaging in ["none", "None", None]:
         algo_dict["rotor_model"] = None
     elif background_averaging == "grid":
-        algo_dict["rotor_model"] = f"grid{nx*ny}"
+        algo_dict["rotor_model"] = f"grid{nx * ny}"
     else:
         algo_dict["rotor_model"] = background_averaging
 
@@ -215,7 +217,7 @@ def _read_rotor_averaging(rotor_averaging, algo_dict, verbosity):
             algo_dict["partial_wakes"] = "rotor_points"
         else:
             if grid == "grid":
-                algo_dict["partial_wakes"] = f"grid{nx*ny}"
+                algo_dict["partial_wakes"] = f"grid{nx * ny}"
             else:
                 algo_dict["partial_wakes"] = grid
     else:
@@ -230,10 +232,12 @@ def _read_deflection(deflection, induction, algo_dict, mbook, verbosity):
     """Reads deflection model"""
     defl_def_map = Dict(
         {
-            "None": "RotorWD",
-            "Batankhah2016": "YawedWakes",
+            "None": "NoDeflection",
+            "Batankhah2016": "Bastankhah2016Deflection",
+            "Jimenez": "JimenezDeflection",
+            "JimenezVector": "JimenezDeflection",
         },
-        name="defl_def_map",
+        _name="defl_def_map",
     )
 
     wname = deflection.pop_item("name")
@@ -241,15 +245,24 @@ def _read_deflection(deflection, induction, algo_dict, mbook, verbosity):
         print("    Reading deflection_model")
         print("      Name:", wname)
         print("      Contents:", [k for k in deflection.keys()])
-    indc_dict = Dict(wframe_type=defl_def_map[wname])
+    defl_dict = Dict(wdefl_type=defl_def_map[wname])
+    if wname == "Jimenez" and "rotate" not in defl_dict:
+        defl_dict["rotate"] = False
+    elif wname == "JimenezVector":
+        assert "rotate" not in defl_dict, (
+            f"Deflection model '{wname}' does not support 'rotate' parameter"
+        )
+        defl_dict["rotate"] = True
     try:
-        mbook.wake_frames[wname] = WakeFrame.new(**indc_dict, induction=induction)
+        mbook.wake_deflections[wname] = WakeDeflection.new(
+            **defl_dict, induction=induction
+        )
     except TypeError:
-        mbook.wake_frames[wname] = WakeFrame.new(**indc_dict)
+        mbook.wake_deflections[wname] = WakeDeflection.new(**defl_dict)
     if verbosity > 2:
-        print(f"      Created wake frame '{wname}':")
-        print("       ", mbook.wake_frames[wname])
-    algo_dict["wake_frame"] = wname
+        print(f"      Created wake deflection '{wname}':")
+        print("       ", mbook.wake_deflections[wname])
+    algo_dict["wake_deflection"] = wname
 
 
 def _read_analysis(wio_ana, idict, mbook, verbosity):
@@ -260,7 +273,7 @@ def _read_analysis(wio_ana, idict, mbook, verbosity):
 
     # superposition:
     superposition = Dict(
-        wio_ana["superposition_model"], name=wio_ana.name + ".superposition_model"
+        wio_ana["superposition_model"], _name=wio_ana.name + ".superposition_model"
     )
     if verbosity > 2:
         print("    Reading superposition_model")
@@ -272,7 +285,7 @@ def _read_analysis(wio_ana, idict, mbook, verbosity):
             "1D": "Betz",
             "Madsen": "Madsen",
         },
-        name="induction mapping",
+        _name="induction mapping",
     )
     induction = imap[wio_ana.get_item("axial_induction_model", "1D")]
     if verbosity > 2:
@@ -284,7 +297,7 @@ def _read_analysis(wio_ana, idict, mbook, verbosity):
     )
     algo_dict = idict["algorithm"]
     wind_deficit = Dict(
-        wio_ana[wake_model_key], name=wio_ana.name + "." + wake_model_key
+        wio_ana[wake_model_key], _name=wio_ana.name + "." + wake_model_key
     )
     ka, kb, amb_ti = _read_wind_deficit(
         wake_model_key,
@@ -298,7 +311,7 @@ def _read_analysis(wio_ana, idict, mbook, verbosity):
 
     # turbulence model:
     if "turbulence_model" in wio_ana:
-        turbulence_model = Dict(wio_ana["turbulence_model"], name="turbulence_model")
+        turbulence_model = Dict(wio_ana["turbulence_model"], _name="turbulence_model")
         _read_turbulence(
             turbulence_model,
             superposition,
@@ -315,21 +328,21 @@ def _read_analysis(wio_ana, idict, mbook, verbosity):
 
     # blockage model:
     if "blockage_model" in wio_ana:
-        blockage_model = Dict(wio_ana["blockage_model"], name="blockage_model")
+        blockage_model = Dict(wio_ana["blockage_model"], _name="blockage_model")
         _read_blockage(blockage_model, induction, algo_dict, mbook, verbosity)
     elif verbosity > 0:
         print("blockage_model not found, not using a turbine induction model")
 
     # rotor_averaging:
     if "rotor_averaging" in wio_ana:
-        rotor_averaging = Dict(wio_ana["rotor_averaging"], name="rotor_averaging")
+        rotor_averaging = Dict(wio_ana["rotor_averaging"], _name="rotor_averaging")
         _read_rotor_averaging(rotor_averaging, algo_dict, verbosity)
     elif verbosity > 0:
         print("rotor_averaging not found, using default settings")
 
     # deflection:
     if "deflection_model" in wio_ana:
-        deflection = Dict(wio_ana["deflection_model"], name="deflection_model")
+        deflection = Dict(wio_ana["deflection_model"], _name="deflection_model")
         _read_deflection(deflection, induction, algo_dict, mbook, verbosity)
     elif verbosity > 0:
         print("deflection_model not found, using default settings")
@@ -359,7 +372,7 @@ def read_attributes(wio_attrs, idict, mbook, verbosity=1):
 
     # read flow model:
     if "flow_model" in wio_attrs:
-        flow_model = Dict(wio_attrs["flow_model"], name="flow_model")
+        flow_model = Dict(wio_attrs["flow_model"], _name="flow_model")
         fmname = flow_model.pop_item("name")
         if verbosity > 2:
             print("    Reading flow_model")
@@ -369,5 +382,5 @@ def read_attributes(wio_attrs, idict, mbook, verbosity=1):
             print(f"Running flow model 'foxes', overruling original choice '{fmname}'")
 
     # read analysis:
-    wio_ana = Dict(wio_attrs["analysis"], name=wio_attrs.name + ".analysis")
+    wio_ana = Dict(wio_attrs["analysis"], _name=wio_attrs.name + ".analysis")
     _read_analysis(wio_ana, idict, mbook, verbosity)

foxes/input/yaml/windio/read_farm.py

@@ -38,7 +38,9 @@ def read_turbine_types(wio_farm, mbook, ws_exp_P, ws_exp_ct, verbosity):
             print(*args, **kwargs)
 
     if "turbine_types" not in wio_farm:
-        wio_farm["turbine_types"] = {0: wio_farm["turbines"]}
+        wio_farm["turbine_types"] = Dict(
+            {0: wio_farm["turbines"]}, _name="turbine_types"
+        )
 
     ttypes = {}
     for k, wio_trbns in wio_farm["turbine_types"].items():
@@ -49,18 +51,18 @@ def read_turbine_types(wio_farm, mbook, ws_exp_P, ws_exp_ct, verbosity):
         _print("      Contents:", [k for k in wio_trbns.keys()], level=3)
 
         # read performance:
-        performance = Dict(wio_trbns["performance"], name="performance")
+        performance = wio_trbns["performance"]
         _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")
+            power_curve = performance["power_curve"]
             _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")
+            ct_curve = performance["Ct_curve"]
             _print("            Reading Ct_curve", level=3)
             _print("              Contents:", [k for k in ct_curve.keys()], level=3)
             ct = ct_curve["Ct_values"]
@@ -77,7 +79,7 @@ def read_turbine_types(wio_farm, mbook, ws_exp_P, ws_exp_ct, verbosity):
                 return FV.REWS if wse == 1 else (FV.REWS2 if wse == 2 else FV.REWS3)
 
             _print(f"            Creating model '{tname}'", level=3)
-            _print(f"              Turbine type class: PCtFomTwo", level=3)
+            _print("              Turbine type class: PCtFomTwo", level=3)
             mbook.turbine_types[tname] = TurbineType.new(
                 ttype_type="PCtFromTwo",
                 data_source_P=data_P,
@@ -96,12 +98,12 @@ def read_turbine_types(wio_farm, mbook, ws_exp_P, ws_exp_ct, verbosity):
 
         # P, ct data:
         elif "Cp_curve" in performance:
-            cp_curve = Dict(performance["Cp_curve"], name="Cp_curve")
+            cp_curve = performance["Cp_curve"]
             _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")
+            ct_curve = performance["Ct_curve"]
             _print("            Reading Ct_curve", level=3)
             _print("              Contents:", [k for k in ct_curve.keys()], level=3)
             ct = ct_curve["Ct_values"]
@@ -111,7 +113,7 @@ def read_turbine_types(wio_farm, mbook, ws_exp_P, ws_exp_ct, verbosity):
             data_ct = pd.DataFrame(data={"ws": ws_ct, "ct": ct})
 
             _print(f"            Creating model '{tname}'", level=3)
-            _print(f"              Turbine type class: CpCtFromTwo", level=3)
+            _print("              Turbine type class: CpCtFromTwo", level=3)
             mbook.turbine_types[tname] = TurbineType.new(
                 ttype_type="CpCtFromTwo",
                 data_source_cp=data_cp,
@@ -126,7 +128,7 @@ def read_turbine_types(wio_farm, mbook, ws_exp_P, ws_exp_ct, verbosity):
             _print("               ", mbook.turbine_types[tname], level=3)
 
         else:
-            raise KeyError(f"Expecting either 'power_curve' or 'Cp_curve'")
+            raise KeyError("Expecting either 'power_curve' or 'Cp_curve'")
 
     return ttypes
 
@@ -154,10 +156,10 @@ def read_layout(lname, ldict, farm, ttypes, verbosity=1):
     """
     if verbosity > 2:
         print(f"        Reading '{lname}'")
-    cdict = Dict(ldict["coordinates"], name="coordinates")
+    cdict = ldict["coordinates"]
     tmap = ldict.get_item("turbine_types", None)
     if verbosity > 2:
-        print(f"          Turbine type map:", tmap)
+        print("          Turbine type map:", tmap)
     for i, xy in enumerate(zip(cdict["x"], cdict["y"])):
         tt = ttypes[tmap[i] if tmap is not None else 0]
         farm.add_turbine(
@@ -187,7 +189,7 @@ def read_farm(wio_dict, mbook, verbosity):
     :group: input.yaml.windio
 
     """
-    wio_farm = Dict(wio_dict["wind_farm"], name=wio_dict.name + ".wind_farm")
+    wio_farm = wio_dict["wind_farm"]
     if verbosity > 1:
         print("Reading wind farm")
         print("  Name:", wio_farm.pop_item("name", None))
@@ -209,10 +211,10 @@ def read_farm(wio_dict, mbook, verbosity):
     farm = WindFarm()
     wfarm = wio_farm["layouts"]
     if isinstance(wfarm, dict):
-        layouts = Dict(wfarm, name=wio_farm.name + ".layouts")
+        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")
+        layouts = {str(i): lf for i, lf 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()])

foxes/input/yaml/windio/read_fields.py

@@ -22,6 +22,8 @@ wio2foxes = {
     "LMO": FV.MOL,
     "z0": FV.Z0,
     "reference_height": FV.H,
+    "weibull_a": FV.WEIBULL_A,
+    "weibull_k": FV.WEIBULL_k,
 }
 
 """ Mapping from foxes to windio variables
@@ -134,8 +136,6 @@ def read_wind_resource_field(
 
     """
     if name in [
-        "weibull_a",
-        "weibull_k",
         "potential_temperature",
         "friction_velocity",
         "k",
@@ -178,6 +178,8 @@ def read_wind_resource_field(
         "LMO",
         "z0",
         "reference_height",
+        "weibull_a",
+        "weibull_k",
     ] and _read_multi_dimensional_data(name, wio_data, fields, dims):
         return True