from abc import abstractmethod
import numpy as np
from foxes.core import WakeModel
[docs]
class DistSlicedWakeModel(WakeModel):
"""
Abstract base class for wake models for which
the x-denpendency can be separated from the
yz-dependency.
The multi-yz ability is used by the `PartialDistSlicedWake`
partial wakes model.
Attributes
----------
superpositions: dict
The superpositions. Key: variable name str,
value: The wake superposition model name,
will be looked up in model book
superp: dict
The superposition dict, key: variable name str,
value: `foxes.core.WakeSuperposition`
:group: models.wake_models
"""
[docs]
def __init__(self, superpositions):
"""
Constructor.
Parameters
----------
superpositions: dict
The superpositions. Key: variable name str,
value: The wake superposition model name,
will be looked up in model book
"""
super().__init__()
self.superpositions = superpositions
[docs]
def sub_models(self):
"""
List of all sub-models
Returns
-------
smdls: list of foxes.core.Model
Names of all sub models
"""
return list(self.superp.values())
[docs]
def initialize(self, algo, verbosity=0, force=False):
"""
Initializes the model.
Parameters
----------
algo: foxes.core.Algorithm
The calculation algorithm
verbosity: int
The verbosity level, 0 = silent
force: bool
Overwrite existing data
"""
self.superp = {
v: algo.mbook.wake_superpositions[s] for v, s in self.superpositions.items()
}
super().initialize(algo, verbosity, force)
[docs]
@abstractmethod
def calc_wakes_x_yz(
self,
algo,
mdata,
fdata,
tdata,
downwind_index,
x,
yz,
):
"""
Calculate wake deltas.
Parameters
----------
algo: foxes.core.Algorithm
The calculation algorithm
mdata: foxes.core.MData
The model data
fdata: foxes.core.FData
The farm data
tdata: foxes.core.TData
The target point data
downwind_index: int
The index in the downwind order
x: numpy.ndarray
The x values, shape: (n_states, n_targets)
yz: numpy.ndarray
The yz values for each x value, shape:
(n_states, n_targets, n_yz_per_target, 2)
Returns
-------
wdeltas: dict
The wake deltas. Key: variable name str,
value: numpy.ndarray, shape: (n_st_sel, n_yz_per_target)
st_sel: numpy.ndarray of bool
The state-target selection, for which the wake
is non-zero, shape: (n_states, n_targets)
"""
pass
[docs]
def contribute(
self,
algo,
mdata,
fdata,
tdata,
downwind_index,
wake_coos,
wake_deltas,
):
"""
Modifies wake deltas at target points by
contributions from the specified wake source turbines.
Parameters
----------
algo: foxes.core.Algorithm
The calculation algorithm
mdata: foxes.core.MData
The model data
fdata: foxes.core.FData
The farm data
tdata: foxes.core.TData
The target point data
downwind_index: int
The index of the wake causing turbine
in the downwnd order
wake_coos: numpy.ndarray
The wake frame coordinates of the evaluation
points, shape: (n_states, n_targets, n_tpoints, 3)
wake_deltas: dict
The wake deltas. Key: variable name,
value: numpy.ndarray with shape
(n_states, n_targets, n_tpoints, ...)
"""
# rounding for safe x > 0 conditions
x = np.round(wake_coos[:, :, 0, 0], 12)
yz = wake_coos[..., 1:3]
wdeltas, st_sel = self.calc_wakes_x_yz(
algo, mdata, fdata, tdata, downwind_index, x, yz
)
for v, hdel in wdeltas.items():
try:
superp = self.superp[v]
except KeyError:
raise KeyError(
f"Model '{self.name}': Missing wake superposition entry for variable '{v}', found {sorted(list(self.superp.keys()))}"
)
wake_deltas[v] = superp.add_wake(
algo,
mdata,
fdata,
tdata,
downwind_index,
st_sel,
v,
wake_deltas[v],
hdel,
)
[docs]
def finalize_wake_deltas(
self,
algo,
mdata,
fdata,
amb_results,
wake_deltas,
):
"""
Finalize the wake calculation.
Modifies wake_deltas on the fly.
Parameters
----------
algo: foxes.core.Algorithm
The calculation algorithm
mdata: foxes.core.MData
The model data
fdata: foxes.core.FData
The farm data
amb_results: dict
The ambient results, key: variable name str,
values: numpy.ndarray with shape
(n_states, n_targets, n_tpoints)
wake_deltas: dict
The wake deltas object at the selected target
turbines. Key: variable str, value: numpy.ndarray
with shape (n_states, n_targets, n_tpoints)
"""
for v, s in self.superp.items():
wake_deltas[v] = s.calc_final_wake_delta(
algo, mdata, fdata, v, amb_results[v], wake_deltas[v]
)