foxes 0.7.4.25__py3-none-any.whl → 0.8.1__py3-none-any.whl

foxes/opt/core/pop_states.py

@@ -1,206 +0,0 @@
-import numpy as np
-
-from foxes.core import States, Data
-import foxes.constants as FC
-import foxes.variables as FV
-
-
-class PopStates(States):
-    """
-    Helper class for vectorized opt population
-    calculation, via artificial states of length
-    n_pop times n_states.
-
-    Attributes
-    ----------
-    states: foxes.core.States
-        The original states
-    n_pop: int
-        The population size
-
-    :group: opt.core
-
-    """
-
-    def __init__(self, states, n_pop):
-        """
-        Constructor.
-
-        Parameters
-        ----------
-        states: foxes.core.States
-            The original states
-        n_pop: int
-            The population size
-
-        """
-        super().__init__()
-        self.states = states
-        self.n_pop = n_pop
-
-    def load_data(self, algo, verbosity=0):
-        """
-        Load and/or create all model data that is subject to chunking.
-
-        Such data should not be stored under self, for memory reasons. The
-        data returned here will automatically be chunked and then provided
-        as part of the mdata object during calculations.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-        verbosity: int
-            The verbosity level, 0 = silent
-
-        Returns
-        -------
-        idata: dict
-            The dict has exactly two entries: `data_vars`,
-            a dict with entries `name_str -> (dim_tuple, data_ndarray)`;
-            and `coords`, a dict with entries `dim_name_str -> dim_array`
-
-        """
-        self.STATE0 = self.var(FC.STATE + "0")
-        self.SMAP = self.var("SMAP")
-
-        idata = super().load_data(algo, verbosity)
-        idata0 = algo.get_model_data(self.states)
-        for cname, coord in idata0["coords"].items():
-            if cname != FC.STATE:
-                idata["coords"][cname] = coord
-            else:
-                idata["coords"][self.STATE0] = coord
-
-        for dname, (dims0, data0) in idata0["data_vars"].items():
-            if dname != FV.WEIGHT:
-                hdims = tuple([d if d != FC.STATE else self.STATE0 for d in dims0])
-                idata["data_vars"][dname] = (hdims, data0)
-
-        smap = np.zeros((self.n_pop, self.states.size()), dtype=np.int32)
-        smap[:] = np.arange(self.states.size())[None, :]
-        smap = smap.reshape(self.size())
-        idata["data_vars"][self.SMAP] = ((FC.STATE,), smap)
-
-        found = False
-        for dname, (dims0, data0) in idata["data_vars"].items():
-            if self.STATE0 in dims0:
-                found = True
-                break
-        if not found:
-            del idata["coords"][self.STATE0]
-
-        return idata
-
-    def initialize(self, algo, verbosity=0):
-        """
-        Initializes the model.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-        verbosity: int
-            The verbosity level, 0 = silent
-
-        """
-        if not self.states.initialized:
-            self.states.initialize(algo, verbosity)
-        super().initialize(algo, verbosity)
-
-    def size(self):
-        """
-        The total number of states.
-
-        Returns
-        -------
-        int:
-            The total number of states
-
-        """
-        return self.states.size() * self.n_pop
-
-    def weights(self, algo):
-        """
-        The statistical weights of all states.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-
-        Returns
-        -------
-        weights: numpy.ndarray
-            The weights, shape: (n_states, n_turbines)
-
-        """
-        weights = np.zeros(
-            (self.n_pop, self.states.size(), algo.n_turbines), dtype=FC.DTYPE
-        )
-        weights[:] = self.states.weights(algo)[None, :, :] / self.n_pop
-        return weights.reshape(self.size(), algo.n_turbines)
-
-    def output_point_vars(self, algo):
-        """
-        The variables which are being modified by the model.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-
-        Returns
-        -------
-        output_vars: list of str
-            The output variable names
-
-        """
-        return self.states.output_point_vars(algo)
-
-    def calculate(self, algo, mdata, fdata, pdata):
-        """ "
-        The main model calculation.
-
-        This function is executed on a single chunk of data,
-        all computations should be based on numpy arrays.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-        mdata: foxes.core.Data
-            The model data
-        fdata: foxes.core.Data
-            The farm data
-        pdata: foxes.core.Data
-            The point data
-
-        Returns
-        -------
-        results: dict
-            The resulting data, keys: output variable str.
-            Values: numpy.ndarray with shape (n_states, n_points)
-
-        """
-
-        hdata = {}
-        hdims = {}
-        smap = mdata[self.SMAP]
-        for dname, data in mdata.items():
-            dms = mdata.dims[dname]
-            if dname == self.SMAP or dname == self.STATE0:
-                pass
-            elif dms[0] == self.STATE0:
-                hdata[dname] = data[smap]
-                hdims[dname] = tuple([FC.STATE] + list(dms)[1:])
-            elif self.STATE0 in dms:
-                raise ValueError(
-                    f"States '{self.name}': Found states variable not at dimension 0 for mdata entry '{dname}': {dms}"
-                )
-            else:
-                hdata[dname] = data
-                hdims[dname] = dms
-        hmdata = Data(hdata, hdims, mdata.loop_dims)
-
-        return self.states.calculate(algo, hmdata, fdata, pdata)

foxes/opt/objectives/__init__.py

@@ -1,6 +0,0 @@
-"""
-Wind farm optimization objectives.
-"""
-
-from .farm_vars import FarmVarObjective, MaxFarmPower, MinimalMaxTI
-from .max_n_turbines import MaxNTurbines

foxes/opt/objectives/farm_vars.py

@@ -1,323 +0,0 @@
-import numpy as np
-import xarray as xr
-
-from foxes.opt.core.farm_objective import FarmObjective
-from foxes import variables as FV
-import foxes.constants as FC
-
-
-class FarmVarObjective(FarmObjective):
-    """
-    Objectives based on farm variables.
-
-    Attributes
-    ----------
-    variable: str
-        The variable name
-    minimize: bool
-        Switch for maximizing or minimizing
-    deps: list of str
-        The foxes variables on which the variable depends,
-        or None for all
-    rules: dict
-        Contraction rules. Key: coordinate name str, value
-        is str: min, max, sum, mean
-    scale: float
-        The scaling factor
-
-    :group: opt.objectives
-
-    """
-
-    def __init__(
-        self,
-        problem,
-        name,
-        variable,
-        contract_states,
-        contract_turbines,
-        minimize,
-        deps=None,
-        scale=1.0,
-        **kwargs,
-    ):
-        """
-        Constructor.
-
-        Parameters
-        ----------
-        problem: foxes.opt.FarmOptProblem
-            The underlying optimization problem
-        name: str
-            The name of the objective function
-        variable: str
-            The foxes variable name
-        contract_states: str
-            Contraction rule for states: min, max, sum, mean
-        contract_turbines: str
-            Contraction rule for turbines: min, max, sum, mean
-        minimize: bool
-            Switch for maximizing or minimizing
-        deps: list of str
-            The foxes variables on which the variable depends,
-            or None for all
-        scale: float
-            The scaling factor
-        kwargs: dict, optional
-            Additional parameters for `FarmObjective`
-
-        """
-        super().__init__(problem, name, **kwargs)
-        self.variable = variable
-        self.minimize = minimize
-        self.deps = deps
-        self.scale = scale
-        self.rules = {FC.STATE: contract_states, FC.TURBINE: contract_turbines}
-
-    def initialize(self, verbosity=0):
-        """
-        Initialize the object.
-
-        Parameters
-        ----------
-        verbosity: int
-            The verbosity level, 0 = silent
-
-        """
-        super().initialize(verbosity)
-
-    def n_components(self):
-        """
-        Returns the number of components of the
-        function.
-
-        Returns
-        -------
-        int:
-            The number of components.
-
-        """
-        return 1
-
-    def maximize(self):
-        """
-        Returns flag for maximization of each component.
-
-        Returns
-        -------
-        flags: np.array
-            Bool array for component maximization,
-            shape: (n_components,)
-
-        """
-        return [not self.minimize]
-
-    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)
-
-        """
-        if self.deps is None:
-            return super().vardeps_float()
-
-        out = np.zeros((self.n_components(), self.n_vars_float), dtype=bool)
-        for i, tvr in enumerate(self.var_names_float):
-            v, ti = self.problem.parse_tvar(tvr)
-            if v in self.deps and ti in self.sel_turbines:
-                out[0, i] = True
-
-        return out
-
-    def _contract(self, data):
-        """
-        Helper function for data contraction
-        """
-        for dim, rule in self.rules.items():
-            if rule == "min":
-                data = data.min(dim=dim)
-            elif rule == "max":
-                data = data.max(dim=dim)
-            elif rule == "sum":
-                data = data.sum(dim=dim)
-            elif rule == "mean":
-                data = data.mean(dim=dim)
-            else:
-                raise ValueError(
-                    f"Objective '{self.name}': Unknown contraction for dimension '{dim}': '{rule}'. Choose: min, max, sum, mean"
-                )
-        return data
-
-    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,)
-
-        """
-        data = problem_results[self.variable]
-        if self.n_sel_turbines < self.farm.n_turbines:
-            data = data[:, self.sel_turbines]
-        data = self._contract(data) / self.scale
-
-        return np.array([data], dtype=np.float64)
-
-    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]
-        data = (
-            problem_results[self.variable]
-            .to_numpy()
-            .reshape(n_pop, n_states, n_turbines)
-        )
-        data = xr.DataArray(data, dims=(FC.POP, FC.STATE, FC.TURBINE))
-
-        if self.n_sel_turbines < self.farm.n_turbines:
-            data = data[:, self.sel_turbines]
-
-        return self._contract(data / self.scale).to_numpy()[:, None]
-
-    def finalize_individual(self, vars_int, vars_float, problem_results, verbosity=1):
-        """
-        Finalization, given the champion data.
-
-        Parameters
-        ----------
-        vars_int: np.array
-            The optimal integer variable values, shape: (n_vars_int,)
-        vars_float: np.array
-            The optimal float variable values, shape: (n_vars_float,)
-        problem_results: Any
-            The results of the variable application
-            to the problem
-        verbosity: int
-            The verbosity level, 0 = silent
-
-        Returns
-        -------
-        values: np.array
-            The component values, shape: (n_components,)
-
-        """
-        return (
-            super().finalize_individual(
-                vars_int, vars_float, problem_results, verbosity
-            )
-            * self.scale
-        )
-
-
-class MaxFarmPower(FarmVarObjective):
-    """
-    Maximize the mean wind farm power
-
-    Parameters
-    ----------
-    problem: foxes.opt.FarmOptProblem
-        The underlying optimization problem
-    name: str
-        The name of the objective function
-    kwargs: dict, optional
-        Additional parameters for `FarmVarObjective`
-
-    :group: opt.objectives
-
-    """
-
-    def __init__(self, problem, name="maximize_power", **kwargs):
-        if "scale" in kwargs:
-            scale = kwargs.pop("scale")
-        else:
-            scale = 0.0
-            ttypes = problem.algo.mbook.turbine_types
-            for t in problem.farm.turbines:
-                for mname in t.models:
-                    if mname in ttypes:
-                        scale += ttypes[mname].P_nominal
-                        break
-
-        super().__init__(
-            problem,
-            name,
-            variable=FV.P,
-            contract_states="mean",
-            contract_turbines="sum",
-            minimize=False,
-            scale=scale,
-            **kwargs,
-        )
-
-
-class MinimalMaxTI(FarmVarObjective):
-    """
-    Minimize the maximal turbine TI
-
-    Parameters
-    ----------
-    problem: foxes.opt.FarmOptProblem
-        The underlying optimization problem
-    name: str
-        The name of the objective function
-    kwargs: dict, optional
-        Additional parameters for `FarmVarObjective`
-
-    :group: opt.objectives
-
-    """
-
-    def __init__(self, problem, name="minimize_TI", **kwargs):
-        scale = kwargs.pop("scale") if "scale" in kwargs else 1.0
-        super().__init__(
-            problem,
-            name,
-            variable=FV.TI,
-            contract_states="max",
-            contract_turbines="max",
-            minimize=True,
-            scale=scale,
-            **kwargs,
-        )

foxes/opt/objectives/max_n_turbines.py

@@ -1,142 +0,0 @@
-import numpy as np
-
-from foxes.opt.core.farm_objective import FarmObjective
-import foxes.constants as FC
-
-
-class MaxNTurbines(FarmObjective):
-    """
-    Maximizes the number of turrbines.
-
-    Attributes
-    ----------
-    check_valid: bool
-        Check FC.VALID variable before counting
-
-    :group: opt.objectives
-
-    """
-
-    def __init__(
-        self,
-        problem,
-        name="max_n_turbines",
-        check_valid=True,
-        **kwargs,
-    ):
-        """
-        Constructor.
-
-        Parameters
-        ----------
-        problem: foxes.opt.FarmOptProblem
-            The underlying optimization problem
-        name: str
-            The name of the objective function
-        check_valid: bool
-            Check FC.VALID variable before counting
-        kwargs: dict, optional
-            Additional parameters for `FarmObjective`
-
-        """
-        super().__init__(problem, name, **kwargs)
-        self.check_valid = check_valid
-
-    def n_components(self):
-        """
-        Returns the number of components of the
-        function.
-
-        Returns
-        -------
-        int:
-            The number of components.
-
-        """
-        return 1
-
-    def maximize(self):
-        """
-        Returns flag for maximization of each component.
-
-        Returns
-        -------
-        flags: np.array
-            Bool array for component maximization,
-            shape: (n_components,)
-
-        """
-        return [True]
-
-    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,)
-
-        """
-        if FC.VALID in problem_results and self.check_valid:
-            vld = np.sum(problem_results[FC.VALID].to_numpy(), axis=1)
-            if np.min(vld) != np.max(vld):
-                raise ValueError(
-                    f"Objective '{self.name}': Number of valid turbines is state dependend, counting impossible"
-                )
-            return np.array([vld[0]], dtype=np.float64)
-        else:
-            return np.array([self.farm.n_turbines], dtype=np.float64)
-
-    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"].to_numpy()
-        if self.check_valid:
-            n_states = problem_results["n_org_states"].to_numpy()
-            n_turbines = self.farm.n_turbines
-            vld = (
-                problem_results[FC.VALID]
-                .to_numpy()
-                .reshape(n_pop, n_states, n_turbines)
-            )
-            vld = np.sum(vld, axis=2)
-            if np.any(np.min(vld, axis=1) != np.max(vld, axis=1)):
-                raise ValueError(
-                    f"Objective '{self.name}': Number of valid turbines is state dependend, counting impossible"
-                )
-            return vld[:, 0, None]
-        else:
-            return np.full((n_pop, 1), self.farm.n_turbines, dtype=vars_float.dtype)

foxes/opt/problems/__init__.py

@@ -1,7 +0,0 @@
-"""
-Wind farm optimization problems.
-"""
-
-from .opt_farm_vars import OptFarmVars
-
-from . import layout

foxes/opt/problems/layout/__init__.py

@@ -1,9 +0,0 @@
-"""
-Wind farm layout optimization problems.
-"""
-
-from .farm_layout import FarmLayoutOptProblem
-from .regular_layout import RegularLayoutOptProblem
-from .reggrids_layout import RegGridsLayoutOptProblem
-
-from . import geom_layouts