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

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()

tests/1_verification/flappy_0_6/partial_top_hat/test_partial_top_hat.py

@@ -0,0 +1,82 @@
+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"
+    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],
+        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]]
+
+    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)[[FV.AMB_WS, FV.AMB_P, FV.WS, FV.P]]
+    print("\nDELTA\n", delta.describe())
+
+    chk = delta.abs().max()
+    print("\nCHK\n", chk)
+    print("CHK WS =", chk[FV.WS])
+    print("CHK P =", chk[FV.P])
+
+    assert chk[FV.WS] < 1e-5
+    assert chk[FV.P] < 1e-3
+
+
+if __name__ == "__main__":
+    test()

tests/1_verification/flappy_0_6/row_Jensen_linear_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_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/row_Jensen_linear_centre/test_row_Jensen_linear_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_linear_k007"],
+        wake_frame="rotor_wd",
+        partial_wakes={"Jensen_linear_k007": "rotor_points"},
+        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()