## PyWake 2.5 (February 15, 2023)

### New Features and API changes

• PyWake conda package available. Install by conda install -c https://conda.windenergy.dtu.dk/channel/open py_wake

• Before RotorAvgModel was an input to the WindFarmModel. This is ambigious as the rotor average models may be applied to both wake deficit, blockage deficit and turbulence. Instead the RotorAvgModel is now an input option to WakeDeficitModel, BlockageDeficitModel and TurbulenceModel

• Before the an area overlapping rotor average model was integrated into the NOJDeficit Model. These models have now been separated. The default behaviour is unchanged as the default rotor average model of NOJDeficit is set to AreaOverlapAvgModel

• The IEA37SimpleBastankhahGaussian wind farm model is deprecated. Please use the IEA37CaseStudy1 model from py_wake.literature.iea37_case_study1 instead

• Notebook with verification of the TurbOPark model from Ørsted

• New netcdf-based Fuga look-up table format. The function dat2netcdf py_wake.utils.fuga_utils can be used to convert files from the old deprecated format to the new format.

• Wind turbine positions may now depend on wind direction and wind speed (e.g. floating wind turbines or multirotors)

• Before All2AllIterative took an input initialize_with_PropagateDownwind which defaulted to True to decide whether the effective wind speed in All2AllIterative should start with the free stream value or the effective wind speed computed by PropagateDownwind (i.e. without blockage). This input has been replaced with the optional input argument WS_eff. If WS_eff=None(default) then the initial effective wind speed is obtained from PropagateDownwind. Alternatively, the initial effective wind speed can be set to the free wind by WS_eff=0 or directly to a custom value by WS_eff=effective wind speed. Note, however, that bypassing some iterations by setting the “correct” effective wind speed may result in wrong gradients

• All2AllIterative will now return after first iteration if convergence_tolerance is set to None. This only makes sense if CT and the deficit are independent of the effective wind speed, like the IEA37CaseStudy1 setup.

• The default behaviour of StraightDistance is now to use the reference wind direction

• New method to avoid deficit and turbulence from wind turbines on themselves. This allows flow maps without discontinuties at the wind turbines

• New InputModifierModel type that capable of modifying inputs before or during the simulations. This enables simulation of multirotor and floating wind turbines

### New models and functions

• DeficitModels

• FugaMultiLUTDeficit, which allows different wind turbine types

• XRDeficitModel for deficit models based on xarray.dataarray look-up table (with linear interpolation)

• RotorAvgModels

• GaussianOverlap. The model is based on a lookup table with numerically integrated overlap factors based on normalized input of downstream rotor diamter and crosswind distance.

• TurbulenceModels

• XRTurbulenceModel for turbulence models based on xarray.dataarray look-up table (with linear interpolation)

• Predefined WindFarmModels

• TurbOPark. A setup very similar to the original Ørsted implementation

• InputModifierModels

• MultiRotor. Model to change the position of the rotors on a multirotor wind turbine depending on the wind direction

• ISONoiseModel. Simple noise propagation model, see https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/Noise.html

• InputModifierModel. New model type that allows to modify inputs before or during the simulations. This allows multirotor

• Functions

• New circular method in py_wake.utils.layouts to generate circular layouts

### Bug fixes

• Fix a bug in WindFarmModel.aep that ignored the n_cpu, wd_chunks and ws_chunks arguments and always computed on only one CPU.

• Fix NOJLocalDeficit. Before a layout term was precalculated, but in the local version this term depends on the effective TI which was unknow at this stage

• Fix error ModuleNotFoundError: No module named 'xarray.plot.plot' occurring with newer version of xarray

• Fix parallel executino with FugaDeficit

• and many more

## 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 behaves 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/gradients_parallellization.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.

## 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/gradients_parallelization.html#Gradients. Most models supports all three methods, while a few do 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

## PyWake 2.2 (March 26, 2021)

### New features and API changes

• All DeficitModels should inherit 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 allows PyWake to use different RotorAvgModels for wake and turbulence.

• Validation feature updated, see here.

• 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. 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. 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

### New models

• BlockageDeficitModels (see here)

• SelfSimilarityDeficit2020

• HybridInduction

• RankineHalfBody

• VortexCylinder

• VortexDipole

• Rathmann

• DeflectionModels

• FugaDeflection (requires Fuga look-up tables, UL, UT, VL, VT)

• GroundModels

• Mirror

• MirrorSquaredSum

## PyWake 2.1 (September 14, 2020)

### New features and API changes

• New xarray data structure

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

• Optional data variables:

• WS(defaults to reference wind speed, ws), TI(turbulence intensity), SpeedUp, Turning

• 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 in site (wind resource) to speed up optimization of a wind farm with neighbouring farms.

• Vertical flow map via the YZGrid.

### New models

• New RotorAverageModel, see here. 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, provide 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, provide good compromises between accuracy and computational cost.

• Deficit model:

• 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.

## 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 WindFarmModels EngineeringWindFarmModel and PropagateDownwind.

• WindFarmModels, 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.