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

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

@@ -0,0 +1,94 @@
+import numpy as np
+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()
+
+    n_s = 30
+    n_t = 52
+    c = args.chunksize
+    p0 = np.array([0.0, 0.0])
+    stp = np.array([601.0, 15.0])
+    tfile = "../NREL-5MW-D126-H90.csv"
+    ofile = Path(args.ofile)
+
+    # 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_turbine_row(
+        farm,
+        rotor_diameter=126.0,
+        hub_height=90.0,
+        rotor_model="centre",
+        wake_models=["Jensen007", "IEC_TI_2019_rotor"],
+        turbine_models=["ct_P_curves"],
+        base_point=p0,
+        step_vector=stp,
+        steps=n_t - 1,
+    )
+
+    # create states:
+    ws0 = 6.0
+    ws1 = 16.0
+    states = fl.input.AFSScan(
+        ws_min=ws0,
+        ws_delta=(ws1 - ws0) / (n_s - 1),
+        ws_n_bins=n_s,
+        func_pdf_ws=None,
+        wd_min=270.0,
+        wd_delta=1.0,
+        wd_n_bins=1,
+        func_pdf_wd=None,
+        ti_min=0.08,
+        ti_delta=0.01,
+        ti_n_bins=1,
+        func_pdf_ti=None,
+        rho_min=1.225,
+        rho_delta=0.001,
+        rho_n_bins=1,
+        func_pdf_rho=None,
+        max_chunk_size=c,
+    )
+    states.initialize()
+
+    time0 = time.time()
+
+    # run calculation:
+    results = farm.calculate(mbook, states, wake_superp=["wind_linear", "ti_max"])
+
+    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, FV.AMB_TI, FV.TI, FV.AMB_CT, FV.CT]
+    ]
+
+    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/row_Jensen_linear_tophat_IECTI2019/test_row_Jensen_linear_tophat_IECTI_2019.py

@@ -0,0 +1,122 @@
+import numpy as np
+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():
+    n_s = 30
+    n_t = 52
+    wd = 270.0
+    ti = 0.08
+    rotor = "centre"
+    c = 100
+    p0 = np.array([0.0, 0.0])
+    stp = np.array([601.0, 15.0])
+    cfile = thisdir / "flappy" / "results.csv.gz"
+    tfile = thisdir / "NREL-5MW-D126-H90.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.ScanWS(
+        ws_list=np.linspace(6.0, 16.0, n_s), wd=wd, ti=ti, 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=[ttype.name],
+        verbosity=1,
+    )
+
+    algo = foxes.algorithms.Downwind(
+        farm,
+        states,
+        mbook=mbook,
+        rotor_model=rotor,
+        wake_models=["Jensen_linear_k007", "IECTI2019_max"],
+        wake_frame="rotor_wd",
+        partial_wakes=["top_hat", "top_hat"],
+        chunks=ck,
+        verbosity=1,
+    )
+
+    data = algo.calc_farm()
+
+    df = data.to_dataframe()[
+        [
+            FV.X,
+            FV.Y,
+            FV.WD,
+            FV.AMB_REWS,
+            FV.REWS,
+            FV.AMB_TI,
+            FV.TI,
+            FV.AMB_CT,
+            FV.CT,
+        ]
+    ]
+
+    print("\nReading file", cfile)
+    fdata = pd.read_csv(cfile).set_index(["state", "turbine"])
+
+    print()
+    print("TRESULTS\n")
+    """sel = (df[FV.P] > 0) & (fdata[FV.P] > 0)
+    df = df.loc[sel]
+    fdata = fdata.loc[sel]"""
+    print(df)
+    print(fdata)
+
+    print("\nVERIFYING\n")
+    df[FV.WS] = df["REWS"]
+    df[FV.AMB_WS] = df["AMB_REWS"]
+
+    delta = df - fdata
+    print(delta)
+
+    chk = delta.abs()
+    print(chk.max())
+
+    var = FV.WS
+    print(f"\nCHECKING {var}")
+    sel = chk[var] >= 3e-3
+    print(df.loc[sel])
+    print(fdata.loc[sel])
+    print(chk.loc[sel])
+    assert (chk[var] < 3e-3).all()
+
+    var = FV.TI
+    print(f"\nCHECKING {var}")
+    sel = chk[var] >= 3e-4
+    print(df.loc[sel])
+    print(fdata.loc[sel])
+    print(chk.loc[sel])
+    assert (chk[var] < 3e-4).all()
+
+    var = FV.CT
+    print(f"\nCHECKING {var}")
+    sel = chk[var] >= 3e-5
+    print(df.loc[sel])
+    print(fdata.loc[sel])
+    print(chk.loc[sel])
+    assert (chk[var] < 3e-5).all()
+
+
+if __name__ == "__main__":
+    test()

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

@@ -0,0 +1,92 @@
+import numpy as np
+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=1
+    )
+    args = parser.parse_args()
+
+    n_s = 800
+    n_t = 76
+    c = args.chunksize
+    p0 = np.array([0.0, 0.0])
+    stp = np.array([497.0, 0.0])
+    tfile = "../NREL-5MW-D126-H90.csv"
+    ofile = Path(args.ofile)
+
+    # 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_turbine_row(
+        farm,
+        rotor_diameter=126.0,
+        hub_height=90.0,
+        rotor_model="centre",
+        wake_models=["Jensen007_rotor"],
+        turbine_models=["ct_P_curves"],
+        base_point=p0,
+        step_vector=stp,
+        steps=n_t - 1,
+    )
+
+    # create states:
+    ws0 = 3.0
+    ws1 = 30.0
+    states = fl.input.AFSScan(
+        ws_min=ws0,
+        ws_delta=(ws1 - ws0) / (n_s - 1),
+        ws_n_bins=n_s,
+        func_pdf_ws=None,
+        wd_min=270.0,
+        wd_delta=1.0,
+        wd_n_bins=1,
+        func_pdf_wd=None,
+        ti_min=0.08,
+        ti_delta=0.01,
+        ti_n_bins=1,
+        func_pdf_ti=None,
+        rho_min=1.225,
+        rho_delta=0.001,
+        rho_n_bins=1,
+        func_pdf_rho=None,
+        max_chunk_size=c,
+    )
+    states.initialize()
+
+    time0 = time.time()
+
+    # run calculation:
+    results = farm.calculate(mbook, states, wake_superp=["wind_quadratic"])
+
+    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/row_Jensen_quadratic_centre/test_row_Jensen_quadratic_centre.py

@@ -0,0 +1,93 @@
+import numpy as np
+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():
+    n_s = 800
+    n_t = 76
+    c = 1000
+    p0 = np.array([0.0, 0.0])
+    stp = np.array([497.0, 0.0])
+    cfile = thisdir / "flappy" / "results.csv.gz"
+    tfile = thisdir / "NREL-5MW-D126-H90.csv"
+
+    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.ScanWS(
+        ws_list=np.linspace(3.0, 30.0, 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=[ttype.name],
+        verbosity=0,
+    )
+
+    algo = foxes.algorithms.Downwind(
+        farm,
+        states,
+        mbook=mbook,
+        rotor_model="centre",
+        wake_models=["Jensen_quadratic_k007"],
+        wake_frame="rotor_wd",
+        partial_wakes={"Jensen_linear_k007": "centre"},
+        verbosity=0,
+    )
+
+    data = algo.calc_farm()
+
+    df = data.to_dataframe()[[FV.WD, FV.AMB_REWS, FV.REWS, FV.AMB_P, FV.P]]
+
+    print("\nReading file", cfile)
+    fdata = pd.read_csv(cfile).set_index(["state", "turbine"])
+
+    print()
+    print("TRESULTS\n")
+    sel = (df[FV.P] > 0) & (fdata[FV.P] > 0)
+    df = df.loc[sel]
+    fdata = fdata.loc[sel]
+    print(df.loc[sel])
+    print(fdata.loc[sel])
+
+    print("\nVERIFYING\n")
+    df[FV.WS] = df["REWS"]
+    df[FV.AMB_WS] = df["AMB_REWS"]
+
+    delta = df - fdata
+    print(delta)
+
+    chk = delta.abs()
+    print(chk.max())
+
+    var = FV.WS
+    print(f"\nCHECKING {var}")
+    sel = chk[var] >= 1e-7
+    print(df.loc[sel])
+    print(fdata.loc[sel])
+    print(chk.loc[sel])
+    assert (chk[var] < 1e-7).all()
+
+    var = FV.P
+    sel = chk[var] >= 1e-5
+    print(f"\nCHECKING {var}\n", delta.loc[sel])
+    assert (chk[var] < 1e-5).all()
+
+
+if __name__ == "__main__":
+    test()

tests/1_verification/flappy_0_6_2/grid_rotors/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", "--opath", help="The output file path", default=".")
+    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])
+    opath = Path(args.opath)
+    tfile = "../NREL-5MW-D126-H90.csv"
+    sfile = "../states.csv.gz"
+    lfile = "../test_farm.csv"
+    cases = [
+        (["Bastankhah_rotor"], ["wind_linear"], "centre"),
+        (["Bastankhah_rotor"], ["wind_linear"], "grid4"),
+        (["Bastankhah_rotor"], ["wind_linear"], "grid16"),
+        (["Bastankhah_rotor"], ["wind_linear"], "grid64"),
+    ]
+
+    # init flappy:
+    fl.init_flappy(n_cpus=args.n_cpus)
+
+    for i, (wakes, superp, rotor) in enumerate(cases):
+        print(f"\nCase {(wakes, superp, rotor)}")
+
+        # 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=rotor,
+            wake_models=wakes,
+            turbine_models=["ct_P_curves"],
+            output_level=0,
+        )
+
+        # create states:
+        states = fl.input.AFSStatesTable(
+            data_file=sfile,
+            col_wd="wd",
+            col_ws_ref="ws",
+            col_ti="ti",
+            col_weight="weight",
+            air_density=1.225,
+            z0=0.1,
+            h_ref=100.0,
+            max_chunk_size=args.chunksize,
+            output_level=0,
+        )
+        states.initialize()
+
+        # run calculation:
+        results = farm.calculate(mbook, states, wake_superp=superp, output_level=0)
+
+        df = results.state_turbine_results[[FV.WD, FV.AMB_WS, FV.WS, FV.AMB_P, FV.P]]
+
+        ofile = opath / f"results_{i}.csv.gz"
+        print(f"Writing file {ofile}")
+        df.to_csv(ofile)
+
+    # close flappy:
+    fl.shutdown_flappy()

tests/1_verification/flappy_0_6_2/grid_rotors/test_grid_rotors.py

@@ -0,0 +1,130 @@
+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 = 500
+    cpath = thisdir / "flappy"
+    tfile = thisdir / "NREL-5MW-D126-H90.csv"
+    sfile = thisdir / "states.csv.gz"
+    lfile = thisdir / "test_farm.csv"
+    cases = [
+        (["Basta"], "centre", "rotor_points"),
+        (["Basta"], "grid4", "grid4"),
+        (["Basta"], "grid16", "grid16"),
+        (["Basta"], "grid64", "grid64"),
+    ]
+
+    ck = {FC.STATE: c}
+
+    for i, (wakes, rotor, pwake) in enumerate(cases):
+        print(f"\nENTERING CASE {(wakes, rotor, pwake)}\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
+
+        mbook.wake_models["Basta"] = foxes.models.wake_models.wind.Bastankhah2014(
+            sbeta_factor=0.25, superposition="ws_linear", induction="Betz"
+        )
+
+        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, FV.Z0: 0.1, FV.H: 100.0},
+            profiles={FV.WS: "ABLLogNeutralWsProfile"},
+        )
+
+        farm = foxes.WindFarm()
+        foxes.input.farm_layout.add_from_file(
+            farm,
+            lfile,
+            turbine_models=["kTI_amb_02", ttype.name],
+            verbosity=1,
+        )
+
+        algo = foxes.algorithms.Downwind(
+            farm,
+            states,
+            mbook=mbook,
+            rotor_model=rotor,
+            wake_models=wakes,
+            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]
+        ]
+
+        cfile = cpath / f"results_{i}.csv.gz"
+        print("\nReading file", cfile)
+        fdata = pd.read_csv(cfile).set_index(["state", "turbine"])
+
+        print()
+        print("TRESULTS\n")
+        print(df)
+        print(fdata)
+
+        print("\nVERIFYING\n")
+        df[FV.WS] = df["REWS"]
+        df[FV.AMB_WS] = df["AMB_REWS"]
+
+        delta = df - fdata
+        print(delta)
+        chk = delta[[FV.AMB_WS, FV.AMB_P, FV.WS, FV.P]]
+        print(chk)
+        chk = chk.abs()
+        print(chk.max())
+
+        var = FV.AMB_WS
+        sel = chk[var] >= 1e-7
+        print(f"\nCHECKING {var}, {(wakes, rotor, pwake)}\n")
+        print(df.loc[sel])
+        print(fdata.loc[sel])
+        print(delta.loc[sel])
+        assert (chk[var] < 1e-7).all()
+
+        var = FV.AMB_P
+        sel = chk[var] >= 1e-5
+        print(f"\nCHECKING {var}, {(wakes, rotor, pwake)}\n")
+        print(df.loc[sel])
+        print(fdata.loc[sel])
+        print(delta.loc[sel])
+        assert (chk[var] < 1e-5).all()
+
+        var = FV.WS
+        sel = chk[var] >= 1.7e-3
+        print(f"\nCHECKING {var}, {(wakes, rotor, pwake)}\n")
+        print(df.loc[sel])
+        print(fdata.loc[sel])
+        print(delta.loc[sel])
+        assert (chk[var] < 1.7e-3).all()
+
+        var = FV.P
+        sel = chk[var] >= 1.51
+        print(f"\nCHECKING {var}, {(wakes, rotor, pwake)}\n")
+        print(df.loc[sel])
+        print(fdata.loc[sel])
+        print(delta.loc[sel])
+        assert (chk[var] < 1.51).all()
+
+        print()
+
+
+if __name__ == "__main__":
+    test()

tests/1_verification/flappy_0_6_2/row_Bastankhah_Crespo/flappy/run.py

@@ -0,0 +1,96 @@
+import numpy as np
+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(
+        "-o", "--ofile", help="The output file name", default="results.csv.gz"
+    )
+    parser.add_argument(
+        "--n_cpus", help="The number of processors", type=int, default=1
+    )
+    args = parser.parse_args()
+
+    n_s = 30
+    n_t = 52
+    wd = 270.0
+    ti = 0.08
+    rotor = "centre"
+    c = 100
+    p0 = np.array([0.0, 0.0])
+    stp = np.array([601.0, 15.0])
+    tfile = "../NREL-5MW-D126-H90.csv"
+    ofile = Path(args.ofile)
+
+    # 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_turbine_row(
+        farm,
+        rotor_diameter=126.0,
+        hub_height=90.0,
+        rotor_model=rotor,
+        wake_models=["Bastankhah", "CrespoHernandez"],
+        turbine_models=["ct_P_curves"],
+        base_point=p0,
+        step_vector=stp,
+        steps=n_t - 1,
+    )
+
+    # create states:
+    ws0 = 6.0
+    ws1 = 16.0
+    states = fl.input.AFSScan(
+        ws_min=ws0,
+        ws_delta=(ws1 - ws0) / (n_s - 1),
+        ws_n_bins=n_s,
+        func_pdf_ws=None,
+        wd_min=wd,
+        wd_delta=1.0,
+        wd_n_bins=1,
+        func_pdf_wd=None,
+        ti_min=ti,
+        ti_delta=0.01,
+        ti_n_bins=1,
+        func_pdf_ti=None,
+        rho_min=1.225,
+        rho_delta=0.001,
+        rho_n_bins=1,
+        func_pdf_rho=None,
+        max_chunk_size=c,
+    )
+    states.initialize()
+
+    time0 = time.time()
+
+    # run calculation:
+    results = farm.calculate(mbook, states, wake_superp=["wind_quadratic", "ti_max"])
+
+    time1 = time.time()
+    print("\nCalc time =", time1 - time0, "\n")
+
+    df = results.state_turbine_results[
+        [FV.WD, FV.AMB_WS, FV.WS, FV.AMB_TI, FV.TI, FV.AMB_CT, FV.CT]
+    ]
+
+    print(results.turbine_results[[FV.X, FV.Y]])
+
+    print()
+    print("TRESULTS\n")
+    print(df)
+
+    print("\nWriting file", ofile)
+    df.to_csv(ofile)
+
+    # close flappy:
+    fl.shutdown_flappy()