"- Fix a bug `WindFarmModel.aep` that ignored the `n_cpu`, `wd_chunks` and `ws_chunks` arguments and always computed on only one CPU"
]
},
{
"cell_type": "markdown",
"metadata": {},
...
...
%% Cell type:markdown id: tags:
# Change log
%% Cell type:markdown id: tags:
## PyWake 2.4.1 (July 7, 2022)
- Fix a bug `WindFarmModel.aep` that ignored the `n_cpu`, `wd_chunks` and `ws_chunks` arguments and always computed on only one CPU
%% Cell type:markdown id: tags:
## PyWake 2.4 (July 6, 2022)
### New features and API changes
- Before the `Mirror` ground model used linear superposition of the above- and below-ground wind turbines while `MirrorSquaredSum` used squared sum. In this version the `MirrorSquaredSum` has been removed and `Mirror` is now using the superposition model of the wind farm model to calculate the sum. I.e. `Mirror` behave as before if the superposition model is `LinearSum` and as the previuos `MirrorSquaredSum` if the superposition model is `SquaredSum`
- Easy chunkification and parallelization via the arguments `n_cpu`, `wd_chunks` and `ws_chunks`, see https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/RunWindFarmSimulation.html#Chunkification-and-parallelization and https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/Optimization.html#Chunkify-and-Parallelization
- Change dAEPdxy to automatically compute gradients of aep wrt. the concatenated list of x,y which is faster than computing first wrt. x then y
-`py_wake.utils.layouts` contains functions to create rectangular and square wind turbine layouts
- New approach to switch numpy backend (used when switching to `autograd.numpy`, `Numpy32` (see below, etc.). The new approach requires all modules to import np from py_wake, i.e. `from py_wake import np`
- Easy way to switch between double presicion (standard numpy) and single precision (`Numpy32`), see https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/Optimization.html?#Precision
- New function `floris_yaml_to_pywake_turbine` (see https://gitlab.windenergy.dtu.dk/TOPFARM/PyWake/-/blob/master/py_wake/utils/floris_wrapper.py). This function creates a PyWake WindTurbine object from a Floris wind turbine yaml file and allows more direct comparison.
- Previuosly, `LocalWind` (returned by `site.localWind`) was an xarray `Dataset` subclass. Due to issues with autograd and cupy, this has been changed such that `LocalWind` is now a `dict` subclass with numpy arrays, `{'WS_ilk': np.array([...])}`. Xarray DataArrays are created by `LocalWind` when requesting attributes without `_ilk`, e.g. `localWind.WS`
- Long list of bug and issue fixes
### New models
- RotorAvgModels
- New WSPowerRotorAvg, which computes the rotor average deficit by, $deficit = WS - \sqrt[\alpha]{\frac{1}{N} \sum_{i}{\left(WS - deficit_i\right)}^\alpha}$. Note that `WS` is the rotor center wind speed and thus shear and terrain-dependent inflow variation are not taken into account when computing the rotor average deficit.
- Power/Ct functions
- New `DensityCompensation` which scales the wind speed wrt. air density. In most cases this model is more realistic than the existing alternative model, `DensityScale`, which scales the power and ct wrt. air density.
%% Cell type:markdown id: tags:
## PyWake 2.3 (March 18, 2022)
### New features and API changes
-`GroundModel` is now an input to `DeficitModel` instead of `WindFarmModel`. This means that a ground model can be applied to the blockage or wake, only.
- PyWake can now compute gradients via finite differnece, complex step and automatic differentiation, see https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/Optimization.html?highlight=gradients#Gradients. Most models supports all three methods, while a few does not work yet.
- Flow maps can be computed in both the vertical downwind and crosswind plane
### New models
- WakeDeficitModels
- CarbajofuertesGaussianDeficit
- TurboNOJDeficit
- TurboGaussianDeficit
- BlockageDeficitModels
- RathmannScaled
- DeflectionModels
- GCLHillDeflection
- JimenezWakeDeflection (extended with vertical deflection due to rotor tilt)
- WeightModels (to be used with the STF2005 and STF2017 TurbulenceModels)
- FrandsenWeight (the previous implementation)
- IECWeight (weight as specified in the IEC standard)
- SiteModels
- GlobalWindAtlasSite (site with data from online global wind atlas)
- DistanceModels
- JITStreamlineDistance (compute distances between wind turbines along streamlines)
- ShearModels
- LogShear
%% Cell type:markdown id: tags:
## PyWake 2.2 (March 26, 2021)
### New features and API changes
- All DeficitModels should inherrit either `WakeDeficitModel` or `BlockageDeficitModel`
- All Sites are now subclasses of XRSite
- WeightedSum SuperpositionModel reimplemented to be more efficient
- TurbulenceModels now take a RotorAvgModel as optional input. This allow PyWake to use different RotorAvgModels for wake and turbulence.
- Validation feature updated, see [here](https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/exercises/Validation.html)
- The Power/Ct curve functionality of `WindTurbines` has been updated to support multidimensional Power and Ct curves, e.g. curves depending on turbulence intensity, air density, yaw misalignment, operational mode etc. This means that instantiating `WindTurbines` and `OneTypeWindTurbines` with the old set of arguments, i.e. `name, diameter, hub_height, ct_func, power_func, power_unit`, is deprecated. Use the the new `WindTurbine` and `Windturbines` classes with the arguments `name, diameter, hub_height, powerCtFunction` instead, see [here](https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/WindTurbines.html). Backward compatibility is ensured (with runtime warning) for most use cases.
The `powerCtFunction` can be one of the classes from py_wake.wind_turbines.power_ct_functions, i.e.
-`PowerCtFunction`
-`PowerCtTabular`
-`PowerCtFunctionList`
-`PowerCtNDTabular`
-`PowerCtXr`
-`CubePowerSimpleCt`
- Support for time series of wd and ws, see [here](https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/RunWindFarmSimulation.html#Time-series). Possible use cases:
- Time-dependent inflow, e.g. measurements of wd, ws, ti, shear, density, etc.
- Time-dependent operation, e.g. periods of failure or maintaince of a wind turbine
- Added support for load surrogates to predict wind turbine loads
### New models
- BlockageDeficitModels (see [here](https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/EngineeringWindFarmModels.html#Blockage-deficit-models)
- LocalWind, SimulationResult and FlowMap are now `xarray.Dataset`-objects with some additional methods and attributes
-`simulationResult.aep()` now returns a `xarray.DataArray` with aep for all wind turbines, wind directions and wind speeds. To get the total AEP as before, use `simulationResult.aep().sum()`
- New general XRSite where the site is defined as an xarray with the following structure:
- Required data variables:
- P(probability) or f(sector frequency), A(Weibull scale), k(Weibull shape)
- All data variables may be constant or dependent on any of:
- ws (reference wind speed)
- wd (reference wind direction)
- position in terms of
- gridded 2D position, (x,y)
- gridded 3D position, (x,y,z)
- wt position, (i)
-[Include effects of neighbouring wind farms](Optimization.ipynb#Pregenerated-site-with-wake-effects-from-neighbouring-wind-farms) in site (wind resource) to speed up optimization of a wind farm with neighbouring farms
- Vertical flow map via the [YZGrid](RunWindFarmSimulation.ipynb#YZGrid)
### New models
- New `RotorAverageModel`, see [here](EngineeringWindFarmModels.ipynb#Rotor-average-models). The default model, `RotorCenter`, behaves as before as it estimates the rotor-average wind speed from the wind speed at the rotor center. Other models, however, provides a more accurate estimate based on multiple points on the cost of computation. The `CGIRotorAvg(4)` and `CGIRotorAvg(7)` with 4 and 7 points, respectively, provides good compromises between accuracy and computational cost.
- Deficit model:
-[GCLDeficit](EngineeringWindFarmModels.ipynb#GCLDeficit): The Gunner Larsen semi-analytical wake model
- Superposition model:
- WeightedSum A weighted sum approach taking wake convection velocity into account. The model is so far only applicable to the gaussian models. The model is based on "A momentum-conserving wake superposition method for wind farm power prediction" by Haohua Zong and Fernando Porté-Agel, J. Fluid Mech. (2020), vol. 889, A8; doi:10.1017/jfm.2020.77
%% Cell type:markdown id: tags:
## PyWake 2.0 (April 15, 2020)
- New structure
- Purpose:
- Easier combination of different models for flow propagation, wake and blockage deficit, superposition, wake deflection and turbulence
- More consistent interface to and support for engineering models and PyWake-Rans
- Changes
-`WakeModel` class refactored mainly into the `WindFarmModel`s `EngineeringWindFarmModel` and `PropagateDownwind`
-`WindFarmModel`s, e.g. `NOJ`, `Fuga`, `BastankhahGaussian` returns a `SimulationResult` containing the results as well as an AEP and a flow_map method. See the QuickStart tutorial
- and many more
- Backward compatibility
- AEP Calculator works as before, but is now deprecated
- Lower level interfaces and implementations has changed
- New documentation matching the new structure
- Optional blockage deficit models and implementation of the SelfSimilarity model
- Optional wake deflection models and implementation of a model by Jimenez
