foxes 1.5__tar.gz → 1.5.1__tar.gz

{foxes-1.5/foxes.egg-info → foxes-1.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: foxes
-Version: 1.5
+Version: 1.5.1
 Summary: Farm Optimization and eXtended yield Evaluation Software
 Author: Jonas Schulte
 Maintainer: Jonas Schulte

{foxes-1.5 → foxes-1.5.1}/examples/abl_states/run.py

@@ -91,70 +91,72 @@ 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,
-    )
-
-    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]])
+        fr = farm_results.to_dataframe()
+        print(fr[[FV.WD, FV.H, FV.AMB_REWS, FV.REWS, FV.AMB_P, FV.P]])
 
-    o = foxes.output.FarmResultsEval(farm_results)
-    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 = 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.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.WD,
+                    FV.AMB_REWS,
+                    FV.REWS,
+                    FV.AMB_TI,
+                    FV.TI,
+                    FV.AMB_P,
+                    FV.P,
+                    FV.EFF,
+                ]
             ]
-        ]
-    )
-    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():.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():.2f}")
+        print(f"Annual farm yield : {turbine_results[FV.YLD].sum():.2f} GWh.")

{foxes-1.5 → foxes-1.5.1}/examples/dyn_wakes/run.py

@@ -182,14 +182,6 @@ if __name__ == "__main__":
         plt.show()
         plt.close(ax.get_figure())
 
-    engine = foxes.Engine.new(
-        engine_type=args.engine,
-        n_procs=args.n_cpus,
-        chunk_size_states=args.chunksize_states,
-        chunk_size_points=args.chunksize_points,
-    )
-    engine.initialize()
-
     algo = foxes.algorithms.Iterative(
         farm,
         states=states,
@@ -204,131 +196,131 @@ if __name__ == "__main__":
         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())
-
-    # 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} %")
-
-    engine.finalize()
-
-    if not args.nofig:
-        sts = np.arange(farm_results.sizes["state"])
-        plt.plot(sts, farm_results.REWS[:, 1], label="Turbine 1")
-        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()
-        plt.close()
-
-    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]}
         )
+        print()
+        print(farm_df[[FV.AMB_REWS, FV.REWS, FV.CT, FV.EFF]].describe())
 
-        engine.initialize()
+        # 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} %")
 
-        of = foxes.output.FlowPlots2D(algo, farm_results)
-        ofg = 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,
-            precalc=True,
-            rotor_color="red",
-        )
-        next(ofg)
+        if not args.nofig:
+            sts = np.arange(farm_results.sizes["state"])
+            plt.plot(sts, farm_results.REWS[:, 1], label="Turbine 1")
+            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()
+            plt.close()
 
-        engine.finalize()
+        if not args.nofig and args.animation:
+            print("\nCalculating animation")
 
-        anim = foxes.output.Animator(fig)
-        anim.add_generator(ofg)
-        anim.add_generator(
-            o.gen_stdata(
-                turbines=[1, 4, 7],
-                variable=FV.REWS,
+            fig, axs = plt.subplots(
+                2, 1, figsize=(5.2, 7), gridspec_kw={"height_ratios": [3, 1]}
+            )
+
+            of = foxes.output.FlowPlots2D(algo, farm_results)
+            ofg = 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[1],
+                ax=axs[0],
                 ret_im=True,
-                legloc="upper right",
+                title=None,
                 animated=True,
+                precalc=True,
+                rotor_color="red",
+            )
+            next(ofg)
+
+            anim = foxes.output.Animator(fig)
+            anim.add_generator(ofg)
+            anim.add_generator(
+                o.gen_stdata(
+                    turbines=[1, 4, 7],
+                    variable=FV.REWS,
+                    fig=fig,
+                    ax=axs[1],
+                    ret_im=True,
+                    legloc="upper right",
+                    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,
+            )
 
-        axs[0].scatter(
-            [args.ref_xy[0]],
-            [args.ref_xy[1]],
-            marker="x",
-            color="red",
-            s=80,
-            animated=True,
-        )
+            axs[0].scatter(
+                [args.ref_xy[0]],
+                [args.ref_xy[1]],
+                marker="x",
+                color="red",
+                s=80,
+                animated=True,
+            )
 
-        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)

{foxes-1.5 → foxes-1.5.1}/examples/field_data_nc/run.py

@@ -98,31 +98,33 @@ if __name__ == "__main__":
         wake_frame=args.wake_frame,
         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")
 
-    print(farm_results)
+        print(farm_results)
 
-    fr = farm_results.to_dataframe()
-    print(fr[[FV.WD, FV.AMB_REWS, FV.REWS, FV.AMB_P, FV.P]])
+        fr = farm_results.to_dataframe()
+        print(fr[[FV.WD, FV.AMB_REWS, FV.REWS, FV.AMB_P, FV.P]])
 
-    o = foxes.output.SlicesData(algo, farm_results)
-    ds = o.get_states_data_xy(
-        z_list=[90, 100], variables=[FV.WS], resolution=50, verbosity=1
-    )
-    print(ds)
+        o = foxes.output.SlicesData(algo, farm_results)
+        ds = o.get_states_data_xy(
+            z_list=[90, 100], variables=[FV.WS], resolution=50, verbosity=1
+        )
+        print(ds)
 
-    if not args.nofig:
-        o = foxes.output.FlowPlots2D(algo, farm_results)
-        o.get_mean_fig_xy(FV.WS, resolution=10)
-        plt.show()
+        if not args.nofig:
+            o = foxes.output.FlowPlots2D(algo, farm_results)
+            o.get_mean_fig_xy(FV.WS, resolution=10)
+            plt.show()

{foxes-1.5 → foxes-1.5.1}/examples/multi_height/run.py

@@ -91,14 +91,16 @@ 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,
     )
 
-    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,
+    ):
+        time0 = time.time()
+        farm_results = algo.calc_farm()
+        time1 = time.time()
 
     print("\nCalc time =", time1 - time0, "\n")
 

{foxes-1.5 → foxes-1.5.1}/examples/scan_row/run.py

@@ -102,97 +102,99 @@ 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,
-    )
-
-    time0 = time.time()
-    farm_results = algo.calc_farm()
-    time1 = time.time()
-
-    print("\nCalc time =", time1 - time0, "\n")
-
-    print("\nFarm results:\n", 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.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.")
-    print()
-
-    if not args.nofig and args.calc_cline:
-        points = np.zeros((n_s, n_p, 3))
-        points[:, :, 0] = np.linspace(p0[0], p0[0] + n_t * stp[0] + 10 * D, n_p)[
-            None, :
-        ]
-        points[:, :, 1] = p0[1]
-        points[:, :, 2] = H
-        print("\nPOINTS:\n", points[0])
-
+    ):
         time0 = time.time()
-        point_results = algo.calc_points(farm_results, points)
+        farm_results = algo.calc_farm()
         time1 = time.time()
+
         print("\nCalc time =", time1 - time0, "\n")
 
-        print(point_results)
-
-        fig, ax = plt.subplots()
-        for s in range(points.shape[0]):
-            ax.plot(points[s, :, 0], point_results[FV.WS][s, :])
-        ax.set_xlabel("x [m]")
-        ax.set_ylabel("Wind speed [m/s]")
-        ax.set_title("Centreline wind speed")
-        plt.show()
-        plt.close(fig)
-
-    if not args.nofig and args.calc_mean:
-        o = foxes.output.FlowPlots2D(algo, farm_results)
-        fig = o.get_mean_fig_xy(FV.WS, resolution=10)
-        plt.show()
+        print("\nFarm results:\n", 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.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.")
+        print()
+
+        if not args.nofig and args.calc_cline:
+            points = np.zeros((n_s, n_p, 3))
+            points[:, :, 0] = np.linspace(p0[0], p0[0] + n_t * stp[0] + 10 * D, n_p)[
+                None, :
+            ]
+            points[:, :, 1] = p0[1]
+            points[:, :, 2] = H
+            print("\nPOINTS:\n", points[0])
+
+            time0 = time.time()
+            point_results = algo.calc_points(farm_results, points)
+            time1 = time.time()
+            print("\nCalc time =", time1 - time0, "\n")
+
+            print(point_results)
+
+            fig, ax = plt.subplots()
+            for s in range(points.shape[0]):
+                ax.plot(points[s, :, 0], point_results[FV.WS][s, :])
+            ax.set_xlabel("x [m]")
+            ax.set_ylabel("Wind speed [m/s]")
+            ax.set_title("Centreline wind speed")
+            plt.show()
+            plt.close(fig)
+
+        if not args.nofig and args.calc_mean:
+            o = foxes.output.FlowPlots2D(algo, farm_results)
+            fig = o.get_mean_fig_xy(FV.WS, resolution=10)
+            plt.show()