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

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

tests/1_verification/flappy_0_6/row_Jensen_linear_tophat/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=4
+    )
+    args = parser.parse_args()
+
+    n_s = 1000
+    n_t = 55
+    c = args.chunksize
+    p0 = np.array([0.0, 0.0])
+    stp = np.array([500.0, 80.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"],
+        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_tophat/test_row_Jensen_linear_tophat.py

@@ -0,0 +1,96 @@
+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 = 1000
+    n_t = 55
+    c = 1000
+    p0 = np.array([0.0, 0.0])
+    stp = np.array([500.0, 80.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(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": "top_hat"},
+        chunks=ck,
+        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/row_Jensen_linear_tophat_IECTI2005/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_2005_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_IECTI2005/test_row_Jensen_linear_tophat_IECTI_2005.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,
+        rotor_model="centre",
+        mbook=mbook,
+        wake_models=["Jensen_linear_k007", "IECTI2005_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()