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

examples/wind_rose/run.py

@@ -0,0 +1,141 @@
+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("-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=["CrespoHernandez_quadratic", "Bastankhah2014_linear"],
+        nargs="+",
+    )
+    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(
+        "-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=5000,
+        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.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_from_file(
+        farm,
+        args.layout,
+        col_x="x",
+        col_y="y",
+        col_H="H",
+        turbine_models=[ttype.name, "kTI_02"] + args.tmodels,
+    )
+
+    if not args.nofig and args.show_layout:
+        ax = foxes.output.FarmLayoutOutput(farm).get_figure()
+        plt.show()
+        plt.close(ax.get_figure())
+
+    algo = foxes.algorithms.Downwind(
+        farm,
+        states=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,
+    )
+
+    if not args.nofig:
+        o = foxes.output.StatesRosePlotOutput(states, point=[0.0, 0.0, 100.0])
+        fig = o.get_figure(16, FV.AMB_WS, [0, 3.5, 6, 10, 15, 20])
+        plt.show()
+
+    time0 = time.time()
+    farm_results = algo.calc_farm()
+    time1 = time.time()
+
+    print("\nCalc time =", time1 - time0, "\n")
+
+    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]])
+
+    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()

examples/windio/run.py

@@ -0,0 +1,29 @@
+import argparse
+
+import foxes
+
+if __name__ == "__main__":
+    # define arguments and options:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "-wio",
+        "--windio_yaml",
+        help="The windio wind energy systems yaml file",
+        default="windio_5turbines_timeseries.yaml",
+    )
+    parser.add_argument(
+        "-nf", "--nofig", help="Do not show figures", action="store_true"
+    )
+    parser.add_argument(
+        "-V", "--verbosity", help="The verbosity level, 0=silent", type=int, default=1
+    )
+    args = parser.parse_args()
+
+    try:
+        wio_runner = foxes.input.windio.read_windio(
+            args.windio_yaml, verbosity=args.verbosity
+        )
+        with wio_runner as runner:
+            runner.run()
+    except ModuleNotFoundError as e:
+        print(e.msg)

examples/yawed_wake/run.py

@@ -0,0 +1,196 @@
+import numpy as np
+import argparse
+import matplotlib.pyplot as plt
+
+import foxes
+import foxes.variables as FV
+
+if __name__ == "__main__":
+    # define arguments and options:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "-y", "--yawm", help="YAWM angle of first turbine", default=30.0, type=float
+    )
+    parser.add_argument(
+        "-y2", "--yawm2", help="YAWM angle of second turbine", default=0.0, type=float
+    )
+    parser.add_argument("--ws", help="The wind speed", type=float, default=9.0)
+    parser.add_argument("--wd", help="The wind direction", type=float, default=270.0)
+    parser.add_argument("--ti", help="The TI value", type=float, default=0.08)
+    parser.add_argument("--rho", help="The air density", type=float, default=1.225)
+    parser.add_argument(
+        "-dx", "--deltax", help="The turbine distance in x", type=float, default=1500.0
+    )
+    parser.add_argument(
+        "-dy", "--deltay", help="Turbine layout y step", type=float, default=0.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=["Bastankhah2016_linear_ka02", "CrespoHernandez_quadratic_ka04"],
+        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("-f", "--frame", help="The wake frame", default="yawed")
+    parser.add_argument(
+        "-m", "--tmodels", help="The turbine models", default=[], nargs="+"
+    )
+    parser.add_argument("-v", "--var", help="The plot variable", default=FV.WS)
+    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=5000,
+        type=int,
+    )
+    parser.add_argument(
+        "-nf", "--nofig", help="Do not show figures", action="store_true"
+    )
+    args = parser.parse_args()
+
+    # create model book
+    mbook = foxes.ModelBook()
+    ttype = foxes.models.turbine_types.PCtFile(args.turbine_file)
+    mbook.turbine_types[ttype.name] = ttype
+
+    # set turbines in yaw
+    yawm = np.array([[args.yawm, args.yawm2]])
+    mbook.turbine_models["set_yawm"] = foxes.models.turbine_models.SetFarmVars()
+    mbook.turbine_models["set_yawm"].add_var(FV.YAWM, yawm)
+
+    # create states
+    states = foxes.input.states.SingleStateStates(
+        ws=args.ws, wd=args.wd, ti=args.ti, rho=args.rho
+    )
+
+    # create wind farm
+    print("\nCreating wind farm")
+    farm = foxes.WindFarm()
+    foxes.input.farm_layout.add_row(
+        farm=farm,
+        xy_base=np.array([0.0, 0.0]),
+        xy_step=np.array([args.deltax, args.deltay]),
+        n_turbines=2,
+        turbine_models=args.tmodels + ["set_yawm", "yawm2yaw", ttype.name],
+    )
+
+    # create algorithm
+    algo = foxes.algorithms.Downwind(
+        farm,
+        states=states,
+        rotor_model=args.rotor,
+        wake_models=args.wakes,
+        wake_frame=args.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,
+    )
+
+    # 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=-100, 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=10,
+            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()
+
+    # 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()
+
+    # 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.")

foxes/__init__.py

@@ -3,7 +3,7 @@ Farm Optimization and eXtended yield Evaluation Software
     
 """
 
-from .core import WindFarm, Turbine  # noqa: F401
+from .core import Engine, WindFarm, Turbine, get_engine, reset_engine  # noqa: F401
 from .models import ModelBook  # noqa: F401
 from .data import (
     parse_Pct_file_name,
@@ -15,16 +15,12 @@ from .data import (
 )  # noqa: F401
 
 from . import algorithms  # noqa: F401
+from . import engines  # noqa: F401
 from . import models  # noqa: F401
 from . import input  # noqa: F401
 from . import output  # noqa: F401
 from . import utils  # noqa: F401
 
-try:
-    from importlib.resources import files
+from importlib.metadata import version
 
-    __version__ = files(__package__).joinpath("VERSION").read_text()
-except ImportError:
-    from importlib.resources import read_text
-
-    __version__ = read_text(__package__, "VERSION")
+__version__ = version(__package__ or __name__)

foxes/algorithms/__init__.py

@@ -4,7 +4,7 @@ Algorithms define the main calculation routines.
 
 from .downwind.downwind import Downwind
 from .iterative.iterative import Iterative
-from .sequential.sequential import Sequential
+from .sequential import Sequential
 
 from . import downwind
 from . import iterative