foxes 0.7.1__py3-none-any.whl → 0.7.3__py3-none-any.whl

foxes/models/wake_superpositions/ws_pow.py

@@ -184,6 +184,7 @@ class WSPow(WakeSuperposition):
             w = np.minimum(w, self.lim_high - amb_results)
         return w
 
+
 class WSPowLocal(WakeSuperposition):
     """
     Local power supersposition of wind deficit results

foxes/models/wake_superpositions/ws_quadratic.py

@@ -179,6 +179,7 @@ class WSQuadratic(WakeSuperposition):
             w = np.minimum(w, self.lim_high - amb_results)
         return w
 
+
 class WSQuadraticLocal(WakeSuperposition):
     """
     Local quadratic supersposition of wind deficit results

foxes/output/grids.py

@@ -108,12 +108,12 @@ def get_grid_xy(
     n_states = farm_results[FV.H].shape[0]
 
     # get base rectangle:
-    x_min = xmin if xmin is not None else farm_results[FV.X].min() - xspace
-    y_min = ymin if ymin is not None else farm_results[FV.Y].min() - yspace
-    z_min = z if z is not None else farm_results[FV.H].min()
-    x_max = xmax if xmax is not None else farm_results[FV.X].max() + xspace
-    y_max = ymax if ymax is not None else farm_results[FV.Y].max() + yspace
-    z_max = z if z is not None else farm_results[FV.H].max()
+    x_min = xmin if xmin is not None else farm_results[FV.X].min().to_numpy() - xspace
+    y_min = ymin if ymin is not None else farm_results[FV.Y].min().to_numpy() - yspace
+    z_min = z if z is not None else farm_results[FV.H].min().to_numpy()
+    x_max = xmax if xmax is not None else farm_results[FV.X].max().to_numpy() + xspace
+    y_max = ymax if ymax is not None else farm_results[FV.Y].max().to_numpy() + yspace
+    z_max = z if z is not None else farm_results[FV.H].max().to_numpy()
 
     x_pos, x_res = np.linspace(
         x_min,

foxes/output/output.py

@@ -97,13 +97,13 @@ class Output:
             print(n)
 
     @classmethod
-    def new(cls, model_type, *args, **kwargs):
+    def new(cls, output_type, *args, **kwargs):
         """
         Run-time output model factory.
 
         Parameters
         ----------
-        model_type: string
+        output_type: string
             The selected derived class name
         args: tuple, optional
             Additional parameters for the constructor
@@ -112,19 +112,19 @@ class Output:
 
         """
 
-        if model_type is None:
+        if output_type is None:
             return None
 
         allc = all_subclasses(cls)
-        found = model_type in [scls.__name__ for scls in allc]
+        found = output_type in [scls.__name__ for scls in allc]
 
         if found:
             for scls in allc:
-                if scls.__name__ == model_type:
+                if scls.__name__ == output_type:
                     return scls(*args, **kwargs)
 
         else:
             estr = "Output type '{}' is not defined, available types are \n {}".format(
-                model_type, sorted([i.__name__ for i in allc])
+                output_type, sorted([i.__name__ for i in allc])
             )
             raise KeyError(estr)

foxes/utils/__init__.py

@@ -7,7 +7,7 @@ from .pandas_utils import PandasFileHelper
 from .xarray_utils import write_nc
 from .subclasses import all_subclasses
 from .dict import Dict
-from .factory import Factory, FDict
+from .factory import Factory, FDict, WakeKFactory
 from .data_book import DataBook
 from .cubic_roots import cubic_roots
 from .geopandas_utils import read_shp, shp2csv, read_shp_polygons, shp2geom2d

foxes/utils/factory.py

@@ -1,10 +1,12 @@
 from .dict import Dict
+import foxes.variables as FV
+
 
 class Factory:
     """
-    Constructs objects from a choice of allowed 
+    Constructs objects from a choice of allowed
     constructor parameters
-    
+
     Attributes
     ----------
     base: class
@@ -22,25 +24,26 @@ class Factory:
         Hints for print_toc, only for variables for which the
         options are functions or missing
     options: dict
-        For each variable, e.g. A, B or C, the list or dict 
+        For each variable, e.g. A, B or C, the list or dict
         or function that maps a str to the actual value
 
     :group: utils
-    
+
     """
+
     def __init__(
-            self,
-            base,
-            name_template,
-            args=(),
-            kwargs={},
-            var2arg={},
-            hints={},
-            **options,
-        ):
+        self,
+        base,
+        name_template,
+        args=(),
+        kwargs={},
+        var2arg={},
+        hints={},
+        **options,
+    ):
         """
         Constructor.
-        
+
         Parameters
         ----------
         base: class
@@ -58,9 +61,9 @@ class Factory:
             Hints for print_toc, only for variables for which the
             options are functions or missing
         options: dict
-            For each variable, e.g. A, B or C, the list or dict 
+            For each variable, e.g. A, B or C, the list or dict
             or function that maps a str to the actual value
-        
+
         """
         self.base = base
         self.name_template = name_template
@@ -69,17 +72,21 @@ class Factory:
         self.var2arg = var2arg
         self.hints = hints
 
-        parts = name_template.split(">")
-        if len(parts) < 2:
-            raise ValueError(f"Factory '{name_template}': Expecting at least one variable in template, pattern '<..>'")
-
         self._vars = []
         self._pre = []
+        parts = name_template.split(">")
+
         for i, p in enumerate(parts):
             if i < len(parts) - 1:
                 parts2 = p.split("<")
                 if len(parts2) != 2:
-                    raise ValueError(f"Factory '{name_template}': incomplete pattern brackets '<..>'")
+                    raise ValueError(
+                        f"Factory '{name_template}': incomplete pattern brackets '<..>' between variables, e.g. '_'"
+                    )
+                if i > 0 and len(parts2[0]) == 0:
+                    raise ValueError(
+                        f"Factory '{name_template}': Missing seperator like '_' in template between variables '{self._vars[-1]}' and '{parts[1]}'"
+                    )
                 self._pre.append(parts2[0])
                 self._vars.append(parts2[1])
             else:
@@ -89,34 +96,42 @@ class Factory:
             for vi, v in enumerate(self.variables):
                 p = self._pre[vi]
                 if vi < len(self.variables) - 1 and p == "":
-                    raise ValueError(f"Factory '{name_template}': Require indicator before variable '{v}' in template, e.g. '{v}<{v}>'")
-        
+                    raise ValueError(
+                        f"Factory '{name_template}': Require indicator before variable '{v}' in template, e.g. '{v}<{v}>'"
+                    )
+
         self.options = Dict(name=f"{self._pre[0]}_options")
-        for v, o  in options.items():
+        for v, o in options.items():
             if v not in self.variables:
-                raise KeyError(f"Factory '{name_template}': Variable '{v}' found in options, but not in template")
+                raise KeyError(
+                    f"Factory '{name_template}': Variable '{v}' found in options, but not in template"
+                )
             if isinstance(o, list) or isinstance(o, tuple):
                 o = {str(k): k for k in o}
             if isinstance(o, dict):
                 for k in o.keys():
                     if not isinstance(k, str):
-                        raise TypeError(f"Factory '{name_template}': Found option for variable '{v}' that is not a str, {k}")
+                        raise TypeError(
+                            f"Factory '{name_template}': Found option for variable '{v}' that is not a str, {k}"
+                        )
                 self.options[v] = Dict(name=f"{self._pre[0]}_options_{v}", **o)
             elif hasattr(o, "__call__"):
                 self.options[v] = o
             else:
-                raise ValueError(f"Factory '{name_template}': Variable '{v}' has option of type '{type(v).__name__}'. Only list, tuple, dict or function are supported")
-    
+                raise ValueError(
+                    f"Factory '{name_template}': Variable '{v}' has option of type '{type(v).__name__}'. Only list, tuple, dict or function are supported"
+                )
+
     @property
     def name_prefix(self):
         """
         The beginning of the name template
-        
+
         Returns
         -------
         nbase: str
             The beginning of the name template
-        
+
         """
         return self._pre[0]
 
@@ -124,30 +139,30 @@ class Factory:
     def name_suffix(self):
         """
         The ending of the name template
-        
+
         Returns
         -------
         nbase: str
             The ending of the name template
-        
+
         """
         return self._pre[-1]
-    
+
     @property
     def variables(self):
         """
         The list of variables
-        
+
         Returns
         -------
         vrs: list of str
             The variables
-        
+
         """
         return self._vars
-    
+
     def __str__(self):
-        """ String representation """
+        """String representation"""
         s = f"{self.name_template}: {self.base.__name__} with"
         for k, d in self.kwargs.items():
             s += f"\n  {k}={d}"
@@ -157,11 +172,11 @@ class Factory:
             else:
                 s += f"\n  {v}={self.hints.get(v, '(value)')}"
         return s
-    
+
     def check_match(self, name):
         """
         Tests if a name matches the template
-        
+
         Parameters
         ----------
         name: str
@@ -171,7 +186,7 @@ class Factory:
         -------
         success: bool
             True if the template is matched
-        
+
         """
         data_str = name
         for vi in range(len(self.variables)):
@@ -182,7 +197,7 @@ class Factory:
                 return False
             data_str = data_str[j:]
 
-            q = self._pre[vi+1]
+            q = self._pre[vi + 1]
             if q != "":
                 i = data_str.find(q)
                 j = i + len(q)
@@ -190,47 +205,42 @@ class Factory:
                     return False
             else:
                 data_str = ""
-        
+
         return True
 
     def construct(self, name):
         """
         Create an object of the base class.
-        
+
         Parameters
         ----------
         name: str
             The name, matching the template
-        
+
         Returns
         -------
         obj: object
             The instance of the base class
-        
+
         """
-        data_str = name
+        j = 0
         wlist = []
-        for vi, v in enumerate(self.variables):
-            p = self._pre[vi]
-            i = data_str.find(p)
-            j = i + len(p)
-            if i < 0 or len(data_str) <= j:
-                raise ValueError(f"Factory '{self.name_template}': Name '{name}' not matching template")
-            data_str = data_str[j:]
-
-            q = self._pre[vi+1]
-            if q != "":
-                i = data_str.find(q)
-                j = i + len(q)
-                if i < 0 or len(data_str) <= j:
-                    raise ValueError(f"Factory '{self.name_template}': Name '{name}' not matching template")
-                wlist.append(data_str[:i])
+        for pi, p in enumerate(self._pre):
+            if len(p) > 0:
+                i = name[j:].find(p)
+                if i < 0 or (pi == 0 and i > 0):
+                    raise ValueError(
+                        f"Factory '{self.name_template}': Name '{name}' not matching template"
+                    )
+                w = name[j : j + i]
+                j += i + len(p)
             else:
-                wlist.append(data_str)
-                data_str = ""
+                w = name[j:]
+            if pi > 0:
+                wlist.append(w)
 
         kwargs = {}
-        for vi, v in enumerate(self.variables):          
+        for vi, v in enumerate(self.variables):
             w = self.var2arg.get(v, v)
             data = wlist[vi]
             if v in self.options:
@@ -246,24 +256,206 @@ class Factory:
 
         return self.base(*self.args, **kwargs)
 
+
+class WakeKFactory:
+    """
+    A factory that automatically handles
+    wake_k parameters
+
+    Attributes
+    ----------
+    factories: list of Factory
+        The individual factories
+
+    :group: utils
+
+    """
+
+    def __init__(self, base, name_template, *args, hints={}, **kwargs):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        base: class
+            The class of which objects are to be created
+        name_template: str
+            The name template, e.g. 'name_<A>_<B>_<C>' for
+            variables A, B, C. Indicate wake_k part by '_[wake_k]'
+        args: tuple, optional
+            Additional arguments for Factory
+        hints: dict
+            Hints for print_toc, only for variables for which the
+            options are functions or missing
+        kwargs: dict
+            Additional arguments for Factory
+
+        """
+        self._base = base
+        self._kwargs = kwargs
+        self._template0 = name_template
+        self.factories = []
+
+        i0 = name_template.find("_[wake_k]")
+        i1 = i0 + len("_[wake_k]")
+        kw = kwargs.pop("kwargs", {})
+
+        if i0 < 0:
+            raise ValueError(
+                f"String '_[wake_k]' not found in name template '{name_template}'"
+            )
+
+        # add case ka, kb:
+        t = name_template[:i0] + "_ka<ka>_kb<kb>"
+        if len(name_template) > i1:
+            t += name_template[i1:]
+        h = hints.copy()
+        h["ka"] = "(Value, e.g. 04 for 0.4)"
+        h["kb"] = "(Value, e.g. 001 for 0.01)"
+        kw["ti_var"] = FV.TI
+        self.factories.append(
+            Factory(
+                base,
+                t,
+                *args,
+                hints=h,
+                kwargs=kw.copy(),
+                **kwargs,
+                ka=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
+                kb=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
+            )
+        )
+
+        # add case ambient ka, kb:
+        t = name_template[:i0] + "_ambka<ka>_kb<kb>"
+        if len(name_template) > i1:
+            t += name_template[i1:]
+        h = hints.copy()
+        h["ka"] = "(Value, e.g. 04 for 0.4)"
+        h["kb"] = "(Value, e.g. 001 for 0.01)"
+        kw["ti_var"] = FV.AMB_TI
+        self.factories.append(
+            Factory(
+                base,
+                t,
+                *args,
+                hints=h,
+                kwargs=kw.copy(),
+                **kwargs,
+                ka=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
+                kb=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
+            )
+        )
+
+        # add case ka:
+        t = name_template[:i0] + "_ka<ka>"
+        if len(name_template) > i1:
+            t += name_template[i1:]
+        h = hints.copy()
+        h["ka"] = "(Value, e.g. 04 for 0.4)"
+        kw["ti_var"] = FV.TI
+        self.factories.append(
+            Factory(
+                base,
+                t,
+                *args,
+                hints=h,
+                kwargs=kw.copy(),
+                **kwargs,
+                ka=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
+            )
+        )
+
+        # add case ka:
+        t = name_template[:i0] + "_ambka<ka>"
+        if len(name_template) > i1:
+            t += name_template[i1:]
+        h = hints.copy()
+        h["ka"] = "(Value, e.g. 04 for 0.4)"
+        kw["ti_var"] = FV.AMB_TI
+        self.factories.append(
+            Factory(
+                base,
+                t,
+                *args,
+                hints=h,
+                kwargs=kw.copy(),
+                **kwargs,
+                ka=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
+            )
+        )
+
+        # add case k:
+        t = name_template[:i0] + "_k<k>"
+        if len(name_template) > i1:
+            t += name_template[i1:]
+        h = hints.copy()
+        h["k"] = "(Value, e.g. 004 for 0.04)"
+        kw["ti_var"] = FV.TI
+        self.factories.append(
+            Factory(
+                base,
+                t,
+                *args,
+                hints=h,
+                kwargs=kw.copy(),
+                **kwargs,
+                k=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
+            )
+        )
+
+        # add case without k:
+        t = name_template[:i0]
+        if len(name_template) > i1:
+            t += name_template[i1:]
+        kw["ti_var"] = FV.TI
+        self.factories.append(
+            Factory(
+                base,
+                t,
+                *args,
+                hints=hints,
+                kwargs=kw.copy(),
+                **kwargs,
+            )
+        )
+
+    def __str__(self):
+        """String representation"""
+        s = f"{self._template0}: {self._base.__name__} with"
+        for k, d in self._kwargs.items():
+            s += f"\n  {k}={d}"
+        f0 = self.factories[-1]
+        for v in f0.variables:
+            if v in f0.options and isinstance(f0.options[v], dict):
+                s += f"\n  {v} from {list(f0.options[v])}"
+            else:
+                s += f"\n  {v}={f0.hints.get(v, '(value)')}"
+        s += (
+            f"\n  [wake_k]=(None or k<k> or ka<ka> or ka<ka>_kb<kb>, e.g. 004 for 0.04)"
+        )
+        return s
+
+
 class FDict(Dict):
     """
     A dictionary with factory support
-    
+
     Attributes
     ----------
     store_created: bool
         Flag for storing created objects
     factories: list of foxes.utils.Factory
         The factories
-    
+
     :group: utils
-    
+
     """
+
     def __init__(self, *args, store_created=True, **kwargs):
         """
         Constructor.
-        
+
         Parameters
         ----------
         args: tuple, optional
@@ -272,30 +464,32 @@ class FDict(Dict):
             Flag for storing created objects
         kwargs: dict, optional
             Parameters for the base class
-        
+
         """
         super().__init__(*args, **kwargs)
         self.store_created = store_created
         self.factories = []
 
-    def add_factory(self, *args, **kwargs):
+    def add_factory(self, *args, factory=None, **kwargs):
         """
-        Constructor.
-        
+        Adds a Factory object.
+
         Parameters
         ----------
         args: tuple, optional
             Parameters for the Factory constructor
+        factory: Factory, optional
+            The factory object
         kwargs: dict, optional
             Parameters for the Factory constructor
-        
+
         """
-        f = Factory(*args, **kwargs)
+        f = Factory(*args, **kwargs) if factory is None else factory
         i = len(self.factories)
         for gi in range(len(self.factories) - 1, -1, -1):
             g = self.factories[gi]
             if (
-                g.name_prefix == f.name_prefix 
+                g.name_prefix == f.name_prefix
                 and g.name_suffix == f.name_suffix
                 and len(f.variables) > len(g.variables)
             ):
@@ -306,6 +500,21 @@ class FDict(Dict):
         else:
             self.factories.insert(i, f)
 
+    def add_k_factory(self, *args, **kwargs):
+        """
+        Adds a WakeKFactory.
+
+        Parameters
+        ----------
+        args: tuple, optional
+            Parameters for the Factory constructor
+        kwargs: dict, optional
+            Parameters for the Factory constructor
+
+        """
+        for f in WakeKFactory(*args, **kwargs).factories:
+            self.add_factory(factory=f)
+
     def __contains__(self, key):
         found = super().__contains__(key)
         if not found:
@@ -330,4 +539,3 @@ class FDict(Dict):
         k = ", ".join(sorted(list(self.keys())))
         e = f"{self.name}: Cannot find key '{key}', also no factory matches. Known keys: {k}. Known factories: {[f.name_template for f in self.factories]}"
         raise KeyError(e)
-                

{foxes-0.7.1.dist-info → foxes-0.7.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foxes
-Version: 0.7.1
+Version: 0.7.3
 Summary: Farm Optimization and eXtended yield Evaluation Software
 Author: Fraunhofer IWES
 Author-email: jonas.schmidt@iwes.fraunhofer.de
@@ -17,16 +17,18 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: matplotlib
-Requires-Dist: numpy
+Requires-Dist: numpy <2
+Requires-Dist: pandas
 Requires-Dist: xarray
-Requires-Dist: dask[distributed]
+Requires-Dist: dask
+Requires-Dist: distributed
 Requires-Dist: scipy
 Requires-Dist: netcdf4
 Requires-Dist: windrose
 Requires-Dist: iwopy >=0.1.4
 Requires-Dist: pyarrow
 Provides-Extra: all
-Requires-Dist: windio >=1.0 ; extra == 'all'
+Requires-Dist: windio >=1 ; extra == 'all'
 Requires-Dist: flake8 ; extra == 'all'
 Requires-Dist: pytest ; extra == 'all'
 Requires-Dist: pymoo >=0.6 ; extra == 'all'
@@ -45,7 +47,7 @@ Requires-Dist: ipywidgets ; extra == 'doc'
 Requires-Dist: m2r2 ; extra == 'doc'
 Requires-Dist: lxml-html-clean ; extra == 'doc'
 Provides-Extra: io
-Requires-Dist: windio >=1.0 ; extra == 'io'
+Requires-Dist: windio >=1 ; extra == 'io'
 Provides-Extra: scripts
 Provides-Extra: test
 Requires-Dist: flake8 ; extra == 'test'
@@ -170,7 +172,7 @@ The supported Python versions are:
 - `Python 3.11`
 - `Python 3.12`
 
-### Preparation
+### Preparation (optional)
 
 It is strongly recommend to use the `libmamba` dependency solver instead of the default solver. Install it once by