foxes 0.8.2__py3-none-any.whl → 1.1.0.2__py3-none-any.whl

{foxes-0.8.2.dist-info → foxes-1.1.0.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.2.0)
+Generator: setuptools (75.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

foxes-1.1.0.2.dist-info/top_level.txt

@@ -0,0 +1,4 @@
+docs
+examples
+foxes
+tests

tests/0_consistency/iterative/test_iterative.py

@@ -0,0 +1,92 @@
+from pathlib import Path
+import inspect
+
+import foxes
+import foxes.variables as FV
+import foxes.constants as FC
+
+thisdir = Path(inspect.getfile(inspect.currentframe())).parent
+
+
+def test():
+    c = 1000
+    ttype = "DTU10MW"
+    sfile = "wind_rose_bremen.csv"
+    lfile = thisdir / "test_farm.csv"
+    cases = [
+        (foxes.algorithms.Downwind, "rotor_wd"),
+        (foxes.algorithms.Iterative, "rotor_wd"),
+        (foxes.algorithms.Iterative, "rotor_wd_farmo"),
+    ]
+    lims = {FV.REWS: 5e-7, FV.P: 5e-4}
+
+    ck = {FC.STATE: c}
+
+    base_results = None
+    for Algo, frame in cases:
+        print(f"\nENTERING CASE {(Algo.__name__, frame)}\n")
+
+        mbook = foxes.models.ModelBook()
+
+        states = foxes.input.states.StatesTable(
+            data_source=sfile,
+            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, lfile, turbine_models=[ttype], verbosity=1
+        )
+
+        kwargs = {}
+        if Algo is foxes.algorithms.Iterative:
+            kwargs["mod_cutin"] = {"modify_ct": False, "modify_P": False}
+
+        algo = Algo(
+            farm,
+            states,
+            mbook=mbook,
+            rotor_model="grid16",
+            wake_models=["Bastankhah2014_linear_k004", "IECTI2019_max"],
+            wake_frame=frame,
+            partial_wakes="rotor_points",
+            chunks=ck,
+            verbosity=1,
+            **kwargs,
+        )
+
+        # f Algo is foxes.algorithms.Iterative:
+        #    algo.set_urelax("post_rotor", CT=0.9)
+
+        data = algo.calc_farm()
+
+        df = data.to_dataframe()[
+            [FV.AMB_WD, FV.WD, FV.AMB_REWS, FV.REWS, FV.AMB_P, FV.P]
+        ]
+
+        print()
+        print("TRESULTS\n")
+        print(df)
+
+        df = df.reset_index()
+
+        if base_results is None:
+            base_results = df
+
+        else:
+            print(f"CASE {(Algo.__name__, frame)}")
+            delta = df - base_results
+            print(delta)
+            print(delta.min(), delta.max())
+
+            for v, lim in lims.items():
+                chk = delta[v].abs().loc[df["AMB_REWS"] > 7]
+                print(f"CASE {(Algo.__name__, frame, v, lim)}:", chk.max())
+
+            assert (chk < lim).all()
+
+
+if __name__ == "__main__":
+    test()

tests/0_consistency/partial_wakes/test_partial_wakes.py

@@ -0,0 +1,90 @@
+from pathlib import Path
+import inspect
+
+import foxes
+import foxes.variables as FV
+import foxes.constants as FC
+
+thisdir = Path(inspect.getfile(inspect.currentframe())).parent
+
+
+def test():
+    c = 180
+    tfile = thisdir / "NREL-5MW-D126-H90.csv"
+    sfile = thisdir / "states.csv.gz"
+    lfile = thisdir / "test_farm.csv"
+    cases = [
+        ("grid400", "rotor_points", None),
+        ("grid4", "rotor_points", 0.15),
+        ("grid9", "rotor_points", 0.07),
+        ("centre", "axiwake5", 0.03),
+        ("centre", "axiwake10", 0.0081),
+        ("centre", "grid9", 0.07),
+        ("centre", "grid16", 0.05),
+        ("centre", "grid36", 0.025),
+    ]
+
+    ck = {FC.STATE: c}
+
+    base_results = None
+    for rotor, pwake, lim in cases:
+        print(f"\nENTERING CASE {(rotor, pwake, lim)}\n")
+
+        mbook = foxes.models.ModelBook()
+        ttype = foxes.models.turbine_types.PCtFile(
+            data_source=tfile, var_ws_ct=FV.REWS, var_ws_P=FV.REWS
+        )
+        mbook.turbine_types[ttype.name] = ttype
+
+        states = foxes.input.states.StatesTable(
+            data_source=sfile,
+            output_vars=[FV.WS, FV.WD, FV.TI, FV.RHO],
+            var2col={FV.WS: "ws", FV.WD: "wd", FV.TI: "ti"},
+            fixed_vars={FV.RHO: 1.225},
+        )
+
+        farm = foxes.WindFarm()
+        foxes.input.farm_layout.add_from_file(
+            farm, lfile, turbine_models=[ttype.name], verbosity=1
+        )
+
+        algo = foxes.algorithms.Downwind(
+            farm,
+            states,
+            mbook=mbook,
+            rotor_model=rotor,
+            wake_models=["Bastankhah025_linear_k002"],
+            wake_frame="rotor_wd",
+            partial_wakes=pwake,
+            chunks=ck,
+            verbosity=1,
+        )
+
+        data = algo.calc_farm()
+
+        df = data.to_dataframe()[
+            [FV.AMB_WD, FV.WD, FV.AMB_REWS, FV.REWS, FV.AMB_P, FV.P]
+        ]
+
+        print()
+        print("TRESULTS\n")
+        print(df)
+
+        df = df.reset_index()
+
+        if base_results is None:
+            base_results = df
+
+        else:
+            print(f"CASE {(rotor, pwake, lim)}")
+            delta = df - base_results
+            print(delta)
+            print(delta.min(), delta.max())
+            chk = delta[FV.REWS].abs()
+            print(f"CASE {(rotor, pwake, lim)}:", chk.max())
+
+            assert (chk < lim).all()
+
+
+if __name__ == "__main__":
+    test()

tests/1_verification/flappy_0_6/PCt_files/flappy/run.py

@@ -0,0 +1,85 @@
+import numpy as np
+import pandas as pd
+import time
+import argparse
+from pathlib import Path
+
+import flappy as fl
+from flappy.config.variables import variables as FV
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "-c", "--chunksize", help="The maximal chunk size", type=int, default=500
+    )
+    parser.add_argument(
+        "-o", "--ofile", help="The output file name", default="results.csv.gz"
+    )
+    parser.add_argument(
+        "--n_cpus", help="The number of processors", type=int, default=4
+    )
+    args = parser.parse_args()
+
+    c = args.chunksize
+    p0 = np.array([0.0, 0.0])
+    stp = np.array([500.0, 0.0])
+    ofile = Path(args.ofile)
+    tPfile = "../NREL-5MW-D126-H90-P.csv"
+    tCtfile = "../NREL-5MW-D126-H90-Ct.csv"
+    sfile = "../states.csv.gz"
+    lfile = "../test_farm.csv"
+
+    # init flappy:
+    fl.init_flappy(n_cpus=args.n_cpus)
+
+    # load model book:
+    mbook = fl.ModelBook()
+    mbook.turbine_models[f"ws_P"] = fl.models.Ws2P(P_curve_file=tPfile)
+    mbook.turbine_models[f"ws_Ct"] = fl.models.Ws2Ct(ct_curve_file=tCtfile)
+
+    # create wind farm:
+    farm = fl.WindFarm()
+    fl.input.add_turbines_from_csv(
+        farm,
+        lfile,
+        col_index="index",
+        col_x="x",
+        col_y="y",
+        rotor_diameter=126.0,
+        hub_height=90.0,
+        rotor_model="centre",
+        wake_models=["Jensen007"],
+        turbine_models=["ws_P", "ws_Ct"],
+    )
+
+    # create states:
+    states = fl.input.AFSStatesTable(
+        data_file=sfile,
+        col_wd="wd",
+        col_ws="ws",
+        col_ti="ti",
+        col_weight="weight",
+        air_density=1.225,
+        max_chunk_size=args.chunksize,
+    )
+    states.initialize()
+
+    time0 = time.time()
+
+    # run calculation:
+    results = farm.calculate(mbook, states, wake_superp=["wind_linear"])
+
+    time1 = time.time()
+    print("\nCalc time =", time1 - time0, "\n")
+
+    df = results.state_turbine_results[[FV.WD, FV.AMB_WS, FV.WS, FV.AMB_P, FV.P]]
+
+    print()
+    print("TRESULTS\n")
+    print(df)
+
+    print("\nWriting file", ofile)
+    df.to_csv(ofile)
+
+    # close flappy:
+    fl.shutdown_flappy()

tests/1_verification/flappy_0_6/PCt_files/test_PCt_files.py

@@ -0,0 +1,103 @@
+import pandas as pd
+from pathlib import Path
+import inspect
+
+import foxes
+import foxes.variables as FV
+import foxes.constants as FC
+
+thisdir = Path(inspect.getfile(inspect.currentframe())).parent
+
+
+def test():
+    print(thisdir)
+
+    c = 2000
+    cfile = thisdir / "flappy" / "results.csv.gz"
+    tPfile = thisdir / "NREL-5MW-D126-H90-P.csv"
+    tCtfile = thisdir / "NREL-5MW-D126-H90-Ct.csv"
+    sfile = thisdir / "states.csv.gz"
+    lfile = thisdir / "test_farm.csv"
+
+    ck = {FC.STATE: c}
+
+    mbook = foxes.models.ModelBook()
+    ttype = foxes.models.turbine_types.PCtFromTwo(
+        data_source_P=tPfile,
+        data_source_ct=tCtfile,
+        col_ws_P_file="ws",
+        col_ws_ct_file="ws",
+        col_P="P",
+        col_ct="ct",
+        P_nominal=5000,
+        H=90.0,
+        D=126,
+        name="power_and_ct_curve",
+    )
+    mbook.turbine_types[ttype.name] = ttype
+
+    states = foxes.input.states.StatesTable(
+        data_source=sfile,
+        output_vars=[FV.WS, FV.WD, FV.TI, FV.RHO],
+        var2col={FV.WS: "ws", FV.WD: "wd", FV.TI: "ti"},
+        fixed_vars={FV.RHO: 1.225},
+    )
+
+    farm = foxes.WindFarm()
+    foxes.input.farm_layout.add_from_file(
+        farm, lfile, turbine_models=[ttype.name], verbosity=0
+    )
+
+    algo = foxes.algorithms.Downwind(
+        farm,
+        states,
+        mbook=mbook,
+        rotor_model="centre",
+        wake_models=["Jensen_linear_k007"],
+        wake_frame="rotor_wd",
+        partial_wakes={"Jensen_linear_k007": "top_hat"},
+        chunks=ck,
+        verbosity=0,
+    )
+
+    data = algo.calc_farm()
+
+    df = data.to_dataframe()[[FV.AMB_WD, FV.WD, FV.AMB_REWS, FV.REWS, FV.AMB_P, FV.P]]
+    df = df.reset_index()
+
+    print()
+    print("TRESULTS\n")
+    print(df)
+
+    # print("\Reading file", cfile)
+    fdata = pd.read_csv(cfile)
+    print(fdata)
+
+    print("\nVERIFYING\n")
+    df[FV.WS] = df["REWS"]
+    df[FV.AMB_WS] = df["AMB_REWS"]
+
+    # neglecting ws < 5 and ws > 20
+    sel_ws = (
+        (fdata[FV.WS] > 5) & (fdata[FV.WS] < 20) & (df["REWS"] > 5) & (df["REWS"] < 20)
+    )
+
+    # calculating difference
+    delta = df.reset_index() - fdata
+    delta = delta[sel_ws]
+    print(delta)
+    print(delta.max())
+    chk = delta[[FV.AMB_WS, FV.AMB_P, FV.WS, FV.P]].abs()
+    sel = chk[FV.WS] >= 1e-5
+    print(sel)
+    print(df[sel & sel_ws])
+    print(fdata[sel & sel_ws])
+    print(chk.loc[sel & sel_ws])
+    print(chk.max())
+
+    assert ((chk[FV.WS] < 1e-5)).all()
+    assert (chk[FV.P] < 1e-3).all()
+
+
+if __name__ == "__main__":
+    test()

tests/1_verification/flappy_0_6/abl_states/flappy/run.py

@@ -0,0 +1,85 @@
+import numpy as np
+import pandas as pd
+import time
+import argparse
+from pathlib import Path
+
+import flappy as fl
+from flappy.config.variables import variables as FV
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "-c", "--chunksize", help="The maximal chunk size", type=int, default=500
+    )
+    parser.add_argument(
+        "-o", "--ofile", help="The output file name", default="results.csv.gz"
+    )
+    parser.add_argument(
+        "--n_cpus", help="The number of processors", type=int, default=4
+    )
+    args = parser.parse_args()
+
+    c = args.chunksize
+    p0 = np.array([0.0, 0.0])
+    stp = np.array([500.0, 0.0])
+    ofile = Path(args.ofile)
+    tfile = "../NREL-5MW-D126-H90.csv"
+    sfile = "../states.csv.gz"
+    lfile = "../test_farm.csv"
+
+    # init flappy:
+    fl.init_flappy(n_cpus=args.n_cpus)
+
+    # load model book:
+    mbook = fl.ModelBook(ct_power_curve_file=tfile)
+
+    # create wind farm:
+    farm = fl.WindFarm()
+    fl.input.add_turbines_from_csv(
+        farm,
+        lfile,
+        col_index="index",
+        col_x="x",
+        col_y="y",
+        col_h="H",
+        rotor_diameter=126.0,
+        rotor_model="centre",
+        wake_models=["Jensen007_rotor"],
+        turbine_models=["ct_P_curves"],
+    )
+
+    # create states:
+    states = fl.input.AFSStatesTable(
+        data_file=sfile,
+        col_wd="wd",
+        col_ws_ref="ws",
+        col_ti="ti",
+        col_mol="mol",
+        z0=0.05,
+        h_ref=100.0,
+        col_weight="weight",
+        air_density=1.225,
+        max_chunk_size=args.chunksize,
+    )
+    states.initialize()
+
+    time0 = time.time()
+
+    # run calculation:
+    results = farm.calculate(mbook, states, wake_superp=["wind_linear"])
+
+    time1 = time.time()
+    print("\nCalc time =", time1 - time0, "\n")
+
+    df = results.state_turbine_results[[FV.WD, FV.AMB_WS, FV.WS, FV.AMB_P, FV.P]]
+
+    print()
+    print("TRESULTS\n")
+    print(df)
+
+    print("\nWriting file", ofile)
+    df.to_csv(ofile)
+
+    # close flappy:
+    fl.shutdown_flappy()

tests/1_verification/flappy_0_6/abl_states/test_abl_states.py

@@ -0,0 +1,87 @@
+import pandas as pd
+from pathlib import Path
+import inspect
+
+import foxes
+import foxes.variables as FV
+import foxes.constants as FC
+
+thisdir = Path(inspect.getfile(inspect.currentframe())).parent
+
+
+def test():
+    c = 2000
+    cfile = thisdir / "flappy" / "results.csv.gz"
+    tfile = thisdir / "NREL-5MW-D126-H90.csv"
+    sfile = thisdir / "states.csv.gz"
+    lfile = thisdir / "test_farm.csv"
+
+    ck = {FC.STATE: c}
+
+    mbook = foxes.models.ModelBook()
+    ttype = foxes.models.turbine_types.PCtFile(
+        data_source=tfile, var_ws_ct=FV.REWS, var_ws_P=FV.REWS
+    )
+    mbook.turbine_types[ttype.name] = ttype
+
+    states = foxes.input.states.StatesTable(
+        data_source=sfile,
+        output_vars=[FV.WS, FV.WD, FV.TI, FV.RHO, FV.MOL],
+        var2col={FV.WS: "ws", FV.WD: "wd", FV.TI: "ti", FV.MOL: "mol"},
+        fixed_vars={FV.RHO: 1.225, FV.Z0: 0.05, FV.H: 100.0},
+        profiles={FV.WS: "ABLLogWsProfile"},
+    )
+
+    farm = foxes.WindFarm()
+    foxes.input.farm_layout.add_from_file(
+        farm,
+        lfile,
+        col_x="x",
+        col_y="y",
+        col_H="H",
+        turbine_models=[ttype.name],
+        verbosity=0,
+    )
+
+    algo = foxes.algorithms.Downwind(
+        farm,
+        states,
+        mbook=mbook,
+        rotor_model="centre",
+        wake_models=["Jensen_linear_k007"],
+        wake_frame="rotor_wd",
+        partial_wakes={"Jensen_linear_k007": "centre"},
+        chunks=ck,
+        verbosity=0,
+    )
+
+    data = algo.calc_farm()
+
+    df = data.to_dataframe()[[FV.AMB_WD, FV.WD, FV.AMB_REWS, FV.REWS, FV.AMB_P, FV.P]]
+
+    print()
+    print("TRESULTS\n")
+    print(df)
+
+    print("\nReading file", cfile)
+    fdata = pd.read_csv(cfile)
+    print(fdata)
+
+    print("\nVERIFYING\n")
+    df[FV.WS] = df["REWS"]
+    df[FV.AMB_WS] = df["AMB_REWS"]
+
+    delta = df.reset_index() - fdata
+    print(delta)
+    print(delta.max())
+    chk = delta[[FV.AMB_WS, FV.AMB_P, FV.WS, FV.P]].abs()
+    print(chk.max())
+
+    assert (chk[FV.AMB_WS] < 1e-5).all()
+    assert (chk[FV.AMB_P] < 1e-3).all()
+    assert (chk[FV.WS] < 1e-5).all()
+    assert (chk[FV.P] < 1e-3).all()
+
+
+if __name__ == "__main__":
+    test()

tests/1_verification/flappy_0_6/partial_top_hat/flappy/run.py

@@ -0,0 +1,82 @@
+import numpy as np
+import pandas as pd
+import time
+import argparse
+from pathlib import Path
+
+import flappy as fl
+from flappy.config.variables import variables as FV
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "-c", "--chunksize", help="The maximal chunk size", type=int, default=500
+    )
+    parser.add_argument(
+        "-o", "--ofile", help="The output file name", default="results.csv.gz"
+    )
+    parser.add_argument(
+        "--n_cpus", help="The number of processors", type=int, default=4
+    )
+    args = parser.parse_args()
+
+    c = args.chunksize
+    p0 = np.array([0.0, 0.0])
+    stp = np.array([500.0, 0.0])
+    ofile = Path(args.ofile)
+    tfile = "../NREL-5MW-D126-H90.csv"
+    sfile = "../states.csv.gz"
+    lfile = "../test_farm.csv"
+
+    # init flappy:
+    fl.init_flappy(n_cpus=args.n_cpus)
+
+    # load model book:
+    mbook = fl.ModelBook(ct_power_curve_file=tfile)
+
+    # create wind farm:
+    farm = fl.WindFarm()
+    fl.input.add_turbines_from_csv(
+        farm,
+        lfile,
+        col_index="index",
+        col_x="x",
+        col_y="y",
+        rotor_diameter=126.0,
+        hub_height=90.0,
+        rotor_model="centre",
+        wake_models=["Jensen007"],
+        turbine_models=["ct_P_curves"],
+    )
+
+    # create states:
+    states = fl.input.AFSStatesTable(
+        data_file=sfile,
+        col_wd="wd",
+        col_ws="ws",
+        col_ti="ti",
+        col_weight="weight",
+        air_density=1.225,
+        max_chunk_size=args.chunksize,
+    )
+    states.initialize()
+
+    time0 = time.time()
+
+    # run calculation:
+    results = farm.calculate(mbook, states, wake_superp=["wind_linear"])
+
+    time1 = time.time()
+    print("\nCalc time =", time1 - time0, "\n")
+
+    df = results.state_turbine_results[[FV.WD, FV.AMB_WS, FV.WS, FV.AMB_P, FV.P]]
+
+    print()
+    print("TRESULTS\n")
+    print(df)
+
+    print("\nWriting file", ofile)
+    df.to_csv(ofile)
+
+    # close flappy:
+    fl.shutdown_flappy()