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

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

@@ -159,6 +159,162 @@ def _get_MultiHeightNCTimeseries(
     return False
 
 
+def _get_WeibullSectors(
+    coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
+):
+    """Try to generate Weibull sector parameters
+    :group: input.yaml.windio
+    """
+    if (
+        FV.WEIBULL_A in fields
+        and FV.WEIBULL_k in fields
+        and "sector_probability" in fields
+        and len(dims[FV.WEIBULL_A]) == 1
+        and len(dims[FV.WEIBULL_k]) == 1
+        and len(dims["sector_probability"]) == 1
+    ):
+        if verbosity > 2:
+            print("        selecting class 'WeibullSectors'")
+
+        data = {}
+        fix = {}
+        c = dims[FV.WEIBULL_A][0]
+        for v, d in fields.items():
+            if dims[v] == (c,):
+                data[v] = d
+            elif len(dims[v]) == 0:
+                fix[v] = d
+            elif verbosity > 2:
+                print(f"        ignoring field '{v}' with dims {dims[v]}")
+        fix.update({v: d for v, d in fixval.items() if v not in data})
+
+        if FV.WD in coords:
+            data[FV.WD] = coords[FV.WD]
+
+        sdata = pd.DataFrame(index=range(len(fields[FV.WEIBULL_A])), data=data)
+        sdata.index.name = "sector"
+        states_dict.update(
+            dict(
+                states_type="WeibullSectors",
+                data_source=sdata,
+                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,
+                profiles=profiles,
+            )
+        )
+        return True
+    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
@@ -186,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 = {}
@@ -200,6 +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:
@@ -232,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(f"Reading windio data")
+    _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,
     )

foxes/models/__init__.py

@@ -2,18 +2,19 @@
 Model collection.
 """
 
-from . import turbine_types
-from . import rotor_models
-from . import turbine_models
-from . import farm_models
-from . import partial_wakes
-from . import wake_frames
-from . import wake_models
-from . import wake_superpositions
-from . import farm_controllers
-from . import vertical_profiles
-from . import point_models
-from . import axial_induction
-from . import ground_models
+from . import turbine_types as turbine_types
+from . import rotor_models as rotor_models
+from . import turbine_models as turbine_models
+from . import farm_models as farm_models
+from . import partial_wakes as partial_wakes
+from . import wake_frames as wake_frames
+from . import wake_models as wake_models
+from . import wake_deflections as wake_deflections
+from . import wake_superpositions as wake_superpositions
+from . import farm_controllers as farm_controllers
+from . import vertical_profiles as vertical_profiles
+from . import point_models as point_models
+from . import axial_induction as axial_induction
+from . import ground_models as ground_models
 
-from .model_book import ModelBook
+from .model_book import ModelBook as ModelBook

foxes/models/axial_induction/__init__.py

@@ -1,2 +1,2 @@
-from .betz import BetzAxialInduction
-from .madsen import MadsenAxialInduction
+from .betz import BetzAxialInduction as BetzAxialInduction
+from .madsen import MadsenAxialInduction as MadsenAxialInduction

foxes/models/farm_controllers/__init__.py

@@ -2,4 +2,4 @@
 Farm controller models.
 """
 
-from .basic import BasicFarmController
+from .basic import BasicFarmController as BasicFarmController

foxes/models/farm_models/__init__.py

@@ -2,4 +2,4 @@
 Farm models.
 """
 
-from .turbine2farm import Turbine2FarmModel
+from .turbine2farm import Turbine2FarmModel as Turbine2FarmModel

foxes/models/ground_models/__init__.py

@@ -1,2 +1,3 @@
-from .no_ground import NoGround
-from .wake_mirror import WakeMirror, GroundMirror
+from .no_ground import NoGround as NoGround
+from .wake_mirror import WakeMirror as WakeMirror
+from .wake_mirror import GroundMirror as GroundMirror

foxes/models/ground_models/wake_mirror.py

@@ -75,13 +75,14 @@ class WakeMirror(GroundModel):
         # assert(np.all(fdata[FV.H]==fdata[FV.TXYH[..., 2]]))
 
         # contribution from main wake:
-        wcoos = algo.wake_frame.get_wake_coos(algo, mdata, fdata, tdata, downwind_index)
+        wcoos = algo.wake_frame.get_wake_coos(
+            algo, mdata, fdata, tdata, downwind_index, wmodel
+        )
         wmodel.contribute(algo, mdata, fdata, tdata, downwind_index, wcoos, wake_deltas)
 
         # contribution from mirrors:
         tdata[FC.TARGETS] = tdata[FC.TARGETS].copy()  # making sure this is no ref
         for h in self.heights:
-
             fdata[FV.TXYH][:, downwind_index, 2] = hh + 2 * (h - hh)
 
             pwake.contribute(
@@ -136,7 +137,6 @@ class WakeMirror(GroundModel):
         # contribution from mirrors:
         tdata[FC.TARGETS] = tdata[FC.TARGETS].copy()  # making sure this is no ref
         for h in self.heights:
-
             fdata[FV.TXYH][:, downwind_index, 2] = hh + 2 * (h - hh)
 
             wcoos = algo.wake_frame.get_wake_coos(