foxes 1.4__py3-none-any.whl → 1.5.1__py3-none-any.whl

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")
@@ -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"]
@@ -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"]
@@ -154,7 +156,7 @@ 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("          Turbine type map:", tmap)
@@ -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): lf for i, lf in enumerate(wfarm)}
-        layouts = Dict(layouts, name=wio_farm.name + ".layouts")
+        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_outputs.py

@@ -12,9 +12,7 @@ def _read_turbine_outputs(wio_outs, olist, algo, states_isel, verbosity):
     if "turbine_outputs" in wio_outs and wio_outs["turbine_outputs"].get_item(
         "report", True
     ):
-        turbine_outputs = Dict(
-            wio_outs["turbine_outputs"], name=wio_outs.name + ".turbine_outputs"
-        )
+        turbine_outputs = wio_outs["turbine_outputs"]
         turbine_nc_filename = turbine_outputs.pop_item(
             "turbine_nc_filename", "turbine_outputs.nc"
         )
@@ -27,6 +25,7 @@ def _read_turbine_outputs(wio_outs, olist, algo, states_isel, verbosity):
         vmap = Dict(
             power=FV.P,
             rotor_effective_velocity=FV.REWS,
+            _name="vmap",
         )
         ivmap = {d: k for k, d in vmap.items()}
         ivmap.update(
@@ -56,7 +55,7 @@ def _read_turbine_outputs(wio_outs, olist, algo, states_isel, verbosity):
                         verbosity=verbosity,
                     )
                 ],
-                name=f"outputs.output{len(olist)}.StateTurbineTable",
+                _name=f"outputs.{len(olist)}.StateTurbineTable",
             )
         )
 
@@ -64,13 +63,11 @@ def _read_turbine_outputs(wio_outs, olist, algo, states_isel, verbosity):
 def _read_flow_field(wio_outs, olist, algo, states_isel, verbosity):
     """Reads the flow field request"""
     if "flow_field" in wio_outs and wio_outs["flow_field"].get_item("report", True):
-        flow_field = Dict(wio_outs["flow_field"], name=wio_outs.name + ".flow_field")
+        flow_field = wio_outs["flow_field"]
         flow_nc_filename = flow_field.pop_item("flow_nc_filename", "flow_field.nc")
         output_variables = flow_field.pop_item("output_variables")
 
-        z_planes = Dict(
-            flow_field.pop_item("z_planes"), name=flow_field.name + ".z_planes"
-        )
+        z_planes = flow_field.pop_item("z_planes")
         z_sampling = z_planes["z_sampling"]
         xy_sampling = z_planes["xy_sampling"]
 
@@ -85,6 +82,7 @@ def _read_flow_field(wio_outs, olist, algo, states_isel, verbosity):
         vmap = Dict(
             wind_speed=FV.WS,
             wind_direction=FV.WD,
+            _name="vmap",
         )
 
         z_list = []
@@ -147,7 +145,7 @@ def _read_flow_field(wio_outs, olist, algo, states_isel, verbosity):
                             verbosity=verbosity,
                         )
                     ],
-                    name=f"outputs.output{len(olist)}.SliceData",
+                    _name=f"outputs.output{len(olist)}.SliceData",
                 )
             )
         else:
@@ -187,13 +185,25 @@ def read_outputs(wio_outs, idict, algo, verbosity=1):
         print("    Contents  :", [k for k in wio_outs.keys()])
 
     # read subset:
-    cases_run = Dict(
-        wio_outs.pop_item("cases_run", {}), name=wio_outs.name + ".cases_run"
-    )
-    if cases_run.pop_item("all_occurences"):
+    run_configuration = wio_outs.pop_item("run_configuration", {})
+    if "times_run" in run_configuration:
+        times_run = run_configuration.pop_item("times_run")
+        if times_run.get_item("all_occurences"):
+            states_isel = None
+        else:
+            states_isel = times_run.get_item("subset")
+    elif "wind_speeds_run" in run_configuration:
+        wind_speeds_run = run_configuration.get_item("wind_speeds_run")
+        directions_run = run_configuration.get_item("directions_run")
+        if not wind_speeds_run.get_item("all_values"):
+            raise NotImplementedError(
+                f"Wind speed and direction subsets are not yet supported, got {wind_speeds_run.name} {wind_speeds_run}"
+            )
+        if not directions_run.get_item("all_values"):
+            raise NotImplementedError(
+                f"Wind speed and direction subsets are not yet supported, got {directions_run.name} {directions_run}"
+            )
         states_isel = None
-    else:
-        states_isel = cases_run.pop_item("subset")
 
     # read turbine_outputs:
     _read_turbine_outputs(wio_outs, olist, algo, states_isel, verbosity)

foxes/input/yaml/windio/read_site.py

@@ -197,7 +197,7 @@ def _get_WeibullSectors(
             dict(
                 states_type="WeibullSectors",
                 data_source=sdata,
-                ws_bins=coords.get(FV.WS, np.arange(30)),
+                ws_bins=np.arange(60) / 2 if FV.WS not in sdata else None,
                 output_vars=ovars,
                 var2ncvar={FV.WEIGHT: "sector_probability"},
                 fixed_vars=fix,
@@ -208,6 +208,113 @@ def _get_WeibullSectors(
     return False
 
 
+def _get_WeibullPointCloud(
+    coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
+):
+    """Try to generate Weibull sector parameters
+    :group: input.yaml.windio
+    """
+    if (
+        FV.WD in coords
+        and FV.WEIBULL_A in fields
+        and FV.WEIBULL_k in fields
+        and "sector_probability" in fields
+        and FV.X in fields
+        and FV.Y in fields
+        and len(dims[FV.X]) == 1
+        and dims[FV.X] == dims[FV.Y]
+        and dims[FV.X][0] != FV.WD
+        and dims[FV.X][0] in coords
+    ):
+        if verbosity > 2:
+            print("        selecting class 'WeibullPointCloud'")
+
+        data = {}
+        fix = {}
+        for v, d in fields.items():
+            if len(dims[v]) == 0:
+                fix[v] = d
+            elif v not in fixval:
+                data[v] = (dims[v], d)
+        fix.update({v: d for v, d in fixval.items() if v not in data})
+
+        sdata = Dataset(
+            coords=coords,
+            data_vars=data,
+        )
+
+        states_dict.update(
+            dict(
+                states_type="WeibullPointCloud",
+                data_source=sdata,
+                output_vars=ovars,
+                var2ncvar={},
+                fixed_vars=fix,
+                point_coord=dims[FV.X][0],
+                wd_coord=FV.WD,
+                ws_coord=FV.WS if FV.WS in sdata.coords else None,
+                ws_bins=np.arange(60) / 2 if FV.WS not in sdata else None,
+                x_ncvar=FV.X,
+                y_ncvar=FV.Y,
+                h_ncvar=FV.H if FV.H in sdata.data_vars else None,
+                weight_ncvar="sector_probability",
+            )
+        )
+        return True
+    return False
+
+
+def _get_WeibullField(
+    coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
+):
+    """Try to generate Weibull sector parameters
+    :group: input.yaml.windio
+    """
+    if (
+        FV.WD in coords
+        and FV.X in coords
+        and FV.Y in coords
+        and FV.WEIBULL_A in fields
+        and FV.WEIBULL_k in fields
+        and "sector_probability" in fields
+    ):
+        if verbosity > 2:
+            print("        selecting class 'WeibullField'")
+
+        data = {}
+        fix = {}
+        for v, d in fields.items():
+            if len(dims[v]) == 0:
+                fix[v] = d
+            elif v not in fixval:
+                data[v] = (dims[v], d)
+        fix.update({v: d for v, d in fixval.items() if v not in data})
+
+        sdata = Dataset(
+            coords=coords,
+            data_vars=data,
+        )
+
+        states_dict.update(
+            dict(
+                states_type="WeibullField",
+                data_source=sdata,
+                output_vars=ovars,
+                wd_coord=FV.WD,
+                x_coord=FV.X,
+                y_coord=FV.Y,
+                h_coord=FV.H if FV.H in sdata.coords else None,
+                weight_ncvar="sector_probability",
+                var2ncvar={},
+                fixed_vars=fix,
+                ws_bins=np.arange(60) / 2 if FV.WS not in sdata.coords else None,
+                ws_coord=FV.WS if FV.WS in sdata.coords else None,
+            )
+        )
+        return True
+    return False
+
+
 def get_states(coords, fields, dims, verbosity=1):
     """
     Reads states parameters from windio input
@@ -235,7 +342,7 @@ def get_states(coords, fields, dims, verbosity=1):
         print("      Creating states")
 
     ovars = [FV.WS, FV.WD, FV.TI, FV.RHO]
-    fixval = {FV.TI: 0.05, FV.RHO: 1.225}
+    fixval = {FV.RHO: 1.225}
     profiles = _get_profiles(coords, fields, dims, ovars, fixval, verbosity)
 
     states_dict = {}
@@ -249,9 +356,15 @@ def get_states(coords, fields, dims, verbosity=1):
         or _get_MultiHeightNCTimeseries(
             coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
         )
+        or _get_WeibullPointCloud(
+            coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
+        )
         or _get_WeibullSectors(
             coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
         )
+        or _get_WeibullField(
+            coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
+        )
     ):
         return States.new(**states_dict)
     else:
@@ -284,32 +397,28 @@ def read_site(wio_dict, verbosity=1):
         if verbosity >= level:
             print(*args, **kwargs)
 
-    wio_site = Dict(wio_dict["site"], name=wio_dict.name + ".site")
+    wio_site = wio_dict["site"]
     _print("Reading site")
     _print("  Name:", wio_site.pop_item("name", None))
     _print("  Contents:", [k for k in wio_site.keys()])
     _print("  Ignoring boundaries", level=2)
 
     # read energy_resource:
-    energy_resource = Dict(
-        wio_site["energy_resource"], name=wio_site.name + ".energy_resource"
-    )
+    energy_resource = wio_site["energy_resource"]
     _print("  Reading energy_resource", level=2)
     _print("    Name:", energy_resource.pop_item("name", None), level=2)
     _print("    Contents:", [k for k in energy_resource.keys()], level=2)
 
     # read wind_resource:
-    wind_resource = Dict(
-        energy_resource["wind_resource"], name=energy_resource.name + ".wind_resource"
-    )
+    wind_resource = energy_resource["wind_resource"]
     _print("    Reading wind_resource", level=3)
     _print("      Name:", wind_resource.pop_item("name", None), level=3)
     _print("      Contents:", [k for k in wind_resource.keys()], level=3)
 
     # read fields
-    coords = Dict(name="coords")
-    fields = Dict(name="fields")
-    dims = Dict(name="dims")
+    coords = Dict(_name="coords")
+    fields = Dict(_name="fields")
+    dims = Dict(_name="dims")
     for n, d in wind_resource.items():
         read_wind_resource_field(n, d, coords, fields, dims, verbosity)
     if verbosity > 2:

foxes/input/yaml/windio/windio.py

@@ -41,40 +41,52 @@ def read_windio(wio_dict, verbosity=1):
             print(*args, **kwargs)
 
     if not isinstance(wio_dict, Dict):
-        wio_dict = Dict(wio_dict, name="windio")
+        tmp = Dict(_name="windio")
+        for k, d in wio_dict.items():
+            tmp[k] = d
+        wio_dict = tmp
 
     _print("Reading windio data")
     _print("  Name:", wio_dict.pop_item("name", None))
     _print("  Contents:", [k for k in wio_dict.keys()])
 
     idict = Dict(
-        wind_farm=Dict(name="wio2fxs.farm"),
+        wind_farm=Dict(_name="wio2fxs.farm"),
         algorithm=Dict(
             algo_type="Downwind",
             wake_models=[],
-            name="wio2fxs.algorithm",
+            _name="wio2fxs.algorithm",
             verbosity=verbosity - 3,
         ),
-        calc_farm=Dict(run=True, name="wio2fxs.calc_farm"),
-        name="wio2fxs",
+        calc_farm=Dict(run=True, _name="wio2fxs.calc_farm"),
+        _name="wio2fxs",
     )
 
     mbook = ModelBook()
     states = read_site(wio_dict, verbosity)
     farm = read_farm(wio_dict, mbook, verbosity)
 
-    wio_attrs = Dict(wio_dict["attributes"], name=wio_dict.name + ".attributes")
+    wio_attrs = wio_dict["attributes"]
     read_attributes(wio_attrs, idict, mbook, verbosity=verbosity)
 
+    # special case WeibullPointCloud:
+    if (
+        type(states).__name__ == "WeibullPointCloud"
+        and idict["algorithm"]["rotor_model"] == "centre"
+    ):
+        _print(
+            "Found WeibullPointCloud states, changing rotor model from 'centre' to 'direct_mdata'",
+            level=3,
+        )
+        idict["algorithm"]["rotor_model"] = "direct_mdata"
+
     algo = Algorithm.new(
         farm=farm, states=states, mbook=mbook, **idict.pop_item("algorithm")
     )
 
     odir = None
     if "model_outputs_specification" in wio_attrs:
-        outputs = Dict(
-            wio_attrs["model_outputs_specification"], name=wio_attrs.name + ".outputs"
-        )
+        outputs = wio_attrs["model_outputs_specification"]
         odir = read_outputs(outputs, idict, algo, verbosity=verbosity)
 
     return idict, algo, odir
@@ -171,7 +183,7 @@ def foxes_windio():
         conda_hint="",
     )
 
-    wio = Dict(yml_utils.load_yaml(wio_file), name="windio")
+    wio = Dict(yml_utils.load_yaml(wio_file), _name="windio")
     idict, algo, odir = read_windio(wio, verbosity=args.verbosity)
 
     if args.output_dir is not None:

foxes/input/yaml/yaml.py

@@ -99,5 +99,6 @@ def foxes_yaml():
         iterative=args.iterative,
         input_dir=fpath.parent,
         output_dir=args.output_dir,
+        nofig=args.nofig,
         verbosity=args.verbosity,
     )