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

examples/yawed_wake/run.py

@@ -114,93 +114,95 @@ if __name__ == "__main__":
         wake_deflection=args.deflection,
         partial_wakes=args.pwakes,
         mbook=mbook,
-        engine=args.engine,
+    )
+
+    with foxes.Engine.new(
+        engine_type=args.engine,
         n_procs=args.n_cpus,
         chunk_size_states=args.chunksize_states,
         chunk_size_points=args.chunksize_points,
-    )
+    ):
+        # calculate farm results
+        farm_results = algo.calc_farm()
+        print("\nResults data:\n", farm_results)
 
-    # calculate farm results
-    farm_results = algo.calc_farm()
-    print("\nResults data:\n", farm_results)
-
-    if not args.nofig:
-        # xy horizontal flow plot
-        print("\nHorizontal flow figure output:")
-        o = foxes.output.FlowPlots2D(algo, farm_results)
-        g = o.gen_states_fig_xy(
-            args.var, resolution=10, xmin=-500, xmax=3000, rotor_color="red"
-        )
-        fig = next(g)
-        plt.show()
-        plt.close(fig)
+        if not args.nofig:
+            # xy horizontal flow plot
+            print("\nHorizontal flow figure output:")
+            o = foxes.output.FlowPlots2D(algo, farm_results)
+            g = o.gen_states_fig_xy(
+                args.var, resolution=10, xmin=-500, xmax=3000, rotor_color="red"
+            )
+            fig = next(g)
+            plt.show()
+            plt.close(fig)
 
-        # yz flow plot
-        print("\nVertical flow figure output:")
-        o = foxes.output.FlowPlots2D(algo, farm_results)
-        g = o.gen_states_fig_yz(
-            args.var,
-            resolution=5,
-            x=750,
-            ymin=-200,
-            ymax=200,
-            zmin=0,
-            zmax=250,
-            rotor_color="red",
-            verbosity=0,
-        )
-        fig = next(g)
-        plt.show()
-        plt.close(fig)
+            # yz flow plot
+            print("\nVertical flow figure output:")
+            o = foxes.output.FlowPlots2D(algo, farm_results)
+            g = o.gen_states_fig_yz(
+                args.var,
+                resolution=5,
+                x=750,
+                ymin=-200,
+                ymax=200,
+                zmin=0,
+                zmax=250,
+                rotor_color="red",
+                verbosity=0,
+            )
+            fig = next(g)
+            plt.show()
+            plt.close(fig)
 
-    # add capacity and efficiency to farm results
-    o = foxes.output.FarmResultsEval(farm_results)
-    o.add_capacity(algo)
-    o.add_capacity(algo, ambient=True)
-    o.add_efficiency()
+        # add capacity and efficiency to farm results
+        o = foxes.output.FarmResultsEval(farm_results)
+        o.add_capacity(algo)
+        o.add_capacity(algo, ambient=True)
+        o.add_efficiency()
 
-    # state-turbine results
-    farm_df = farm_results.to_dataframe()
-    print("\nFarm results data:\n")
-    print(
-        farm_df[
-            [
-                FV.X,
-                FV.AMB_REWS,
-                FV.REWS,
-                FV.AMB_TI,
-                FV.TI,
-                FV.AMB_P,
-                FV.P,
-                FV.WD,
-                FV.YAW,
-                FV.YAWM,
+        # state-turbine results
+        farm_df = farm_results.to_dataframe()
+        print("\nFarm results data:\n")
+        print(
+            farm_df[
+                [
+                    FV.X,
+                    FV.AMB_REWS,
+                    FV.REWS,
+                    FV.AMB_TI,
+                    FV.TI,
+                    FV.AMB_P,
+                    FV.P,
+                    FV.WD,
+                    FV.YAW,
+                    FV.YAWM,
+                ]
             ]
-        ]
-    )
-    print()
+        )
+        print()
 
-    # results by turbine
-    turbine_results = o.reduce_states(
-        {
-            FV.AMB_P: "weights",
-            FV.P: "weights",
-            FV.AMB_CAP: "weights",
-            FV.CAP: "weights",
-        }
-    )
-    turbine_results[FV.AMB_YLD] = o.calc_turbine_yield(
-        algo=algo, annual=True, ambient=True
-    )
-    turbine_results[FV.YLD] = o.calc_turbine_yield(algo=algo, annual=True)
-    turbine_results[FV.EFF] = turbine_results[FV.P] / turbine_results[FV.AMB_P]
-    print("\nResults by turbine:\n")
-    print(turbine_results)
+        # results by turbine
+        turbine_results = o.reduce_states(
+            {
+                FV.AMB_P: "weights",
+                FV.P: "weights",
+                FV.AMB_CAP: "weights",
+                FV.CAP: "weights",
+            }
+        )
+        turbine_results[FV.AMB_YLD] = o.calc_turbine_yield(
+            algo=algo, annual=True, ambient=True
+        )
+        turbine_results[FV.YLD] = o.calc_turbine_yield(algo=algo, annual=True)
+        turbine_results[FV.EFF] = turbine_results[FV.P] / turbine_results[FV.AMB_P]
+        print("\nResults by turbine:\n")
+        print(turbine_results)
 
-    # power results
-    P0 = o.calc_mean_farm_power(ambient=True)
-    P = o.calc_mean_farm_power()
-    print(f"\nFarm power        : {P / 1000:.1f} MW")
-    print(f"Farm ambient power: {P0 / 1000:.1f} MW")
-    print(f"Farm efficiency   : {o.calc_farm_efficiency() * 100:.2f} %")
-    print(f"Annual farm yield : {turbine_results[FV.YLD].sum():.2f} GWh.")
+        # power results
+        P0 = o.calc_mean_farm_power(ambient=True)
+        P = o.calc_mean_farm_power()
+        print(f"\nFarm power        : {P / 1000:.1f} MW")
+        print(f"Farm ambient power: {P0 / 1000:.1f} MW")
+        print(f"Farm efficiency   : {o.calc_farm_efficiency() * 100:.2f} %")
+        print(f"Annual farm yield : {turbine_results[FV.YLD].sum():.2f} GWh.")

foxes/core/algorithm.py

@@ -912,6 +912,7 @@ class Algorithm(Model):
             isel=isel,
             **kwargs,
         )
+        self.reset_chunk_store(chunk_store)
 
         # reset to not running:
         self.unset_running(

foxes/engines/pool.py

@@ -187,6 +187,7 @@ class PoolEngine(Engine):
             The model results
 
         """
+
         # subset selection:
         model_data, farm_data, point_data = self.select_subsets(
             model_data, farm_data, point_data, sel=sel, isel=isel

foxes/input/yaml/windio/read_attributes.py

@@ -167,7 +167,13 @@ def _read_blockage(blockage_model, induction, algo_dict, mbook, verbosity):
         print("      Name:", wname)
         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)
+        kys = list(blockage_model.keys())
+        for k in kys:
+            if len(k) > 3 and k[:3] == "ss_":
+                blockage_model[k[3:]] = blockage_model.pop_item(k)
+        indc_dict = Dict(
+            wmodel_type=indc_def_map[wname], induction=induction, **blockage_model
+        )
         mbook.wake_models[wname] = WakeModel.new(**indc_dict)
         if verbosity > 2:
             print(f"      Created wake model '{wname}':")
@@ -378,7 +384,7 @@ def read_attributes(wio_attrs, idict, mbook, verbosity=1):
             print("    Reading flow_model")
             print("      Name:", fmname)
             print("      Contents:", [k for k in flow_model.keys()])
-        if fmname != "foxes":
+        if verbosity > 0 and fmname != "foxes":
             print(f"Running flow model 'foxes', overruling original choice '{fmname}'")
 
     # read analysis:

foxes/input/yaml/windio/read_farm.py

@@ -3,7 +3,9 @@ import pandas as pd
 
 from foxes.utils import Dict
 from foxes.core import Turbine, TurbineType, WindFarm
+from foxes.models.farm_controllers import BasicFarmController, OpFlagController
 import foxes.variables as FV
+import foxes.constants as FC
 
 
 def read_turbine_types(wio_farm, mbook, ws_exp_P, ws_exp_ct, verbosity):
@@ -204,6 +206,22 @@ def read_farm(wio_dict, mbook, verbosity):
         ws_exp_P = 1
         ws_exp_ct = 1
 
+    # create farm controller:
+    if FV.OPERATING in wio_farm:
+        op_dims, operating = wio_farm.pop_item(FV.OPERATING)
+        assert (
+            len(op_dims) == 2
+            and op_dims[1] == FC.TURBINE
+            and op_dims[0] in [FC.STATE, FC.TIME]
+        ), f"Expecting operating field to have dims (state, turbine), got {op_dims}"
+        mbook.farm_controllers["farm_cntrl"] = OpFlagController(operating)
+    else:
+        mbook.farm_controllers["farm_cntrl"] = BasicFarmController()
+    if verbosity > 1:
+        print(
+            f"  Farm controller type: {type(mbook.farm_controllers['farm_cntrl']).__name__}"
+        )
+
     # read turbine type:
     ttypes = read_turbine_types(wio_farm, mbook, ws_exp_P, ws_exp_ct, verbosity)
 
@@ -211,6 +229,8 @@ def read_farm(wio_dict, mbook, verbosity):
     farm = WindFarm()
     wfarm = wio_farm["layouts"]
     if isinstance(wfarm, dict):
+        if "coordinates" in wfarm:
+            wfarm = {"0": wfarm}
         layouts = Dict(wfarm, _name=wio_farm.name + ".layouts")
     else:
         layouts = {str(i): lf for i, lf in enumerate(wfarm)}

foxes/input/yaml/windio/read_fields.py

@@ -24,6 +24,7 @@ wio2foxes = {
     "reference_height": FV.H,
     "weibull_a": FV.WEIBULL_A,
     "weibull_k": FV.WEIBULL_k,
+    "operating": FV.OPERATING,
 }
 
 """ Mapping from foxes to windio variables
@@ -137,6 +138,7 @@ def read_wind_resource_field(
     """
     if name in [
         "potential_temperature",
+        "real_temperature",
         "friction_velocity",
         "k",
         "epsilon",
@@ -180,6 +182,7 @@ def read_wind_resource_field(
         "reference_height",
         "weibull_a",
         "weibull_k",
+        "operating",
     ] and _read_multi_dimensional_data(name, wio_data, fields, dims):
         return True
 

foxes/input/yaml/windio/read_outputs.py

@@ -110,14 +110,28 @@ def _read_flow_field(wio_outs, olist, algo, states_isel, verbosity):
             assert len(xb) == 2, f"Expecting two entries for x_bounds, got {xb}"
             yb = z_planes.pop_item("y_bounds")
             assert len(yb) == 2, f"Expecting two entries for y_bounds, got {yb}"
-            dx = z_planes.pop_item("dx")
-            dy = z_planes.pop_item("dy")
-            nx = max(int((xb[1] - xb[0]) / dx), 1) + 1
-            if (xb[1] - xb[0]) / (nx - 1) > dx:
-                nx += 1
-            ny = max(int((yb[1] - yb[0]) / dy), 1) + 1
-            if (yb[1] - yb[0]) / (ny - 1) > dy:
-                ny += 1
+            if "dx" in z_planes or "dy" in z_planes:
+                assert "dx" in z_planes and "dy" in z_planes, (
+                    f"Expecting both 'dx' and 'dy' in z_planes, got {list(z_planes.keys())}"
+                )
+                dx = z_planes.pop_item("dx")
+                dy = z_planes.pop_item("dy")
+                nx = max(int((xb[1] - xb[0]) / dx), 1) + 1
+                if (xb[1] - xb[0]) / (nx - 1) > dx:
+                    nx += 1
+                ny = max(int((yb[1] - yb[0]) / dy), 1) + 1
+                if (yb[1] - yb[0]) / (ny - 1) > dy:
+                    ny += 1
+            elif "Nx" in z_planes or "Ny" in z_planes:
+                assert "Nx" in z_planes and "Ny" in z_planes, (
+                    f"Expecting both 'Nx' and 'Ny' in z_planes, got {list(z_planes.keys())}"
+                )
+                nx = z_planes.pop_item("Nx")
+                ny = z_planes.pop_item("Ny")
+            else:
+                raise KeyError(
+                    f"Expecting either 'dx' and 'dy' or 'Nx' and 'Ny' in z_planes, got {list(z_planes.keys())}"
+                )
             z_list = np.asarray(z_list)
             if verbosity > 2:
                 print("          x_bounds      :", xb)
@@ -186,11 +200,10 @@ def read_outputs(wio_outs, idict, algo, verbosity=1):
 
     # read subset:
     run_configuration = wio_outs.pop_item("run_configuration", {})
+    states_isel = None
     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:
+        if not times_run.get_item("all_occurences"):
             states_isel = times_run.get_item("subset")
     elif "wind_speeds_run" in run_configuration:
         wind_speeds_run = run_configuration.get_item("wind_speeds_run")
@@ -203,7 +216,6 @@ def read_outputs(wio_outs, idict, algo, verbosity=1):
             raise NotImplementedError(
                 f"Wind speed and direction subsets are not yet supported, got {directions_run.name} {directions_run}"
             )
-        states_isel = None
 
     # read turbine_outputs:
     _read_turbine_outputs(wio_outs, olist, algo, states_isel, verbosity)

foxes/input/yaml/windio/read_site.py

@@ -11,6 +11,14 @@ import foxes.constants as FC
 from .read_fields import read_wind_resource_field
 
 
+default_values = {
+    FV.WS: 8.0,
+    FV.WD: 270.0,
+    FV.TI: 0.1,
+    FV.RHO: 1.225,
+}
+
+
 def _get_profiles(coords, fields, dims, ovars, fixval, verbosity):
     """Read ABL profiles information
     :group: input.yaml.windio
@@ -22,6 +30,8 @@ def _get_profiles(coords, fields, dims, ovars, fixval, verbosity):
                 print(
                     f"Ignoring '{FV.Z0}', since no reference_height found. No ABL profile activated."
                 )
+            fields.pop(FV.Z0)
+            dims.pop(FV.Z0)
         elif FV.MOL in fields:
             ovars.append(FV.MOL)
             fixval[FV.H] = fields[FV.H]
@@ -56,7 +66,7 @@ def _get_SingleStateStates(
 
     smap = {FV.WS: "ws", FV.WD: "wd", FV.TI: "ti", FV.RHO: "rho"}
 
-    data = {smap[v]: d for v, d in fixval.items()}
+    data = {smap[v]: fixval.get(v, default_values[v]) for v in ovars}
     for v, d in coords.items():
         if v in smap:
             data[smap[v]] = d
@@ -91,7 +101,7 @@ def _get_Timeseries(
             print("        selecting class 'Timeseries'")
 
         data = {}
-        fix = {}
+        fix = {v: fixval.get(v, default_values[v]) for v in ovars if v not in fields}
         for v, d in fields.items():
             if dims[v] == (FC.TIME,):
                 data[v] = d
@@ -99,7 +109,6 @@ def _get_Timeseries(
                 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})
 
         sdata = pd.DataFrame(index=coords[FC.TIME], data=data)
         sdata.index.name = FC.TIME
@@ -132,7 +141,7 @@ def _get_MultiHeightNCTimeseries(
             )
 
         data = {}
-        fix = {}
+        fix = {v: fixval.get(v, default_values[v]) for v in ovars if v not in fields}
         for v, d in fields.items():
             if dims[v] == (FC.TIME, FV.H):
                 data[v] = ((FC.TIME, FV.H), d)
@@ -142,7 +151,6 @@ def _get_MultiHeightNCTimeseries(
                 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})
 
         sdata = Dataset(coords=coords, data_vars=data)
         states_dict.update(
@@ -153,6 +161,7 @@ def _get_MultiHeightNCTimeseries(
                 data_source=sdata,
                 output_vars=ovars,
                 fixed_vars=fix,
+                bounds_error=False,
             )
         )
         return True
@@ -177,7 +186,7 @@ def _get_WeibullSectors(
             print("        selecting class 'WeibullSectors'")
 
         data = {}
-        fix = {}
+        fix = {v: fixval.get(v, default_values[v]) for v in ovars if v not in fields}
         c = dims[FV.WEIBULL_A][0]
         for v, d in fields.items():
             if dims[v] == (c,):
@@ -186,7 +195,6 @@ def _get_WeibullSectors(
                 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]
@@ -230,13 +238,12 @@ def _get_WeibullPointCloud(
             print("        selecting class 'WeibullPointCloud'")
 
         data = {}
-        fix = {}
+        fix = {v: fixval.get(v, default_values[v]) for v in ovars if v not in fields}
         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,
@@ -282,13 +289,12 @@ def _get_WeibullField(
             print("        selecting class 'WeibullField'")
 
         data = {}
-        fix = {}
+        fix = {v: fixval.get(v, default_values[v]) for v in ovars if v not in fields}
         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,
@@ -342,7 +348,7 @@ def get_states(coords, fields, dims, verbosity=1):
         print("      Creating states")
 
     ovars = [FV.WS, FV.WD, FV.TI, FV.RHO]
-    fixval = {FV.RHO: 1.225}
+    fixval = {}
     profiles = _get_profiles(coords, fields, dims, ovars, fixval, verbosity)
 
     states_dict = {}
@@ -421,6 +427,21 @@ def read_site(wio_dict, verbosity=1):
     dims = Dict(_name="dims")
     for n, d in wind_resource.items():
         read_wind_resource_field(n, d, coords, fields, dims, verbosity)
+
+    # special case: operating field
+    if FV.OPERATING in fields:
+        wio_dict["wind_farm"][FV.OPERATING] = (
+            dims.pop(FV.OPERATING),
+            fields.pop(FV.OPERATING),
+        )
+        if FC.TURBINE in coords:
+            if not any([FC.TURBINE in dms for dms in dims.values()]):
+                if verbosity > 2:
+                    print(
+                        f"      Removing coordinate '{FC.TURBINE}', since only relevant for operating flag"
+                    )
+                coords.pop(FC.TURBINE)
+
     if verbosity > 2:
         print("      Coords:")
         for c, d in coords.items():

foxes/input/yaml/windio/windio.py

@@ -55,6 +55,7 @@ def read_windio(wio_dict, verbosity=1):
         algorithm=Dict(
             algo_type="Downwind",
             wake_models=[],
+            farm_controller="farm_cntrl",
             _name="wio2fxs.algorithm",
             verbosity=verbosity - 3,
         ),

foxes/models/farm_controllers/__init__.py

@@ -3,3 +3,4 @@ Farm controller models.
 """
 
 from .basic import BasicFarmController as BasicFarmController
+from .op_flag import OpFlagController as OpFlagController