foxes-opt 0.1__py3-none-any.whl

foxes_opt/VERSION

@@ -0,0 +1 @@
+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/constraints/__init__.py

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

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

foxes_opt/core/farm_objective.py

@@ -0,0 +1,97 @@
+from abc import abstractmethod
+from iwopy import Objective
+
+from foxes.utils import all_subclasses
+
+
+class FarmObjective(Objective):
+    """
+    Abstract base class for foxes wind farm
+    objective functions.
+
+    :group: opt.core
+
+    """
+
+    def __init__(self, problem, name, sel_turbines=None, **kwargs):
+        """
+        Constraints.
+
+        Parameters
+        ----------
+        problem: foxes_opt.FarmOptProblem
+            The underlying optimization problem
+        name: str
+            The name of the objective function
+        sel_turbines: list of int, optional
+            The selected turbines
+        kwargs: dict, optional
+            Additional parameters for `iwopy.Objective`
+
+        """
+        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)