foxes-opt 0.1__tar.gz

foxes_opt-0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 FraunhoferIWES
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

foxes_opt-0.1/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.1
+Name: foxes-opt
+Version: 0.1
+Summary: Wind farm optimization for the FOXES package
+Author: Fraunhofer IWES
+Author-email: jonas.schulte@iwes.fraunhofer.de
+License: MIT
+Project-URL: Source Code, https://github.com/FraunhoferIWES/foxes-opt
+Project-URL: Bug Tracker, https://github.com/FraunhoferIWES/foxes-opt/issues
+Project-URL: Documentation, https://fraunhoferiwes.github.io/foxes.docs/index.html
+Keywords: Wind farm optimization
+Classifier: Topic :: Scientific/Engineering
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: foxes
+Requires-Dist: iwopy>=0.2.2
+Requires-Dist: pymoo
+Provides-Extra: test
+Requires-Dist: flake8; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: doc
+Requires-Dist: sphinx; extra == "doc"
+Requires-Dist: sphinx-immaterial; extra == "doc"
+Requires-Dist: nbsphinx; extra == "doc"
+Requires-Dist: ipykernel; extra == "doc"
+Requires-Dist: ipywidgets; extra == "doc"
+Requires-Dist: m2r2; extra == "doc"
+Requires-Dist: lxml_html_clean; extra == "doc"
+Provides-Extra: all
+Requires-Dist: flake8; extra == "all"
+Requires-Dist: pytest; extra == "all"
+Requires-Dist: sphinx; extra == "all"
+Requires-Dist: sphinx-immaterial; extra == "all"
+Requires-Dist: nbsphinx; extra == "all"
+Requires-Dist: ipykernel; extra == "all"
+Requires-Dist: ipywidgets; extra == "all"
+Requires-Dist: m2r2; extra == "all"
+Requires-Dist: lxml_html_clean; extra == "all"
+Provides-Extra: scripts
+
+# foxes-opt
+
+_Optimization for the [foxes](https://github.com/FraunhoferIWES/foxes) package_
+
+## Installation
+
+Install from pip via
+```console
+pip install foxes-opt
+```
+Install from conda-forge via
+```console
+conda install foxes-opt -c conda-forge
+```

foxes_opt-0.1/README.md

@@ -0,0 +1,14 @@
+# foxes-opt
+
+_Optimization for the [foxes](https://github.com/FraunhoferIWES/foxes) package_
+
+## Installation
+
+Install from pip via
+```console
+pip install foxes-opt
+```
+Install from conda-forge via
+```console
+conda install foxes-opt -c conda-forge
+```

foxes_opt-0.1/foxes_opt/VERSION

@@ -0,0 +1 @@
+0.1

foxes_opt-0.1/foxes_opt/__init__.py

@@ -0,0 +1,9 @@
+"""
+Wind farm optimization.
+"""
+
+from .core import FarmOptProblem, FarmObjective, FarmConstraint
+
+from . import problems
+from . import constraints
+from . import objectives

foxes_opt-0.1/foxes_opt/constraints/__init__.py

@@ -0,0 +1,6 @@
+"""
+Wind farm optimization constraints.
+"""
+
+from .area_geometry import AreaGeometryConstraint, FarmBoundaryConstraint
+from .min_dist import MinDistConstraint

foxes_opt-0.1/foxes_opt/constraints/area_geometry.py

@@ -0,0 +1,214 @@
+import numpy as np
+
+from foxes_opt.core.farm_constraint import FarmConstraint
+import foxes.variables as FV
+
+
+class AreaGeometryConstraint(FarmConstraint):
+    """
+    Constrains turbine positions to the inside
+    of a given area geometry.
+
+    Attributes
+    ----------
+    farm: foxes.WindFarm
+        The wind farm
+    sel_turbines: list
+        The selected turbines
+    geometry: foxes.utils.geom2d.AreaGeometry
+        The area geometry
+    disc_inside: bool
+        Ensure full rotor disc inside boundary
+    D: float
+        Use this radius for rotor disc inside condition
+
+    :group: opt.constraints
+
+    """
+
+    def __init__(
+        self,
+        problem,
+        name,
+        geometry,
+        sel_turbines=None,
+        disc_inside=False,
+        D=None,
+        **kwargs,
+    ):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        problem : foxes_opt.FarmOptProblem
+            The underlying optimization problem
+        name : str
+            The name of the constraint
+        geometry : foxes.utils.geom2d.AreaGeometry
+            The area geometry
+        sel_turbines : list of int, optional
+            The selected turbines
+        disc_inside : bool
+            Ensure full rotor disc inside boundary
+        D : float, optional
+            Use this radius for rotor disc inside condition
+        kwargs : dict, optional
+            Additional parameters for `iwopy.Constraint`
+
+        """
+        self.geometry = geometry
+        self.disc_inside = disc_inside
+        self.D = D
+
+        selt = problem.sel_turbines if sel_turbines is None else sel_turbines
+        vrs = []
+        cns = []
+        for ti in selt:
+            vrs += [problem.tvar(FV.X, ti), problem.tvar(FV.Y, ti)]
+            cns.append(f"{name}_{ti:04d}")
+
+        super().__init__(
+            problem, name, sel_turbines, vnames_float=vrs, cnames=cns, **kwargs
+        )
+
+    def n_components(self):
+        """
+        Returns the number of components of the
+        function.
+
+        Returns
+        -------
+        int:
+            The number of components.
+
+        """
+        return self.n_sel_turbines
+
+    def vardeps_float(self):
+        """
+        Gets the dependencies of all components
+        on the function float variables
+
+        Returns
+        -------
+        deps: numpy.ndarray of bool
+            The dependencies of components on function
+            variables, shape: (n_components, n_vars_float)
+
+        """
+        deps = np.zeros((self.n_components(), self.n_components(), 2), dtype=bool)
+        np.fill_diagonal(deps[:, :, 0], True)
+        np.fill_diagonal(deps[:, :, 1], True)
+        return deps.reshape(self.n_components(), self.n_components() * 2)
+
+    def calc_individual(self, vars_int, vars_float, problem_results, components=None):
+        """
+        Calculate values for a single individual of the
+        underlying problem.
+
+        Parameters
+        ----------
+        vars_int: np.array
+            The integer variable values, shape: (n_vars_int,)
+        vars_float: np.array
+            The float variable values, shape: (n_vars_float,)
+        problem_results: Any
+            The results of the variable application
+            to the problem
+        components: list of int, optional
+            The selected components or None for all
+
+        Returns
+        -------
+        values: np.array
+            The component values, shape: (n_sel_components,)
+
+        """
+        s = np.s_[:]
+        if components is not None and len(components) < self.n_components():
+            s = components
+        xy = vars_float.reshape(self.n_components(), 2)[s]
+
+        dists = self.geometry.points_distance(xy)
+        dists[self.geometry.points_inside(xy)] *= -1
+
+        if self.disc_inside:
+            if self.D is None:
+                dists += problem_results[FV.D].to_numpy()[0, self.sel_turbines][s] / 2
+            else:
+                dists += self.D / 2
+
+        return dists
+
+    def calc_population(self, vars_int, vars_float, problem_results, components=None):
+        """
+        Calculate values for all individuals of a population.
+
+        Parameters
+        ----------
+        vars_int: np.array
+            The integer variable values, shape: (n_pop, n_vars_int)
+        vars_float: np.array
+            The float variable values, shape: (n_pop, n_vars_float)
+        problem_results: Any
+            The results of the variable application
+            to the problem
+        components: list of int, optional
+            The selected components or None for all
+
+        Returns
+        -------
+        values: np.array
+            The component values, shape: (n_pop, n_sel_components)
+
+        """
+        n_pop = len(vars_float)
+        n_cmpnts = self.n_components()
+        s = np.s_[:]
+        if components is not None and len(components) < self.n_components():
+            n_cmpnts = len(components)
+            s = components
+        xy = vars_float[:, s].reshape(n_pop * n_cmpnts, 2)
+
+        dists = self.geometry.points_distance(xy)
+        dists[self.geometry.points_inside(xy)] *= -1
+        dists = dists.reshape(n_pop, n_cmpnts)
+
+        if self.disc_inside:
+            if self.D is None:
+                dists += (
+                    problem_results[FV.D].to_numpy()[None, 0, self.sel_turbines][s] / 2
+                )
+            else:
+                dists += self.D / 2
+
+        return dists
+
+
+class FarmBoundaryConstraint(AreaGeometryConstraint):
+    """
+    Constrains turbine positions to the inside of
+    the wind farm boundary
+
+    :group: opt.constraints
+
+    """
+
+    def __init__(self, problem, name="boundary", **kwargs):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        problem: foxes_opt.FarmOptProblem
+            The underlying optimization problem
+        name: str
+            The name of the constraint
+        kwargs: dict, optional
+            Additional parameters for `AreaGeometryConstraint`
+
+        """
+        b = problem.farm.boundary
+        assert b is not None, f"Constraint '{name}': Missing wind farm boundary."
+        super().__init__(problem, name, geometry=b, **kwargs)

foxes_opt-0.1/foxes_opt/constraints/min_dist.py

@@ -0,0 +1,239 @@
+import numpy as np
+
+from foxes_opt.core.farm_constraint import FarmConstraint
+import foxes.variables as FV
+import foxes.constants as FC
+
+
+class MinDistConstraint(FarmConstraint):
+    """
+    Turbines must keep at least a minimal
+    spatial distance.
+
+    Attributes
+    ----------
+    farm: foxes.WindFarm
+        The wind farm
+    sel_turbines: list
+        The selected turbines
+    min_dist: float
+        The minimal distance
+    min_dist_unit: str
+        The minimal distance unit, either m or D
+
+    :group: opt.constraints
+
+    """
+
+    def __init__(
+        self,
+        problem,
+        min_dist,
+        min_dist_unit="m",
+        name="dist",
+        sel_turbines=None,
+        **kwargs,
+    ):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        problem: foxes_opt.FarmOptProblem
+            The underlying optimization problem
+        min_dist: float
+            The minimal distance
+        min_dist_unit: str
+            The minimal distance unit, either m or D
+        name: str
+            The name of the constraint
+        sel_turbines: list of int, optional
+            The selected turbines
+        kwargs: dict, optional
+            Additional parameters for `iwopy.Constraint`
+
+        """
+        self.min_dist = min_dist
+        self.min_dist_unit = min_dist_unit
+
+        selt = problem.sel_turbines if sel_turbines is None else sel_turbines
+        vrs = []
+        for ti in selt:
+            vrs += [problem.tvar(FV.X, ti), problem.tvar(FV.Y, ti)]
+
+        super().__init__(problem, name, sel_turbines, vnames_float=vrs, **kwargs)
+
+    def initialize(self, verbosity=0):
+        """
+        Initialize the constaint.
+
+        Parameters
+        ----------
+        verbosity: int
+            The verbosity level, 0 = silent
+
+        """
+        N = self.farm.n_turbines
+        self._i2t = []  # i --> (ti, tj)
+        self._t2i = np.full([N, N], -1)  # (ti, tj) --> i
+        i = 0
+        for ti in self.sel_turbines:
+            for tj in range(N):
+                if ti != tj and self._t2i[ti, tj] < 0:
+                    self._i2t.append([ti, tj])
+                    self._t2i[ti, tj] = i
+                    self._t2i[tj, ti] = i
+                    i += 1
+        self._i2t = np.array(self._i2t)
+        self._cnames = [f"{self.name}_{ti}_{tj}" for ti, tj in self._i2t]
+        super().initialize(verbosity)
+
+    def n_components(self):
+        """
+        Returns the number of components of the
+        function.
+
+        Returns
+        -------
+        int:
+            The number of components.
+
+        """
+        return len(self._i2t)
+
+    def vardeps_float(self):
+        """
+        Gets the dependencies of all components
+        on the function float variables
+
+        Returns
+        -------
+        deps: numpy.ndarray of bool
+            The dependencies of components on function
+            variables, shape: (n_components, n_vars_float)
+
+        """
+        turbs = list(self.problem.sel_turbines)
+        deps = np.zeros((self.n_components(), len(turbs), 2), dtype=bool)
+        for i, titj in enumerate(self._i2t):
+            for t in titj:
+                if t in turbs:
+                    j = turbs.index(t)
+                    deps[i, j] = True
+        return deps.reshape(self.n_components(), 2 * len(turbs))
+
+    def calc_individual(self, vars_int, vars_float, problem_results, components=None):
+        """
+        Calculate values for a single individual of the
+        underlying problem.
+
+        Parameters
+        ----------
+        vars_int: np.array
+            The integer variable values, shape: (n_vars_int,)
+        vars_float: np.array
+            The float variable values, shape: (n_vars_float,)
+        problem_results: Any
+            The results of the variable application
+            to the problem
+        components: list of int, optional
+            The selected components or None for all
+
+        Returns
+        -------
+        values: np.array
+            The component values, shape: (n_sel_components,)
+
+        """
+        xy = np.stack(
+            [problem_results[FV.X].to_numpy(), problem_results[FV.Y].to_numpy()],
+            axis=-1,
+        )
+        if not np.all(np.abs(np.min(xy, axis=0) - np.max(xy, axis=0)) < 1e-13):
+            raise ValueError(f"Constraint '{self.name}': Require state independet XY")
+        xy = xy[0]
+
+        s = np.s_[:]
+        if components is not None and len(components) < self.n_components():
+            s = components
+
+        a = np.take_along_axis(xy, self._i2t[s][:, 0, None], axis=0)
+        b = np.take_along_axis(xy, self._i2t[s][:, 1, None], axis=0)
+        d = np.linalg.norm(a - b, axis=-1)
+
+        if self.min_dist_unit == "m":
+            mind = self.min_dist
+
+        elif self.min_dist_unit == "D":
+            D = problem_results[FV.D].to_numpy()
+            if not np.all(np.abs(np.min(D, axis=0) - np.max(D, axis=0)) < 1e-13):
+                raise ValueError(
+                    f"Constraint '{self.name}': Require state independet D"
+                )
+            D = D[0]
+
+            Da = np.take_along_axis(D, self._i2t[s][:, 0], axis=0)
+            Db = np.take_along_axis(D, self._i2t[s][:, 1], axis=0)
+            mind = self.min_dist * np.maximum(Da, Db)
+
+        return mind - d
+
+    def calc_population(self, vars_int, vars_float, problem_results, components=None):
+        """
+        Calculate values for all individuals of a population.
+
+        Parameters
+        ----------
+        vars_int: np.array
+            The integer variable values, shape: (n_pop, n_vars_int)
+        vars_float: np.array
+            The float variable values, shape: (n_pop, n_vars_float)
+        problem_results: Any
+            The results of the variable application
+            to the problem
+        components: list of int, optional
+            The selected components or None for all
+
+        Returns
+        -------
+        values: np.array
+            The component values, shape: (n_pop, n_sel_components)
+
+        """
+        n_pop = problem_results["n_pop"].values
+        n_states = problem_results["n_org_states"].values
+        n_turbines = problem_results.sizes[FC.TURBINE]
+
+        xy = np.stack(
+            [problem_results[FV.X].to_numpy(), problem_results[FV.Y].to_numpy()],
+            axis=-1,
+        )
+        xy = xy.reshape(n_pop, n_states, n_turbines, 2)
+        if not np.all(np.abs(np.min(xy, axis=1) - np.max(xy, axis=1)) < 1e-13):
+            raise ValueError(f"Constraint '{self.name}': Require state independet XY")
+        xy = xy[:, 0]
+
+        s = np.s_[:]
+        if components is not None and len(components) < self.n_components():
+            s = components
+
+        a = np.take_along_axis(xy, self._i2t[s][None, :, 0, None], axis=1)
+        b = np.take_along_axis(xy, self._i2t[s][None, :, 1, None], axis=1)
+        d = np.linalg.norm(a - b, axis=-1)
+
+        if self.min_dist_unit == "m":
+            mind = self.min_dist
+
+        elif self.min_dist_unit == "D":
+            D = problem_results[FV.D].to_numpy().reshape(n_pop, n_states, n_turbines)
+            if not np.all(np.abs(np.min(D, axis=1) - np.max(D, axis=1)) < 1e-13):
+                raise ValueError(
+                    f"Constraint '{self.name}': Require state independet D"
+                )
+            D = D[:, 0]
+
+            Da = np.take_along_axis(D, self._i2t[s][None, :, 0], axis=1)
+            Db = np.take_along_axis(D, self._i2t[s][None, :, 1], axis=1)
+            mind = self.min_dist * np.maximum(Da, Db)
+
+        return mind - d

foxes_opt-0.1/foxes_opt/core/__init__.py

@@ -0,0 +1,9 @@
+"""
+Abstract classes and core functionality for wind farm optimization.
+"""
+
+from .farm_opt_problem import FarmOptProblem
+from .farm_vars_problem import FarmVarsProblem
+from .farm_objective import FarmObjective
+from .farm_constraint import FarmConstraint
+from .pop_states import PopStates

foxes_opt-0.1/foxes_opt/core/farm_constraint.py

@@ -0,0 +1,96 @@
+from iwopy import Constraint
+
+from foxes.utils import all_subclasses
+
+
+class FarmConstraint(Constraint):
+    """
+    Abstract base class for foxes wind farm
+    optimization constraints.
+
+    :group: opt.core
+
+    """
+
+    def __init__(self, problem, name, sel_turbines=None, **kwargs):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        problem: foxes_opt.FarmOptProblem
+            The underlying optimization problem
+        name: str
+            The name of the constraint
+        sel_turbines: list of int, optional
+            The selected turbines
+        kwargs: dict, optional
+            Additional parameters for `iwopy.Constraint`
+
+        """
+        super().__init__(problem, name, **kwargs)
+        self._sel_turbines = sel_turbines
+
+    @property
+    def farm(self):
+        """
+        The wind farm
+
+        Returns
+        -------
+        foxes.core.WindFarm :
+            The wind farm
+
+        """
+        return self.problem.farm
+
+    @property
+    def sel_turbines(self):
+        """
+        The list of selected turbines
+
+        Returns
+        -------
+        list of int :
+            The list of selected turbines
+
+        """
+        return (
+            self.problem.sel_turbines
+            if self._sel_turbines is None
+            else self._sel_turbines
+        )
+
+    @property
+    def n_sel_turbines(self):
+        """
+        The numer of selected turbines
+
+        Returns
+        -------
+        int :
+            The numer of selected turbines
+
+        """
+        return len(self.sel_turbines)
+
+    def add_to_layout_figure(self, ax, **kwargs):
+        """
+        Add to a layout figure
+
+        Parameters
+        ----------
+        ax: matplotlib.pyplot.Axis
+            The figure axis
+
+        """
+        return ax
+
+    @classmethod
+    def print_models(cls):
+        """
+        Prints all model names.
+        """
+        names = sorted([scls.__name__ for scls in all_subclasses(cls)])
+        for n in names:
+            print(n)