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

foxes/engines/numpy.py

@@ -1,5 +1,6 @@
 from tqdm import tqdm
 from xarray import Dataset
+from tqdm import tqdm
 
 from foxes.core import Engine
 import foxes.constants as FC
@@ -15,28 +16,6 @@ class NumpyEngine(Engine):
 
     """
 
-    def __init__(self, *args, **kwargs):
-        """
-        Constructor.
-
-        Parameters
-        ----------
-        args: tuple, optional
-            Additional parameters for the base class
-        kwargs: dict, optional
-            Additional parameters for the base class
-
-        """
-        ignr = ["n_procs"]
-        for k in ignr:
-            if kwargs.pop(k, None) is not None:
-                print(f"{type(self).__name__}: Ignoring {k}")
-        super().__init__(
-            *args,
-            n_procs=1,
-            **kwargs,
-        )
-
     def run_calculation(
         self,
         algo,
@@ -117,14 +96,18 @@ class NumpyEngine(Engine):
         n_chunks_states = len(chunk_sizes_states)
         n_chunks_targets = len(chunk_sizes_targets)
         self.print(
-            f"Selecting n_chunks_states = {n_chunks_states}, n_chunks_targets = {n_chunks_targets}",
+            f"{type(self).__name__}: Selecting n_chunks_states = {n_chunks_states}, n_chunks_targets = {n_chunks_targets}",
             level=2,
         )
 
         # prepare and submit chunks:
         n_chunks_all = n_chunks_states * n_chunks_targets
-        self.print(f"Looping over {n_chunks_all} chunks")
-        pbar = tqdm(total=n_chunks_all) if self.verbosity > 1 else None
+        self.print(f"{type(self).__name__}: Looping over {n_chunks_all} chunks")
+        pbar = (
+            tqdm(total=n_chunks_all)
+            if self.verbosity > 0 and n_chunks_all > 1
+            else None
+        )
         results = {}
         i0_states = 0
         for chunki_states in range(n_chunks_states):
@@ -134,7 +117,6 @@ class NumpyEngine(Engine):
                 i1_targets = i0_targets + chunk_sizes_targets[chunki_points]
 
                 i = chunki_states * n_chunks_targets + chunki_points
-                self.print(f"Computing chunk {i}/{n_chunks_all}")
 
                 # get this chunk's data:
                 data = self.get_chunk_input_data(

foxes/engines/pool.py

@@ -74,12 +74,13 @@ class PoolEngine(Engine):
         """Shuts down the pool"""
         pass
 
-    def initialize(self):
-        """
-        Initializes the engine.
-        """
-        super().initialize()
+    def __enter__(self):
         self._create_pool()
+        return super().__enter__()
+
+    def __exit__(self, *exit_args):
+        self._shutdown_pool()
+        super().__exit__(*exit_args)
 
     def run_calculation(
         self,
@@ -161,14 +162,15 @@ class PoolEngine(Engine):
         n_chunks_states = len(chunk_sizes_states)
         n_chunks_targets = len(chunk_sizes_targets)
         self.print(
-            f"Selecting n_chunks_states = {n_chunks_states}, n_chunks_targets = {n_chunks_targets}",
+            f"{type(self).__name__}: Selecting n_chunks_states = {n_chunks_states}, n_chunks_targets = {n_chunks_targets}",
             level=2,
         )
 
         # prepare and submit chunks:
         n_chunks_all = n_chunks_states * n_chunks_targets
         self.print(
-            f"Submitting {n_chunks_all} chunks to {self.n_procs} processes", level=2
+            f"{type(self).__name__}: Submitting {n_chunks_all} chunks to {self.n_procs} processes",
+            level=2,
         )
         pbar = tqdm(total=n_chunks_all) if self.verbosity > 1 else None
         jobs = {}
@@ -217,7 +219,7 @@ class PoolEngine(Engine):
         # wait for results:
         if n_chunks_all > 1 or self.verbosity > 1:
             self.print(
-                f"Computing {n_chunks_all} chunks using {self.n_procs} processes"
+                f"{type(self).__name__}: Computing {n_chunks_all} chunks using {self.n_procs} processes"
             )
         pbar = (
             tqdm(total=n_chunks_all)
@@ -245,19 +247,3 @@ class PoolEngine(Engine):
             goal_data=goal_data,
             iterative=iterative,
         )
-
-    def finalize(self, *exit_args, **exit_kwargs):
-        """
-        Finalizes the engine.
-
-        Parameters
-        ----------
-        exit_args: tuple, optional
-            Arguments from the exit function
-        exit_kwargs: dict, optional
-            Arguments from the exit function
-
-        """
-        if self.initialized:
-            self._shutdown_pool()
-        super().finalize(*exit_args, **exit_kwargs)

foxes/engines/ray.py

@@ -0,0 +1,79 @@
+from copy import deepcopy
+
+from foxes.utils import import_module
+
+from .pool import PoolEngine
+
+
+ray = None
+
+
+def load_ray():
+    """On-demand loading of the ray package"""
+    global ray
+    if ray is None:
+        ray = import_module("ray", hint="pip install ray")
+
+
+class RayEngine(PoolEngine):
+    """
+    The ray engine for foxes calculations.
+
+    :group: engines
+
+    """
+
+    def _create_pool(self):
+        """Creates the pool"""
+        self.print(f"Initializing pool of {self.n_procs} ray workers")
+        load_ray()
+        ray.init(num_cpus=self.n_procs)
+
+    def _submit(self, f, *args, **kwargs):
+        """
+        Submits to the pool
+
+        Parameters
+        ----------
+        f: Callable
+            The function f(*args, **kwargs) to be
+            submitted
+        args: tuple, optional
+            Arguments for the function
+        kwargs: dict, optional
+            Arguments for the function
+
+        Returns
+        -------
+        future: object
+            The future object
+
+        """
+
+        @ray.remote
+        def f_ray(*args, **kwargs):
+            return f(*deepcopy(args), **deepcopy(kwargs))
+
+        return f_ray.remote(*args, **kwargs)
+
+    def _result(self, future):
+        """
+        Waits for result from a future
+
+        Parameters
+        ----------
+        future: object
+            The future
+
+        Returns
+        -------
+        result: object
+            The calculation result
+
+        """
+        return ray.get(future)
+
+    def _shutdown_pool(self):
+        """Shuts down the pool"""
+        self.print(f"Shutting down pool of {self.n_procs} ray workers")
+        ray.shutdown()

foxes/engines/single.py

@@ -111,7 +111,9 @@ class SingleChunkEngine(Engine):
         # calculate:
 
         if n_states > 1:
-            self.print(f"Running single chunk calculation for {n_states} states")
+            self.print(
+                f"{type(self).__name__}: Running single chunk calculation for {n_states} states"
+            )
 
         data = self.get_chunk_input_data(
             algo=algo,

foxes/input/farm_layout/from_json.py

@@ -35,7 +35,7 @@ def add_from_json(
 
     keys = list(dict.keys())
     if len(keys) != 1:
-        raise KeyError("Only one wind farm supported by flappy at the moment.")
+        raise KeyError("Only one wind farm supported by foxes at the moment.")
 
     farm_name = keys[0]
     fdict = dict[farm_name]

foxes/input/states/__init__.py

@@ -6,6 +6,7 @@ from .single import SingleStateStates
 from .scan_ws import ScanWS
 from .states_table import StatesTable, Timeseries, TabStates
 from .field_data_nc import FieldDataNC
+from .slice_data_nc import SliceDataNC
 from .multi_height import MultiHeightStates, MultiHeightTimeseries
 from .multi_height import MultiHeightNCStates, MultiHeightNCTimeseries
 from .one_point_flow import (

foxes/input/states/field_data_nc.py

@@ -207,7 +207,7 @@ class FieldDataNC(States):
         """
         if self.pre_load and self.running:
             raise ValueError(
-                f"States '{self.name}': Cannot acces data_source while running"
+                f"States '{self.name}': Cannot access data_source while running"
             )
         return self.__data_source
 
@@ -496,7 +496,7 @@ class FieldDataNC(States):
 
         """
         if self.running:
-            raise ValueError(f"States '{self.name}': Cannot acces index while running")
+            raise ValueError(f"States '{self.name}': Cannot access index while running")
         return self.__inds
 
     def output_point_vars(self, algo):
@@ -533,12 +533,12 @@ class FieldDataNC(States):
         """
         if self.running:
             raise ValueError(
-                f"States '{self.name}': Cannot acces weights while running"
+                f"States '{self.name}': Cannot access weights while running"
             )
         return self.__weights
 
     def calculate(self, algo, mdata, fdata, tdata):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,

foxes/input/states/multi_height.py

@@ -124,7 +124,7 @@ class MultiHeightStates(States):
         """
         if self.running:
             raise ValueError(
-                f"States '{self.name}': Cannot acces data_source while running"
+                f"States '{self.name}': Cannot access data_source while running"
             )
         return self._data_source
 
@@ -370,7 +370,7 @@ class MultiHeightStates(States):
 
         """
         if self.running:
-            raise ValueError(f"States '{self.name}': Cannot acces index while running")
+            raise ValueError(f"States '{self.name}': Cannot access index while running")
         return self._inds
 
     def output_point_vars(self, algo):
@@ -407,12 +407,12 @@ class MultiHeightStates(States):
         """
         if self.running:
             raise ValueError(
-                f"States '{self.name}': Cannot acces weights while running"
+                f"States '{self.name}': Cannot access weights while running"
             )
         return self._weights
 
     def calculate(self, algo, mdata, fdata, tdata):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,

foxes/input/states/scan_ws.py

@@ -201,7 +201,7 @@ class ScanWS(States):
         return np.full((self.N, algo.n_turbines), 1.0 / self.N, dtype=FC.DTYPE)
 
     def calculate(self, algo, mdata, fdata, tdata):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,

foxes/input/states/single.py

@@ -166,7 +166,7 @@ class SingleStateStates(States):
         return np.ones((1, algo.n_turbines), dtype=FC.DTYPE)
 
     def calculate(self, algo, mdata, fdata, tdata):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,