foxes 0.8.1__py3-none-any.whl → 1.0__py3-none-any.whl

examples/scan_row/run.py

@@ -0,0 +1,193 @@
+import numpy as np
+import time
+import argparse
+import matplotlib.pyplot as plt
+
+import foxes
+import foxes.variables as FV
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-n_s", help="The number of states", type=int, default=30)
+    parser.add_argument("-n_t", help="The number of turbines", type=int, default=5)
+    parser.add_argument("--n_p", help="The number of turbines", type=int, default=2000)
+    parser.add_argument("--ws0", help="The lowest wind speed", type=float, default=3.0)
+    parser.add_argument(
+        "--ws1", help="The highest wind speed", type=float, default=30.0
+    )
+    parser.add_argument(
+        "-t",
+        "--turbine_file",
+        help="The P-ct-curve csv file (path or static)",
+        default="NREL-5MW-D126-H90.csv",
+    )
+    parser.add_argument(
+        "-w",
+        "--wakes",
+        help="The wake models",
+        default=["Bastankhah2014_linear"],
+        nargs="+",
+    )
+    parser.add_argument(
+        "-m", "--tmodels", help="The turbine models", default=["kTI_04"], nargs="+"
+    )
+    parser.add_argument("-r", "--rotor", help="The rotor model", default="centre")
+    parser.add_argument(
+        "-p", "--pwakes", help="The partial wakes models", default=None, nargs="+"
+    )
+    parser.add_argument(
+        "-cl", "--calc_cline", help="Calculate centreline", action="store_true"
+    )
+    parser.add_argument(
+        "-cm", "--calc_mean", help="Calculate states mean", action="store_true"
+    )
+    parser.add_argument("-e", "--engine", help="The engine", default="process")
+    parser.add_argument(
+        "-n", "--n_cpus", help="The number of cpus", default=None, type=int
+    )
+    parser.add_argument(
+        "-c",
+        "--chunksize_states",
+        help="The chunk size for states",
+        default=None,
+        type=int,
+    )
+    parser.add_argument(
+        "-C",
+        "--chunksize_points",
+        help="The chunk size for points",
+        default=None,
+        type=int,
+    )
+    parser.add_argument(
+        "-nf", "--nofig", help="Do not show figures", action="store_true"
+    )
+    args = parser.parse_args()
+
+    n_s = args.n_s
+    n_t = args.n_t
+    n_p = args.n_p
+    p0 = np.array([0.0, 0.0])
+    stp = np.array([500.0, 0.0])
+
+    mbook = foxes.models.ModelBook()
+    ttype = foxes.models.turbine_types.PCtFile(args.turbine_file)
+    mbook.turbine_types[ttype.name] = ttype
+    D = ttype.D
+    H = ttype.H
+
+    states = foxes.input.states.ScanWS(
+        ws_list=np.linspace(args.ws0, args.ws1, n_s), wd=270.0, ti=0.08, rho=1.225
+    )
+
+    farm = foxes.WindFarm()
+    foxes.input.farm_layout.add_row(
+        farm=farm,
+        xy_base=p0,
+        xy_step=stp,
+        n_turbines=n_t,
+        turbine_models=args.tmodels + [ttype.name],
+    )
+
+    algo = foxes.algorithms.Downwind(
+        farm,
+        states,
+        rotor_model=args.rotor,
+        wake_models=args.wakes,
+        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,
+    )
+
+    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: "mean",
+            FV.P: "mean",
+            FV.AMB_CAP: "mean",
+            FV.CAP: "mean",
+            FV.EFF: "mean",
+        }
+    )
+    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)
+    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()

examples/sector_management/run.py

@@ -0,0 +1,162 @@
+import time
+import argparse
+import matplotlib.pyplot as plt
+
+import foxes
+import foxes.variables as FV
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "-l",
+        "--layout",
+        help="The wind farm layout file (path or static)",
+        default="test_farm_67.csv",
+    )
+    parser.add_argument(
+        "-s",
+        "--states",
+        help="The states input file (path or static)",
+        default="wind_rose_bremen.csv",
+    )
+    parser.add_argument(
+        "-t",
+        "--turbine_file",
+        help="The P-ct-curve csv file (path or static)",
+        default="NREL-5MW-D126-H90.csv",
+    )
+    parser.add_argument(
+        "-sm",
+        "--sector_file",
+        help="The sector management file",
+        default="sector_rules.csv",
+    )
+    parser.add_argument("-r", "--rotor", help="The rotor model", default="centre")
+    parser.add_argument(
+        "-p", "--pwakes", help="The partial wakes models", default=None, nargs="+"
+    )
+    parser.add_argument(
+        "-w",
+        "--wakes",
+        help="The wake models",
+        default=["Bastankhah2014_linear_k002"],
+        nargs="+",
+    )
+    parser.add_argument(
+        "-m", "--tmodels", help="The turbine models", default=[], nargs="+"
+    )
+    parser.add_argument("-e", "--engine", help="The engine", default="process")
+    parser.add_argument(
+        "-n", "--n_cpus", help="The number of cpus", default=None, type=int
+    )
+    parser.add_argument(
+        "-c",
+        "--chunksize_states",
+        help="The chunk size for states",
+        default=None,
+        type=int,
+    )
+    parser.add_argument(
+        "-C",
+        "--chunksize_points",
+        help="The chunk size for points",
+        default=None,
+        type=int,
+    )
+    parser.add_argument(
+        "-nf", "--nofig", help="Do not show figures", action="store_true"
+    )
+    args = parser.parse_args()
+
+    mbook = foxes.models.ModelBook()
+    ttype = foxes.models.turbine_types.PCtFile(args.turbine_file)
+    mbook.turbine_types[ttype.name] = ttype
+
+    mbook.turbine_models["sector_rules"] = foxes.models.turbine_models.SectorManagement(
+        data_source=args.sector_file,
+        col_tnames="tname",
+        range_vars=[FV.WD, FV.REWS],
+        target_vars=[FV.MAX_P],
+        colmap={"REWS_min": "WS_min", "REWS_max": "WS_max"},
+    )
+
+    states = foxes.input.states.StatesTable(
+        data_source=args.states,
+        output_vars=[FV.WS, FV.WD, FV.TI, FV.RHO],
+        var2col={FV.WS: "ws", FV.WD: "wd", FV.WEIGHT: "weight"},
+        fixed_vars={FV.RHO: 1.225, FV.TI: 0.05},
+    )
+
+    farm = foxes.WindFarm()
+    foxes.input.farm_layout.add_row(
+        farm=farm,
+        xy_base=[0.0, 0.0],
+        xy_step=[600.0, 0.0],
+        n_turbines=2,
+        turbine_models=args.tmodels + [ttype.name, "sector_rules", "PMask"],
+    )
+
+    algo = foxes.algorithms.Downwind(
+        farm,
+        states,
+        rotor_model=args.rotor,
+        wake_models=args.wakes,
+        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 = [
+        FV.D,
+        FV.WD,
+        FV.AMB_WD,
+        FV.H,
+        FV.AMB_REWS,
+        FV.REWS,
+        FV.AMB_P,
+        FV.MAX_P,
+        FV.P,
+        FV.CT,
+        FV.WEIGHT,
+    ]
+
+    time0 = time.time()
+    farm_results = algo.calc_farm(outputs=outputs)
+    time1 = time.time()
+
+    print("\nCalc time =", time1 - time0, "\n")
+
+    print(farm_results)
+
+    fr = farm_results.to_dataframe()
+    sel = fr[FV.MAX_P].dropna().index
+    fr = fr.loc[sel]
+    print(fr)
+
+    if not args.nofig:
+        o = foxes.output.RosePlotOutput(farm_results)
+        fig = o.get_figure(
+            16,
+            FV.P,
+            [100, 1000, 2000, 4000, 5001, 7000],
+            turbine=0,
+            title="Power turbine 0",
+            figsize=(12, 6),
+            rect=[0.05, 0.1, 0.4, 0.8],
+        )
+
+        o = foxes.output.RosePlotOutput(farm_results)
+        fig = o.get_figure(
+            16,
+            FV.P,
+            [100, 1000, 2000, 4000, 5001, 7000],
+            turbine=1,
+            title="Power turbine 1",
+            fig=fig,
+            rect=[0.35, 0.1, 0.8, 0.8],
+        )
+        plt.show()

examples/sequential/run.py

@@ -0,0 +1,209 @@
+import argparse
+import matplotlib.pyplot as plt
+import numpy as np
+from pathlib import Path
+
+import foxes
+import foxes.variables as FV
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "-a", "--animation", help="Write flow animation file", action="store_true"
+    )
+    parser.add_argument(
+        "-A",
+        "--ani_file",
+        help="Path to the animation file to be written",
+        default="ani.gif",
+    )
+    parser.add_argument(
+        "-F",
+        "--fps",
+        help="The frames per second value for the animation",
+        type=int,
+        default=4,
+    )
+    parser.add_argument(
+        "-d", "--debug", help="Switch on wake debugging", action="store_true"
+    )
+    parser.add_argument(
+        "-S",
+        "--n_states",
+        help="The number of states",
+        type=int,
+        default=50,
+    )
+    parser.add_argument(
+        "-l",
+        "--layout",
+        help="The wind farm layout file (path or static)",
+        default="test_farm_67.csv",
+    )
+    parser.add_argument(
+        "-t",
+        "--turbine_file",
+        help="The P-ct-curve csv file (path or static)",
+        default="NREL-5MW-D126-H90.csv",
+    )
+    parser.add_argument("-r", "--rotor", help="The rotor model", default="centre")
+    parser.add_argument(
+        "-p", "--pwakes", help="The partial wakes models", default=None, nargs="+"
+    )
+    parser.add_argument(
+        "-w",
+        "--wakes",
+        help="The wake models",
+        default=["Bastankhah2014_linear_lim_k004"],
+        nargs="+",
+    )
+    parser.add_argument(
+        "-f", "--frame", help="The wake frame", default="seq_dyn_wakes_1min"
+    )
+    parser.add_argument(
+        "-m", "--tmodels", help="The turbine models", default=[], nargs="+"
+    )
+    parser.add_argument(
+        "-sl",
+        "--show_layout",
+        help="Flag for showing layout figure",
+        action="store_true",
+    )
+    parser.add_argument(
+        "-V",
+        "--variable",
+        help="Plot variable",
+        default=FV.WS,
+    )
+    parser.add_argument(
+        "-VMAX",
+        "--max_variable",
+        help="Maximal plot variable",
+        default=10,
+        type=float,
+    )
+    parser.add_argument("-e", "--engine", help="The engine", default="NumpyEngine")
+    parser.add_argument(
+        "-n", "--n_cpus", help="The number of cpus", default=None, type=int
+    )
+    parser.add_argument(
+        "-c",
+        "--chunksize_states",
+        help="The chunk size for states",
+        default=None,
+        type=int,
+    )
+    parser.add_argument(
+        "-C",
+        "--chunksize_points",
+        help="The chunk size for points",
+        default=None,
+        type=int,
+    )
+    parser.add_argument(
+        "-nf", "--nofig", help="Do not show figures", action="store_true"
+    )
+    args = parser.parse_args()
+
+    mbook = foxes.models.ModelBook()
+    ttype = foxes.models.turbine_types.PCtFile(args.turbine_file)
+    mbook.turbine_types[ttype.name] = ttype
+
+    states = foxes.input.states.Timeseries(
+        data_source="timeseries_3000.csv.gz",
+        output_vars=[FV.WS, FV.WD, FV.TI, FV.RHO],
+        var2col={FV.WS: "WS", FV.WD: "WD", FV.TI: "TI", FV.RHO: "RHO"},
+        states_sel=range(240, 240 + args.n_states),
+    )
+
+    farm = foxes.WindFarm()
+    N = 3
+    foxes.input.farm_layout.add_grid(
+        farm,
+        xy_base=np.array([0.0, 0.0]),
+        step_vectors=np.array([[1000.0, 0], [0, 800.0]]),
+        steps=(N, N),
+        turbine_models=args.tmodels + [ttype.name],
+    )
+
+    if not args.nofig and args.show_layout:
+        ax = foxes.output.FarmLayoutOutput(farm).get_figure()
+        plt.show()
+        plt.close(ax.get_figure(figsize=(8, 8)))
+
+    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,
+    ):
+        algo = foxes.algorithms.Sequential(
+            farm,
+            states,
+            rotor_model=args.rotor,
+            wake_models=args.wakes,
+            wake_frame=args.frame,
+            partial_wakes=args.pwakes,
+            mbook=mbook,
+            verbosity=0,
+        )
+
+        # in case of animation, add a plugin that creates the images:
+        if args.animation:
+            anigen = foxes.output.SeqFlowAnimationPlugin(
+                orientation="xy",
+                var=args.variable,
+                resolution=10,
+                levels=None,
+                quiver_pars=dict(scale=0.01),
+                quiver_n=307,
+                xmin=-5000,
+                ymin=-5000,
+                xmax=7000,
+                ymax=7000,
+                vmin=0,
+                vmax=args.max_variable,
+                title=None,
+                animated=True,
+            )
+            algo.plugins.append(anigen)
+
+            if args.debug:
+                anigen_debug = foxes.output.SeqWakeDebugPlugin()
+                algo.plugins.append(anigen_debug)
+
+        # run all states sequentially:
+        for r in algo:
+            print(algo.index)
+
+    print("\nFarm results:\n")
+    print(algo.farm_results)
+
+    if args.animation:
+        print("\nCalculating animation")
+
+        fig, ax = plt.subplots()
+        anim = foxes.output.Animator(fig)
+        anim.add_generator(anigen.gen_images(ax))
+        if args.debug:
+            anim.add_generator(anigen_debug.gen_images(ax))
+        ani = anim.animate(interval=600)
+
+        lo = foxes.output.FarmLayoutOutput(farm)
+        lo.get_figure(
+            fig=fig,
+            ax=ax,
+            title="",
+            annotate=1,
+            anno_delx=-120,
+            anno_dely=-60,
+            alpha=0,
+            s=10,
+        )
+
+        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)