foxes 0.6.2__py3-none-any.whl → 0.7.0.2__py3-none-any.whl

foxes/models/partial_wakes/distsliced.py

@@ -1,322 +0,0 @@
-import numpy as np
-
-from foxes.core import PartialWakesModel, Data
-from foxes.models.wake_models.dist_sliced import DistSlicedWakeModel
-from foxes.models.rotor_models.grid import GridRotor
-from foxes.utils import wd2uv, uv2wd
-import foxes.variables as FV
-import foxes.constants as FC
-
-
-class PartialDistSlicedWake(PartialWakesModel):
-    """
-    Partial wakes for distance sliced wake models,
-    making use of their structure.
-
-    The evaluations are optinally done on a grid rotor
-    that can differ from the algorithm's rotor model.
-
-    Attributes
-    ----------
-    rotor_model: foxes.core.RotorModel
-        The rotor model, default is the one from the algorithm
-    grotor: foxes.models.rotor_models.GridRotor
-        The grid rotor model
-
-    :group: models.partial_wakes
-
-    """
-
-    def __init__(
-        self, n=None, wake_models=None, wake_frame=None, rotor_model=None, **kwargs
-    ):
-        """
-        Constructor.
-
-        Parameters
-        ----------
-        n: int, optional
-            The `GridRotor`'s `n` parameter
-        wake_models: list of foxes.core.WakeModel, optional
-            The wake models, default are the ones from the algorithm
-        wake_frame: foxes.core.WakeFrame, optional
-            The wake frame, default is the one from the algorithm
-        rotor_model: foxes.core.RotorModel, optional
-            The rotor model, default is the one from the algorithm
-        kwargs: dict, optional
-            Additional parameters for the `GridRotor`
-
-        """
-        super().__init__(wake_models, wake_frame)
-
-        self.rotor_model = rotor_model
-        self.grotor = None if n is None else GridRotor(n=n, calc_vars=[], **kwargs)
-
-    def __repr__(self):
-        if self.grotor is not None:
-            return super().__repr__() + f"(n={self.grotor.n})"
-        elif self.rotor_model is not None and isinstance(self.rotor_model, GridRotor):
-            return super().__repr__() + f"(n={self.rotor_model.n})"
-        else:
-            return super().__repr__()
-
-    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 self.rotor_model is None:
-            self.rotor_model = algo.rotor_model
-        if self.grotor is None:
-            self.grotor = self.rotor_model
-
-        super().initialize(algo, verbosity)
-
-        for w in self.wake_models:
-            if not isinstance(w, DistSlicedWakeModel):
-                raise TypeError(
-                    f"Partial wakes '{self.name}': Cannot be applied to wake model '{w.name}', since not an DistSlicedWakeModel"
-                )
-
-        self.YZ = self.var("YZ")
-        self.W = self.var(FV.WEIGHT)
-
-    def sub_models(self):
-        """
-        List of all sub-models
-
-        Returns
-        -------
-        smdls: list of foxes.core.Model
-            Names of all sub models
-
-        """
-        return super().sub_models() + [self.rotor_model, self.grotor]
-
-    def new_wake_deltas(self, algo, mdata, fdata):
-        """
-        Creates new initial wake deltas, filled
-        with zeros.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-        mdata: foxes.core.Data
-            The model data
-        fdata: foxes.core.Data
-            The farm data
-
-        Returns
-        -------
-        wake_deltas: dict
-            Keys: Variable name str, values: any
-        pdata: foxes.core.Data
-            The evaluation point data
-
-        """
-
-        n_states = fdata.n_states
-        n_rpoints = self.grotor.n_rotor_points()
-        n_points = fdata.n_turbines * n_rpoints
-        points = self.grotor.get_rotor_points(algo, mdata, fdata).reshape(
-            n_states, n_points, 3
-        )
-        pdata = Data.from_points(points=points)
-
-        wake_deltas = {}
-        for w in self.wake_models:
-            w.init_wake_deltas(algo, mdata, fdata, pdata, wake_deltas)
-
-        return wake_deltas, pdata
-
-    def contribute_to_wake_deltas(
-        self,
-        algo,
-        mdata,
-        fdata,
-        pdata,
-        states_source_turbine,
-        wake_deltas,
-    ):
-        """
-        Modifies wake deltas by contributions from the
-        specified wake source turbines.
-
-        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 evaluation point data
-        states_source_turbine: numpy.ndarray of int
-            For each state, one turbine index corresponding
-            to the wake causing turbine. Shape: (n_states,)
-        wake_deltas: Any
-            The wake deltas object created by the
-            `new_wake_deltas` function
-
-        """
-
-        # calc x-coordinates of rotor centres:
-        hpdata = Data.from_points(points=fdata[FV.TXYH])
-        x = self.wake_frame.get_wake_coos(
-            algo, mdata, fdata, hpdata, states_source_turbine
-        )[:, :, 0]
-
-        # evaluate grid rotor:
-        n_states = fdata.n_states
-        n_turbines = fdata.n_turbines
-        n_rpoints = self.grotor.n_rotor_points()
-        n_points = fdata.n_turbines * n_rpoints
-        wcoos = self.wake_frame.get_wake_coos(
-            algo, mdata, fdata, pdata, states_source_turbine
-        )
-        yz = wcoos.reshape(n_states, n_turbines, n_rpoints, 3)[:, :, :, 1:3]
-        del wcoos
-
-        # evaluate wake models:
-        for w in self.wake_models:
-            wdeltas, sp_sel = w.calc_wakes_spsel_x_yz(
-                algo, mdata, fdata, hpdata, states_source_turbine, x, yz
-            )
-
-            wsps = np.zeros((n_states, n_turbines, n_rpoints), dtype=bool)
-            wsps[:] = sp_sel[:, :, None]
-            wsps = wsps.reshape(n_states, n_points)
-
-            for v, wdel in wdeltas.items():
-                d = np.zeros((n_states, n_turbines, n_rpoints), dtype=FC.DTYPE)
-                d[sp_sel] = wdel
-                d = d.reshape(n_states, n_points)[wsps]
-
-                try:
-                    superp = w.superp[v]
-                except KeyError:
-                    raise KeyError(
-                        f"Model '{self.name}': Missing wake superposition entry for variable '{v}' in wake model '{w.name}', found {sorted(list(w.superp.keys()))}"
-                    )
-
-                wake_deltas[v] = superp.calc_wakes_plus_wake(
-                    algo,
-                    mdata,
-                    fdata,
-                    pdata,
-                    states_source_turbine,
-                    wsps,
-                    v,
-                    wake_deltas[v],
-                    d,
-                )
-
-    def evaluate_results(
-        self,
-        algo,
-        mdata,
-        fdata,
-        pdata,
-        wake_deltas,
-        states_turbine,
-        amb_res=None,
-    ):
-        """
-        Updates the farm data according to the wake
-        deltas.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-        mdata: foxes.core.Data
-            The model data
-        fdata: foxes.core.Data
-            The farm data
-            Modified in-place by this function
-        pdata: foxes.core.Data
-            The evaluation point data
-        wake_deltas: Any
-            The wake deltas object, created by the
-            `new_wake_deltas` function and filled
-            by `contribute_to_wake_deltas`
-        states_turbine: numpy.ndarray of int
-            For each state, the index of one turbine
-            for which to evaluate the wake deltas.
-            Shape: (n_states,)
-        amb_res: dict, optional
-            Ambient states results. Keys: var str, values:
-            numpy.ndarray of shape (n_states, n_points)
-
-        """
-        rweights = algo.rotor_model.from_data_or_store(FC.RWEIGHTS, algo, mdata)
-        rpoints = algo.rotor_model.from_data_or_store(FC.RPOINTS, algo, mdata)
-        n_states, n_turbines, n_rpoints, __ = rpoints.shape
-
-        amb_res_in = amb_res is not None
-        if not amb_res_in:
-            amb_res = algo.rotor_model.from_data_or_store(
-                FC.AMB_RPOINT_RESULTS, algo, mdata
-            )
-
-        wweights = self.grotor.rotor_point_weights()
-        n_wpoints = self.grotor.n_rotor_points()
-        n_states, n_turbines, n_rpoints, __ = rpoints.shape
-        st_sel = (np.arange(n_states), states_turbine)
-
-        uv = None
-        if (FV.WS in amb_res and FV.WD not in amb_res) or (
-            FV.WS not in amb_res and FV.WD in amb_res
-        ):
-            raise KeyError(
-                f"Model '{self.name}': Missing one of the variables '{FV.WS}', '{FV.WD}' in ambient rotor results: {list(amb_res.keys())}"
-            )
-
-        elif FV.WD in amb_res and np.any(
-            np.min(amb_res[FV.WD], axis=2) != np.max(amb_res[FV.WD], axis=2)
-        ):
-            wd = amb_res[FV.WD].reshape(n_states, n_turbines, n_rpoints)[st_sel]
-            ws = amb_res[FV.WS].reshape(n_states, n_turbines, n_rpoints)[st_sel]
-            uv = wd2uv(wd, ws, axis=-1)
-            uv = np.einsum("spd,p->sd", uv, rweights)
-            del ws, wd
-
-        wres = {}
-        for v, ares in amb_res.items():
-            if v == FV.WS and uv is not None:
-                wres[v] = np.linalg.norm(uv, axis=-1)
-            elif v == FV.WD and uv is not None:
-                wres[v] = uv2wd(uv, axis=-1)
-            else:
-                wres[v] = ares.reshape(n_states, n_turbines, n_rpoints)[st_sel]
-                wres[v] = np.einsum("sp,p->s", wres[v], rweights)
-            wres[v] = wres[v][:, None]
-        del uv
-
-        wdel = {}
-        for v, d in wake_deltas.items():
-            wdel[v] = d.reshape(n_states, n_turbines, n_wpoints)[st_sel]
-        for w in self.wake_models:
-            w.finalize_wake_deltas(algo, mdata, fdata, pdata, wres, wdel)
-        for v in wdel.keys():
-            wdel[v] = np.einsum("sp,p->s", wdel[v], wweights)[:, None]
-
-        for v in wres.keys():
-            if v in wake_deltas:
-                wres[v] += wdel[v]
-                if amb_res_in:
-                    amb_res[v][st_sel] = wres[v]
-            wres[v] = wres[v][:, None]
-
-        self.rotor_model.eval_rpoint_results(
-            algo, mdata, fdata, wres, np.array([1.0]), states_turbine=states_turbine
-        )

foxes/models/partial_wakes/mapped.py

@@ -1,252 +0,0 @@
-from copy import deepcopy
-
-from foxes.core import PartialWakesModel
-from foxes.models.partial_wakes.rotor_points import RotorPoints
-from foxes.models.partial_wakes.top_hat import PartialTopHat
-from foxes.models.partial_wakes.axiwake import PartialAxiwake
-from foxes.models.partial_wakes.distsliced import PartialDistSlicedWake
-from foxes.models.wake_models.top_hat import TopHatWakeModel
-from foxes.models.wake_models.dist_sliced import DistSlicedWakeModel
-from foxes.models.wake_models.axisymmetric import AxisymmetricWakeModel
-import foxes.constants as FC
-
-
-class Mapped(PartialWakesModel):
-    """
-    Partial wake models depending on the wake model (type).
-
-    This is required if more than one wake models are
-    used and different partial wake models should be invoked.
-
-    Attributes
-    ----------
-    wname2pwake: dict
-        Mapping from wake model name to partial wakes.
-        Key: model name str, value: Tuple of length 2,
-        (Partial wake class name, parameter dict)
-    wtype2pwake: dict
-        Mapping from wake model class name to partial wakes.
-        Key: wake model class name str, value: Tuple of length 2,
-        (Partial wake class name, parameter dict)
-
-    :group: models.partial_wakes
-
-    """
-
-    def __init__(
-        self, wname2pwake={}, wtype2pwake=None, wake_models=None, wake_frame=None
-    ):
-        """
-        Constructor.
-
-        Parameters
-        ----------
-        wname2pwake: dict, optional
-            Mapping from wake model name to partial wakes.
-            Key: model name str, value: Tuple of length 2,
-            (Partial wake class name, parameter dict)
-        wtype2pwake: dict, optional
-            Mapping from wake model class name to partial wakes.
-            Key: wake model class name str, value: Tuple of length 2,
-            (Partial wake class name, parameter dict)
-        wake_models: list of foxes.core.WakeModel, optional
-            The wake models, default are the ones from the algorithm
-        wake_frame: foxes.core.WakeFrame, optional
-            The wake frame, default is the one from the algorithm
-
-        """
-        super().__init__(wake_models, wake_frame)
-
-        self.wname2pwake = wname2pwake
-
-        if wtype2pwake is None:
-            self.wtype2pwake = {
-                TopHatWakeModel: (PartialTopHat.__name__, {}),
-                AxisymmetricWakeModel: (PartialAxiwake.__name__, {"n": 6}),
-                DistSlicedWakeModel: (PartialDistSlicedWake.__name__, {"n": 9}),
-            }
-        else:
-            self.wtype2pwake = wtype2pwake
-
-        self._pwakes = None
-
-    def initialize(self, algo, verbosity=0):
-        """
-        Initializes the model.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-        verbosity: int
-            The verbosity level, 0 = silent
-
-        """
-        self.wake_models = algo.wake_models if self._wmodels is None else self._wmodels
-        self.wake_frame = algo.wake_frame if self._wframe is None else self._wframe
-
-        pws = {}
-        for w in self.wake_models:
-            pdat = None
-            if w.name in self.wname2pwake:
-                pdat = deepcopy(self.wname2pwake[w.name])
-
-            if pdat is None:
-                for pwcls, tdat in self.wtype2pwake.items():
-                    if isinstance(w, pwcls):
-                        pdat = deepcopy(tdat)
-                        break
-
-            if pdat is None:
-                pdat = (RotorPoints.__name__, {})
-
-            pname = pdat[0]
-            if pname not in pws:
-                pws[pname] = pdat[1]
-                pws[pname]["wake_models"] = []
-                pws[pname]["wake_frame"] = self.wake_frame
-            pws[pname]["wake_models"].append(w)
-
-        self._pwakes = []
-        for pname, pars in pws.items():
-            if verbosity:
-                print(
-                    f"Partial wakes '{self.name}': Applying {pname} to {[w.name for w in pars['wake_models']]}"
-                )
-            self._pwakes.append(PartialWakesModel.new(pname, **pars))
-
-        super().initialize(algo, verbosity)
-
-    def sub_models(self):
-        """
-        List of all sub-models
-
-        Returns
-        -------
-        smdls: list of foxes.core.Model
-            Names of all sub models
-
-        """
-        return super().sub_models() + self._pwakes
-
-    def new_wake_deltas(self, algo, mdata, fdata):
-        """
-        Creates new initial wake deltas, filled
-        with zeros.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-        mdata: foxes.core.Data
-            The model data
-        fdata: foxes.core.Data
-            The farm data
-
-        Returns
-        -------
-        wake_deltas: dict
-            Keys: Variable name str, values: any
-        pdata: foxes.core.Data
-            The evaluation point data
-
-        """
-        wdeltas = []
-        pdatas = []
-        for pw in self._pwakes:
-            w, p = pw.new_wake_deltas(algo, mdata, fdata)
-            wdeltas.append(w)
-            pdatas.append(p)
-
-        return wdeltas, pdatas
-
-    def contribute_to_wake_deltas(
-        self,
-        algo,
-        mdata,
-        fdata,
-        pdata,
-        states_source_turbine,
-        wake_deltas,
-    ):
-        """
-        Modifies wake deltas by contributions from the
-        specified wake source turbines.
-
-        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 evaluation point data
-        states_source_turbine: numpy.ndarray of int
-            For each state, one turbine index corresponding
-            to the wake causing turbine. Shape: (n_states,)
-        wake_deltas: Any
-            The wake deltas object created by the
-            `new_wake_deltas` function
-
-        """
-        for pwi, pw in enumerate(self._pwakes):
-            pw.contribute_to_wake_deltas(
-                algo, mdata, fdata, pdata[pwi], states_source_turbine, wake_deltas[pwi]
-            )
-
-    def evaluate_results(
-        self,
-        algo,
-        mdata,
-        fdata,
-        pdata,
-        wake_deltas,
-        states_turbine,
-        amb_res=None,
-    ):
-        """
-        Updates the farm data according to the wake
-        deltas.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-        mdata: foxes.core.Data
-            The model data
-        fdata: foxes.core.Data
-            The farm data
-            Modified in-place by this function
-        pdata: foxes.core.Data
-            The evaluation point data
-        wake_deltas: Any
-            The wake deltas object, created by the
-            `new_wake_deltas` function and filled
-            by `contribute_to_wake_deltas`
-        states_turbine: numpy.ndarray of int
-            For each state, the index of one turbine
-            for which to evaluate the wake deltas.
-            Shape: (n_states,)
-        amb_res: dict, optional
-            Ambient states results. Keys: var str, values:
-            numpy.ndarray of shape (n_states, n_points)
-
-        """
-        if amb_res is None:
-            ares = algo.rotor_model.from_data_or_store(
-                FC.AMB_RPOINT_RESULTS, algo, mdata
-            ).copy()
-            amb_res = {v: d.copy() for v, d in ares.items()}
-
-        for pwi, pw in enumerate(self._pwakes):
-            pw.evaluate_results(
-                algo,
-                mdata,
-                fdata,
-                pdata[pwi],
-                wake_deltas[pwi],
-                states_turbine,
-                amb_res=amb_res,
-            )

foxes/models/turbine_models/set_XYHD.py

@@ -1,130 +0,0 @@
-import numpy as np
-
-from foxes.core import TurbineModel
-import foxes.variables as FV
-import foxes.constants as FC
-
-
-class SetXYHD(TurbineModel):
-    """
-    Sets basic turbine data, from
-    turbine object to farm data.
-
-    Attributes
-    ----------
-    set_XY: bool
-        Flag for (x,y) data
-    set_H: bool
-        Flag for height data
-    set_D: bool
-        Flag for rotor diameter data
-
-    :group: models.turbine_models
-
-    """
-
-    def __init__(self, set_XY=True, set_H=True, set_D=True):
-        """
-        Constructor.
-
-        Parameters
-        ----------
-        set_XY: bool
-            Flag for (x,y) data
-        set_H: bool
-            Flag for height data
-        set_D: bool
-            Flag for rotor diameter data
-
-        """
-        super().__init__()
-
-        self.set_XY = set_XY
-        self.set_H = set_H
-        self.set_D = set_D
-
-    def output_farm_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
-
-        """
-        ovars = []
-        if self.set_XY:
-            ovars.append(FV.X)
-            ovars.append(FV.Y)
-        if self.set_H:
-            ovars.append(FV.H)
-        if self.set_D:
-            ovars.append(FV.D)
-        return ovars
-
-    def calculate(self, algo, mdata, fdata, st_sel):
-        """ "
-        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
-        st_sel: numpy.ndarray of bool
-            The state-turbine selection,
-            shape: (n_states, n_turbines)
-
-        Returns
-        -------
-        results: dict
-            The resulting data, keys: output variable str.
-            Values: numpy.ndarray with shape (n_states, n_turbines)
-
-        """
-        n_states = mdata.n_states
-        n_turbines = algo.n_turbines
-
-        if self.set_XY or self.set_H:
-            fdata[FV.TXYH] = np.full((n_states, n_turbines, 3), np.nan, dtype=FC.DTYPE)
-            if self.set_XY:
-                fdata[FV.X] = fdata[FV.TXYH][..., 0]
-                fdata[FV.Y] = fdata[FV.TXYH][..., 1]
-            if self.set_H:
-                fdata[FV.H] = fdata[FV.TXYH][..., 2]
-
-        for ti in range(n_turbines):
-            ssel = st_sel[:, ti]
-            if np.any(ssel):
-                if np.all(ssel):
-                    ssel = np.s_[:]
-
-                if self.set_XY:
-                    fdata[FV.X][ssel, ti] = algo.farm.turbines[ti].xy[0]
-                    fdata[FV.Y][ssel, ti] = algo.farm.turbines[ti].xy[1]
-
-                if self.set_H:
-                    H = algo.farm.turbines[ti].H
-                    if H is None:
-                        H = algo.farm_controller.turbine_types[ti].H
-                    fdata[FV.H][ssel, ti] = H
-
-                if self.set_D:
-                    D = algo.farm.turbines[ti].D
-                    if D is None:
-                        D = algo.farm_controller.turbine_types[ti].D
-                    fdata[FV.D][ssel, ti] = D
-
-        return {v: fdata[v] for v in self.output_farm_vars(algo)}