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

examples/sector_management/run.py

@@ -104,10 +104,6 @@ if __name__ == "__main__":
         wake_frame="rotor_wd",
         partial_wakes=args.pwakes,
         mbook=mbook,
-        engine=args.engine,
-        n_procs=args.n_cpus,
-        chunk_size_states=args.chunksize_states,
-        chunk_size_points=args.chunksize_points,
     )
 
     outputs = [
@@ -124,43 +120,49 @@ if __name__ == "__main__":
         FV.WEIGHT,
     ]
 
-    time0 = time.time()
-    farm_results = algo.calc_farm(outputs=outputs)
-    time1 = time.time()
+    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,
+    ):
+        time0 = time.time()
+        farm_results = algo.calc_farm(outputs=outputs)
+        time1 = time.time()
 
-    print("\nCalc time =", time1 - time0, "\n")
+        print("\nCalc time =", time1 - time0, "\n")
 
-    print(farm_results)
+        print(farm_results)
 
-    fr = farm_results.to_dataframe()
-    sel = fr[FV.MAX_P].dropna().index
-    fr = fr.loc[sel]
-    print(fr)
+        fr = farm_results.to_dataframe()
+        sel = fr[FV.MAX_P].dropna().index
+        fr = fr.loc[sel]
+        print(fr)
 
-    if not args.nofig:
-        fig = plt.figure(figsize=(12, 4))
-        ax1 = fig.add_subplot(121, polar=True)
-        ax2 = fig.add_subplot(122, polar=True)
+        if not args.nofig:
+            fig = plt.figure(figsize=(12, 4))
+            ax1 = fig.add_subplot(121, polar=True)
+            ax2 = fig.add_subplot(122, polar=True)
 
-        o = foxes.output.RosePlotOutput(farm_results)
-        o.get_figure(
-            16,
-            FV.P,
-            [0, 100, 1000, 2000, 4000, 5001, 7000],
-            turbine=0,
-            title="Power turbine 0",
-            fig=fig,
-            ax=ax1,
-        )
+            o = foxes.output.RosePlotOutput(farm_results)
+            o.get_figure(
+                16,
+                FV.P,
+                [0, 100, 1000, 2000, 4000, 5001, 7000],
+                turbine=0,
+                title="Power turbine 0",
+                fig=fig,
+                ax=ax1,
+            )
 
-        o = foxes.output.RosePlotOutput(farm_results)
-        o.get_figure(
-            16,
-            FV.P,
-            [0, 100, 1000, 2000, 4000, 5001, 7000],
-            turbine=1,
-            title="Power turbine 1",
-            fig=fig,
-            ax=ax2,
-        )
-        plt.show()
+            o = foxes.output.RosePlotOutput(farm_results)
+            o.get_figure(
+                16,
+                FV.P,
+                [0, 100, 1000, 2000, 4000, 5001, 7000],
+                turbine=1,
+                title="Power turbine 1",
+                fig=fig,
+                ax=ax2,
+            )
+            plt.show()

examples/states_lookup_table/run.py

@@ -117,13 +117,15 @@ if __name__ == "__main__":
         wake_frame="rotor_wd",
         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,
-    )
-
-    farm_results = algo.calc_farm()
+    ):
+        farm_results = algo.calc_farm()
 
     fr = farm_results.to_dataframe()
     print(fr[[FV.WD, FV.H, FV.AMB_REWS, FV.REWS, FV.AMB_P, FV.P, FV.CT, FV.WEIGHT]])

examples/streamline_wakes/run.py

@@ -97,7 +97,7 @@ if __name__ == "__main__":
         mbook.turbine_models["set_yawm"].add_var(FV.YAWM, yawm)
         ymodels = ["set_yawm"]
 
-    states = foxes.input.states.FieldDataNC(
+    states = foxes.input.states.FieldData(
         args.file_pattern,
         states_coord="state",
         x_coord="x",
@@ -108,7 +108,7 @@ if __name__ == "__main__":
         var2ncvar={FV.WS: "ws", FV.WD: "wd"},
         fixed_vars={FV.RHO: 1.225, FV.TI: 0.1},
         load_mode=args.load_mode,
-        bounds_error=False,
+        interpn_pars=dict(bounds_error=False),
     )
 
     farm = foxes.WindFarm()
@@ -129,15 +129,17 @@ 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,
-    )
-
-    time0 = time.time()
-    farm_results = algo.calc_farm()
-    time1 = time.time()
+    ):
+        time0 = time.time()
+        farm_results = algo.calc_farm()
+        time1 = time.time()
 
     print("\nCalc time =", time1 - time0, "\n")
 

examples/timelines/run.py

@@ -173,119 +173,121 @@ if __name__ == "__main__":
         wake_deflection=args.deflection,
         partial_wakes=args.pwakes,
         mbook=mbook,
-        engine=args.engine,
-        n_procs=args.n_cpus,
-        chunk_size_states=args.chunksize_states,
-        chunk_size_points=args.chunksize_points,
         verbosity=1,
     )
 
-    time0 = time.time()
-    farm_results = algo.calc_farm()
-    time1 = time.time()
+    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,
+    ):
+        time0 = time.time()
+        farm_results = algo.calc_farm()
+        time1 = time.time()
 
-    print("\nCalc time =", time1 - time0, "\n")
+        print("\nCalc time =", time1 - time0, "\n")
 
-    o = foxes.output.FarmResultsEval(farm_results)
-    o.add_capacity(algo)
-    o.add_capacity(algo, ambient=True)
-    o.add_efficiency()
+        o = foxes.output.FarmResultsEval(farm_results)
+        o.add_capacity(algo)
+        o.add_capacity(algo, ambient=True)
+        o.add_efficiency()
 
-    print("\nFarm results:\n")
-    print(farm_results)
+        print("\nFarm results:\n")
+        print(farm_results)
 
-    # state-turbine results
-    farm_df = farm_results.to_dataframe()
-    print("\nFarm results data:\n")
-    print(
-        farm_df[
-            [
-                FV.X,
-                FV.Y,
-                FV.WD,
-                FV.AMB_REWS,
-                FV.REWS,
-                FV.AMB_TI,
-                FV.TI,
-                FV.AMB_P,
-                FV.P,
-                FV.EFF,
+        # state-turbine results
+        farm_df = farm_results.to_dataframe()
+        print("\nFarm results data:\n")
+        print(
+            farm_df[
+                [
+                    FV.X,
+                    FV.Y,
+                    FV.WD,
+                    FV.AMB_REWS,
+                    FV.REWS,
+                    FV.AMB_TI,
+                    FV.TI,
+                    FV.AMB_P,
+                    FV.P,
+                    FV.EFF,
+                ]
             ]
-        ]
-    )
-    print()
-    print(farm_df[[FV.AMB_REWS, FV.REWS, FV.CT, FV.EFF]].describe())
+        )
+        print()
+        print(farm_df[[FV.AMB_REWS, FV.REWS, FV.CT, FV.EFF]].describe())
 
-    # 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} %")
+        # 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} %")
 
-    if not args.nofig:
-        sts = np.arange(farm_results.sizes["state"])
-        plt.plot(sts, farm_results.REWS[:, 4], label="Turbine 4")
-        plt.plot(sts, farm_results.REWS[:, 7], label="Turbine 7")
-        plt.legend()
-        plt.xlabel("State")
-        plt.ylabel("REWS [m/s]")
-        plt.show()
+        if not args.nofig:
+            sts = np.arange(farm_results.sizes["state"])
+            plt.plot(sts, farm_results.REWS[:, 4], label="Turbine 4")
+            plt.plot(sts, farm_results.REWS[:, 7], label="Turbine 7")
+            plt.legend()
+            plt.xlabel("State")
+            plt.ylabel("REWS [m/s]")
+            plt.show()
 
-    if not args.nofig and args.animation:
-        print("\nCalculating animation")
+        if not args.nofig and args.animation:
+            print("\nCalculating animation")
 
-        fig, axs = plt.subplots(
-            2, 1, figsize=(5.2, 7), gridspec_kw={"height_ratios": [3, 1]}
-        )
+            fig, axs = plt.subplots(
+                2, 1, figsize=(5.2, 7), gridspec_kw={"height_ratios": [3, 1]}
+            )
 
-        anim = foxes.output.Animator(fig)
-        of = foxes.output.FlowPlots2D(algo, farm_results)
-        anim.add_generator(
-            of.gen_states_fig_xy(
-                FV.WS,
-                resolution=30,
-                quiver_pars=dict(angles="xy", scale_units="xy", scale=0.013),
-                quiver_n=35,
-                xmax=5000,
-                ymax=5000,
-                vmin=0,
-                fig=fig,
-                ax=axs[0],
-                ret_im=True,
-                title=None,
-                animated=True,
-                rotor_color="red",
+            anim = foxes.output.Animator(fig)
+            of = foxes.output.FlowPlots2D(algo, farm_results)
+            anim.add_generator(
+                of.gen_states_fig_xy(
+                    FV.WS,
+                    resolution=30,
+                    quiver_pars=dict(angles="xy", scale_units="xy", scale=0.013),
+                    quiver_n=35,
+                    xmax=5000,
+                    ymax=5000,
+                    vmin=0,
+                    fig=fig,
+                    ax=axs[0],
+                    ret_im=True,
+                    title=None,
+                    animated=True,
+                    rotor_color="red",
+                )
             )
-        )
-        anim.add_generator(
-            o.gen_stdata(
-                turbines=[4, 7],
-                variable=FV.REWS,
-                fig=fig,
-                ax=axs[1],
-                ret_im=True,
-                legloc="upper left",
-                animated=True,
+            anim.add_generator(
+                o.gen_stdata(
+                    turbines=[4, 7],
+                    variable=FV.REWS,
+                    fig=fig,
+                    ax=axs[1],
+                    ret_im=True,
+                    legloc="upper left",
+                    animated=True,
+                )
             )
-        )
 
-        ani = anim.animate()
+            ani = anim.animate()
 
-        lo = foxes.output.FarmLayoutOutput(farm)
-        lo.get_figure(
-            fig=fig,
-            ax=axs[0],
-            title="",
-            annotate=1,
-            anno_delx=-120,
-            anno_dely=-60,
-            alpha=0,
-        )
+            lo = foxes.output.FarmLayoutOutput(farm)
+            lo.get_figure(
+                fig=fig,
+                ax=axs[0],
+                title="",
+                annotate=1,
+                anno_delx=-120,
+                anno_dely=-60,
+                alpha=0,
+            )
 
-        fpath = Path(args.ani_file)
-        print("Writing file", fpath)
-        if fpath.suffix == ".gif":
-            ani.save(filename=fpath, writer="pillow", fps=args.fps)
-        else:
-            ani.save(filename=fpath, writer="ffmpeg", fps=args.fps)
+            fpath = Path(args.ani_file)
+            print("Writing file", fpath)
+            if fpath.suffix == ".gif":
+                ani.save(filename=fpath, writer="pillow", fps=args.fps)
+            else:
+                ani.save(filename=fpath, writer="ffmpeg", fps=args.fps)

examples/timeseries/run.py

@@ -99,15 +99,6 @@ if __name__ == "__main__":
         plt.show()
         plt.close(ax.get_figure())
 
-    engine = foxes.Engine.new(
-        args.engine,
-        n_procs=args.n_cpus,
-        chunk_size_states=args.chunksize_states,
-        chunk_size_points=args.chunksize_points,
-        verbosity=1,
-    )
-    engine.initialize()
-
     Algo = foxes.algorithms.Iterative if args.iterative else foxes.algorithms.Downwind
     algo = Algo(
         farm,
@@ -120,71 +111,75 @@ if __name__ == "__main__":
         verbosity=1,
     )
 
-    time0 = time.time()
-    farm_results = algo.calc_farm()
-    time1 = time.time()
-
-    print("\nFarm results:\n")
-    print(farm_results)
-
-    print("\nCalc time =", time1 - time0, "\n")
-
-    o = foxes.output.FarmResultsEval(farm_results)
-    o.add_capacity(algo)
-    o.add_capacity(algo, ambient=True)
-    o.add_efficiency()
-
-    print("\nFarm results:\n")
-    print(farm_results)
-
-    # state-turbine results
-    farm_df = farm_results.to_dataframe()
-    print("\nFarm results data:\n")
-    print(
-        farm_df[
-            [
-                FV.X,
-                FV.WD,
-                FV.AMB_REWS,
-                FV.REWS,
-                FV.AMB_TI,
-                FV.TI,
-                FV.AMB_P,
-                FV.P,
-                FV.EFF,
+    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,
+    ):
+        time0 = time.time()
+        farm_results = algo.calc_farm()
+        time1 = time.time()
+
+        print("\nFarm results:\n")
+        print(farm_results)
+
+        print("\nCalc time =", time1 - time0, "\n")
+
+        o = foxes.output.FarmResultsEval(farm_results)
+        o.add_capacity(algo)
+        o.add_capacity(algo, ambient=True)
+        o.add_efficiency()
+
+        print("\nFarm results:\n")
+        print(farm_results)
+
+        # state-turbine results
+        farm_df = farm_results.to_dataframe()
+        print("\nFarm results data:\n")
+        print(
+            farm_df[
+                [
+                    FV.X,
+                    FV.WD,
+                    FV.AMB_REWS,
+                    FV.REWS,
+                    FV.AMB_TI,
+                    FV.TI,
+                    FV.AMB_P,
+                    FV.P,
+                    FV.EFF,
+                ]
             ]
-        ]
-    )
-    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)
-
-    # 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")
-
-    engine.finalize()
-
-    if not args.nofig:
-        o = foxes.output.StateTurbineMap(farm_results)
-        ax = o.plot_map(FV.P, cmap="inferno", figsize=(6, 7))
-        plt.show()
+        )
+        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)
+
+        # 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")
+
+        if not args.nofig:
+            o = foxes.output.StateTurbineMap(farm_results)
+            ax = o.plot_map(FV.P, cmap="inferno", figsize=(6, 7))
+            plt.show()

examples/wind_rose/run.py

@@ -105,37 +105,39 @@ if __name__ == "__main__":
         wake_frame="rotor_wd",
         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,
-    )
+    ):
+        if not args.nofig:
+            o = foxes.output.StatesRosePlotOutput(states, point=[0.0, 0.0, 100.0])
+            o.get_figure(16, FV.AMB_WS, [0, 3.5, 6, 10, 15, 20], add_inf=True)
+            plt.show()
 
-    if not args.nofig:
-        o = foxes.output.StatesRosePlotOutput(states, point=[0.0, 0.0, 100.0])
-        o.get_figure(16, FV.AMB_WS, [0, 3.5, 6, 10, 15, 20], add_inf=True)
-        plt.show()
-
-    time0 = time.time()
-    farm_results = algo.calc_farm()
-    time1 = time.time()
+        time0 = time.time()
+        farm_results = algo.calc_farm()
+        time1 = time.time()
 
-    print("\nCalc time =", time1 - time0, "\n")
+        print("\nCalc time =", time1 - time0, "\n")
 
-    print(farm_results)
+        print(farm_results)
 
-    fr = farm_results.to_dataframe()
-    print(fr[[FV.WD, FV.H, FV.AMB_REWS, FV.REWS, FV.AMB_P, FV.P, FV.WEIGHT]])
+        fr = farm_results.to_dataframe()
+        print(fr[[FV.WD, FV.H, FV.AMB_REWS, FV.REWS, FV.AMB_P, FV.P, FV.WEIGHT]])
 
-    o = foxes.output.FarmResultsEval(farm_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 : {o.calc_farm_yield(algo=algo):.2f} GWh")
+        o = foxes.output.FarmResultsEval(farm_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 : {o.calc_farm_yield(algo=algo):.2f} GWh")
 
-    if not args.nofig and args.calc_mean:
-        o = foxes.output.FlowPlots2D(algo, farm_results)
-        fig = o.get_mean_fig_xy(FV.WS, resolution=30)
-        plt.show()
+        if not args.nofig and args.calc_mean:
+            o = foxes.output.FlowPlots2D(algo, farm_results)
+            fig = o.get_mean_fig_xy(FV.WS, resolution=30)
+            plt.show()