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

tests/0_consistency/iterative/test_iterative.py

@@ -3,13 +3,13 @@ import inspect
 
 import foxes
 import foxes.variables as FV
-import foxes.constants as FC
+from foxes.config import config
 
 thisdir = Path(inspect.getfile(inspect.currentframe())).parent
 
 
 def test():
-    c = 1000
+
     ttype = "DTU10MW"
     sfile = "wind_rose_bremen.csv"
     lfile = thisdir / "test_farm.csv"
@@ -20,72 +20,70 @@ def test():
     ]
     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()
+    with foxes.Engine.new("process", chunk_size_states=1000):
+        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",
+                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__":

tests/0_consistency/partial_wakes/test_partial_wakes.py

@@ -3,13 +3,12 @@ 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"
@@ -24,66 +23,64 @@ def test():
         ("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()
+    with foxes.Engine.new("process", chunk_size_states=100):
+        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,
+                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__":

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

@@ -4,7 +4,7 @@ import inspect
 
 import foxes
 import foxes.variables as FV
-import foxes.constants as FC
+from foxes.config import config
 
 thisdir = Path(inspect.getfile(inspect.currentframe())).parent
 
@@ -12,15 +12,12 @@ 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,
@@ -48,55 +45,61 @@ def test():
         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()
+    with foxes.Engine.new("threads", chunk_size_states=1000):
+
+        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"},
+            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__":

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

@@ -4,7 +4,6 @@ import inspect
 
 import foxes
 import foxes.variables as FV
-import foxes.constants as FC
 
 thisdir = Path(inspect.getfile(inspect.currentframe())).parent
 
@@ -16,8 +15,6 @@ def test():
     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
@@ -43,44 +40,47 @@ def test():
         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()
+    with foxes.Engine.new("threads", chunk_size_states=c):
+
+        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"},
+            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__":

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

@@ -4,7 +4,7 @@ import inspect
 
 import foxes
 import foxes.variables as FV
-import foxes.constants as FC
+from foxes.config import config
 
 thisdir = Path(inspect.getfile(inspect.currentframe())).parent
 
@@ -12,14 +12,11 @@ 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
@@ -38,44 +35,47 @@ def test():
         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,
-    )
+    with foxes.Engine.new("threads", chunk_size_states=1000):
+
+        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"},
+            verbosity=0,
+        )
 
-    data = algo.calc_farm()
+        data = algo.calc_farm()
 
-    df = data.to_dataframe()[[FV.AMB_WD, FV.WD, FV.AMB_REWS, FV.REWS, FV.AMB_P, FV.P]]
+        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()
+        print("TRESULTS\n")
+        print(df)
 
-    print("\nReading file", cfile)
-    fdata = pd.read_csv(cfile)
-    print(fdata)
+        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"]
+        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())
+        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])
+        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
+        assert chk[FV.WS] < 1e-5
+        assert chk[FV.P] < 1e-3
 
 
 if __name__ == "__main__":