PyWake

https://topfarm.pages.windenergy.dtu.dk/PyWake
Admin
PyWake is an open-source Python-based wind farm simulation tool that computes flow fields, power...
Tokens:358,685
Snippets:2,225
Trust Score:9.7
Update:8 months ago
Show doc for...
Tokens:
Raw
### PyWake Quickstart Guide

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/_modules/py_wake/deficit_models/gaussian

A quick start guide for PyWake, demonstrating how to import and set up wind turbines, sites, and flow models, and how to plot AEP and flow maps.

```text
Quickstart
    * Import and set up of wind turbines, site, and flow model
    * Plot AEP as function of wind turbines, wind direction and wind speed
    * Plot flow maps
```

--------------------------------

### Setup and Import PyWake

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/literature_verification/Gaussian

This snippet demonstrates how to set up the PyWake environment by loading necessary extensions and installing PyWake if it's not already present. It ensures that the library is ready for use in subsequent code examples.

```python
%load_ext autoreload
%autoreload 2

# install PyWake if needed
try:
    import py_wake
except ModuleNotFoundError:
    !pip install git+https://gitlab.windenergy.dtu.dk/TOPFARM/PyWake.git
```

--------------------------------

### PyWake Installation Guide

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/_modules/py_wake/deficit_models/gaussian

This section outlines the different methods for installing PyWake, including pre-installation requirements, a simple installation process, and instructions for developers who need to build from source.

```text
Installation Guide
  * Pre-Installation
  * Simple Installation
  * Developer Installation
```

--------------------------------

### PyWake Quickstart: Setup and Plotting

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/api/WindFarmModel

Demonstrates the basic usage of PyWake for setting up wind turbines, sites, and flow models, and plotting simulation results like AEP and flow maps.

```python
from pywake.examples.quickstart import run_quickstart
run_quickstart()
```

--------------------------------

### PyWake Installation Guide

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/api/WindFarmModel

Instructions for installing PyWake, including simple and developer installations. Dependencies are managed through pip.

```bash
pip install pywake
```

--------------------------------

### PyWake Setup and Visualization Example

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/RotorAverageModels

Sets up a wind farm site and turbines using PyWake, then simulates and visualizes wake effects. It uses BastankhahGaussian model and plots horizontal and YZ grid flow maps.

```python
import numpy as np
import matplotlib.pyplot as plt

import py_wake
from py_wake.examples.data.hornsrev1 import V80, Hornsrev1Site

site = Hornsrev1Site()
windTurbines = V80()
wt_x, wt_y = site.initial_position.T

from py_wake.superposition_models import SquaredSum
from py_wake.flow_map import HorizontalGrid, YZGrid
from py_wake import BastankhahGaussian

D = 80
R = D/2
wfm = BastankhahGaussian(site, windTurbines, superpositionModel=SquaredSum())
sim_res = wfm([0,200],[0,0],wd=270,ws=10)

fig,(ax1,ax2) = plt.subplots(1,2, figsize=(10,4))
ax1.set_xlabel("x [m]"), ax1.set_ylabel("y [m]")
sim_res.flow_map(HorizontalGrid(extend=.1)).plot_wake_map(10, ax=ax1, plot_colorbar=False)
sim_res.flow_map(YZGrid(x=199.99)).plot_wake_map(10, ax=ax2)
ax2.plot([-100,100],[70,70],'-.')
ax2.set_xlabel("y [m]"), ax1.set_ylabel("z [m]")

plt.figure()
flow_map = sim_res.flow_map(HorizontalGrid(x=[199.99], y=np.arange(-80, 80)))

for x in [-.5,.5]:
    plt.gca().axvline(x,color='grey')
plt.plot(flow_map.Y[:, 0]/D, flow_map.WS_eff_xylk[:, 0, 0, 0], '-.', label='Hub-height profile')
plt.plot([-.5,.5],[7.73,7.73],label='Rotor average: 7.73m/s')
rc_ws = flow_map.WS_eff_xylk[80, 0, 0, 0]
plt.plot(flow_map.Y[80, 0]/D, rc_ws,'.', ms=10, label='Rotor center: %.2fm/s'%rc_ws)
plt.legend()
plt.xlabel("y/D")
plt.ylabel('Wind speed [m/s]')

```

--------------------------------

### Install PyWake from GitLab

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/installation

Installs PyWake directly from its GitLab repository, including any recent updates not yet released on PyPI. This is useful for accessing the most current version of the code.

```bash
pip install git+https://gitlab.windenergy.dtu.dk/TOPFARM/PyWake.git
```

--------------------------------

### Setup CostModelComponent and TopFarmProblem (Python)

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/_sources/notebooks/Optimization.ipynb

Configures the `CostModelComponent` to use the `mean_power` function as the cost and its gradient. Sets up the `TopFarmProblem` with design variables ('zhub', 'derating'), their bounds, the cost component, and an expected cost value to guide the optimizer.

```python
cost_comp=CostModelComponent(input_keys=['zhub', 'derating'],
                              n_wt=n_wt,
                              cost_function=mean_power,
                              cost_gradient_function=dmean_power_dzhub_derating,
                              maximize=True # because we want to maximize the mean power
                             )

tf = TopFarmProblem(design_vars={
                        # (initial_values, lower limit, upper limit)
                        'zhub': ([100]*n_wt, 80, 130),
                        'derating': ([0] * n_wt, 0, .9)},
                    n_wt=n_wt,
                    cost_comp=cost_comp,
                    expected_cost=1000, # expected cost impacts the size of the moves performed by the optimizer
                    )
```

--------------------------------

### Setup Wind Turbine and Site Objects in PyWake

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/literature_verification/TurbOPark

Demonstrates the setup of wind turbine and site objects using PyWake. It imports necessary classes and defines parameters for wind turbines and site conditions.

```python
import numpy as np
import matplotlib.pyplot as plt

from py_wake.wind_turbines._wind_turbines import WindTurbine, WindTurbines
from py_wake.wind_turbines.power_ct_functions import PowerCtTabular
from py_wake.site._site import UniformSite
from py_wake.site.shear import PowerShear
from py_wake.utils.plotting import setup_plot
```

--------------------------------

### Install PyWake from PyPI

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/installation

Installs the latest official release of PyWake from the Python Package Index (PyPI). This is the simplest method for users who do not need the latest development features.

```bash
pip install py_wake
```

--------------------------------

### Setup Site and Wind Turbines in PyWake

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/_sources/notebooks/RotorAverageModels.ipynb

Initializes site and wind turbine objects using data from PyWake examples. This setup is necessary for running wind energy simulations.

```python
import numpy as np
import matplotlib.pyplot as plt

# import and setup site and windTurbines
import py_wake
from py_wake.examples.data.hornsrev1 import V80, Hornsrev1Site

site = Hornsrev1Site()
windTurbines = V80()
wt_x, wt_y = site.initial_position.T
```

--------------------------------

### Noise Simulation Setup

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/_sources/notebooks/Noise.ipynb

Demonstrates the setup for simulating noise at receiver positions within a wind farm. This involves creating a WindFarmModel and running a simulation. It highlights potential user warnings related to specific Gaussian models.

```python
# This is a placeholder for the actual code that would set up and run the simulation.
# The provided text only contains a markdown description and a user warning.
# Example of a potential warning that might be logged:
# C:\mmpe\programming\python\Topfarm\PyWake\py_wake\deficit_models\gaussian.py:403: UserWarning: The ZongGaussian model is not representative of the setup used in the literature. For this, use py_wake.literature.gaussian_models.Zong_PorteAgel_2020 instead
```

--------------------------------

### Import and Setup Wind Turbines, Site, and Flow Model in PyWake

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/literature_verification/SuperGaussian

This snippet demonstrates the basic setup for a wind farm simulation in PyWake. It covers importing necessary components like wind turbines, defining a site, and specifying the flow model. This is a foundational step for any PyWake simulation.

```python
from pywake.examples import simple_wind_farm

# Example: Import and set up of wind turbines, site, and flow model
wind_farm = simple_wind_farm()
print(wind_farm)
```

--------------------------------

### Install TOPFARM

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/_sources/notebooks/Optimization.ipynb

Installs the TOPFARM package if it's not already imported. This package is used for wind farm optimizations and integrates with other tools like PyWake.

```python
try:
    import topfarm
except ImportError:
    !pip install topfarm --user
```

--------------------------------

### Setup Wind Farm Model

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/_sources/notebooks/exercises/WakeDeflection.ipynb

Configures the wind farm simulation by defining the site, turbine positions, wind turbine model, and the wake model with deflection. This setup is crucial for accurately simulating wind flow and energy production.

```python
site = IEA37Site(16)
x, y = [0, 600, 1200], [0, 0, 0]
windTurbines = IEA37_WindTurbines()
wfm = Bastankhah_PorteAgel_2014(site, windTurbines, k=0.0324555, deflectionModel=JimenezWakeDeflection())
```

--------------------------------

### Setup WindFarmModel and Mean Power Function (Python)

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/_sources/notebooks/Optimization.ipynb

Initializes the WindFarmModel using IEA37SimpleBastankhahGaussian and UniformSite. Defines the `mean_power` function that calculates the average power output for a given set of hub heights and derating factors. This function serves as the objective for optimization.

```python
from py_wake.deficit_models.gaussian import IEA37SimpleBastankhahGaussian
from py_wake.site import UniformSite
from py_wake.utils.gradients import autograd

from topfarm._topfarm import TopFarmProblem
from topfarm.cost_models.cost_model_wrappers import CostModelComponent
from topfarm.easy_drivers import EasyScipyOptimizeDriver

n_wt = 5
wfm = IEA37SimpleBastankhahGaussian(site=UniformSite(p_wd=[1],ti=.1), windTurbines=wt)
wt_x = np.arange(n_wt) * 4 * wt.diameter()
wt_y = np.zeros_like(wt_x)

def mean_power(zhub, derating):
    power_ilk = wfm(x=wt_x, y=wt_y, h=zhub, wd=[270], ws=[10], derating=derating, return_simulationResult=False)[2] 
    return np.mean(power_ilk)
```

--------------------------------

### Setup Wind Farm Models and TOPFARM Problem (Python)

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/_sources/notebooks/Optimization.ipynb

Sets up wind farm models for IEA37 and Hornsrev1 sites using PyWake, and defines a function to create a TOPFARM problem. This includes defining site characteristics, turbine types, and optimization constraints.

```python
import numpy as np
import matplotlib.pyplot as plt
import multiprocessing

#setting up pywake models
from py_wake.deficit_models.gaussian import IEA37SimpleBastankhahGaussian
from py_wake.literature.gaussian_models import Bastankhah_PorteAgel_2014
from py_wake.examples.data.iea37._iea37 import IEA37Site, IEA37WindTurbines
from py_wake.examples.data.hornsrev1 import Hornsrev1Site, V80
from py_wake.utils.gradients import autograd, fd, cs
from py_wake.utils.plotting import setup_plot

#setting up topfarm models
from topfarm._topfarm import TopFarmProblem
from topfarm.cost_models.py_wake_wrapper import PyWakeAEPCostModelComponent
from topfarm.constraint_components.boundary import CircleBoundaryConstraint, XYBoundaryConstraint
from topfarm.constraint_components.spacing import SpacingConstraint
from topfarm.easy_drivers import EasyScipyOptimizeDriver

#wind farm model for the IEA 37 site
def IEA37_wfm(n_wt, n_wd):
    site = IEA37Site(n_wt)
    site.default_wd = np.linspace(0,360,n_wd, endpoint=False)
    wt = IEA37WindTurbines()
    return IEA37SimpleBastankhahGaussian(site, wt)

#wind farm model for the Hornsrev1 site
Hornsrev1_wfm = Bastankhah_PorteAgel_2014(Hornsrev1Site(), V80(), k=0.0324555)

#function to create a topfarm problem, following the elements of OpenMDAO architecture
def get_topfarmProblem_xy(wfm, grad_method, maxiter, n_cpu):
    x, y = wfm.site.initial_position.T
    boundary_constr = [XYBoundaryConstraint(np.array([x, y]).T),
                       CircleBoundaryConstraint(center=[0, 0], radius=np.round(np.hypot(x, y).max()))][int(isinstance(wfm.site, IEA37Site))]
    
    return TopFarmProblem(design_vars={'x': x, 'y': y},

```

--------------------------------

### Setup External Wind Farm Models

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/ExternalWindFarms

This code sets up different external wind farm models: ExternalWFMWindFarm, ExternalXRAbsWindFarm, and ExternalXRRelWindFarm. It measures the time and memory required for setup for each model. The performance of XR models depends on grid resolution.

```python
setup_df = pd.DataFrame({'Time [s]':[],'Memory [MB]':[]})
ext_wf_dict = {}
ext_cls_lst = [ExternalWFMWindFarm, ExternalXRAbsWindFarm, ExternalXRRelWindFarm]
for cls in ext_cls_lst:
    ext_farm_lst,t,mem = profileit(setup_ext_farms)(cls, neighbour_x_y_angle)
    ext_wf_dict[cls] = ext_farm_lst
    setup_df.loc[f'Setup {cls.__name__}'] = [np.mean(t), mem]
np.round(setup_df,1)
```

--------------------------------

### PyWake Site Object Examples

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/api/WindFarmModel

Illustrates the creation and usage of different Site objects in PyWake, including UniformSite, UniformWeibullSite, XRSite, WaspGridSite, and WRFSite.

```python
from pywake.site import UniformWeibullSite
site = UniformWeibullSite(p: float = 2.0, ti: float = 0.14)
print(site)
```

```python
from pywake.site import XRSite
site = XRSite(filename='path/to/wind/resource/data.nc')
print(site)
```

--------------------------------

### Developer Installation of PyWake

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/installation

This snippet guides through cloning the PyWake repository from GitLab and installing it in editable mode with testing dependencies. This is recommended for developers contributing to PyWake.

```bash
git clone https://gitlab.windenergy.dtu.dk/TOPFARM/PyWake.git
cd PyWake
pip install -e .[test]
```

--------------------------------

### Setup PyWake Site and Wind Turbines

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/BlockageDeficitModels

Initializes the wind farm simulation environment by setting up the site and wind turbine models. It imports necessary components from PyWake and defines turbine positions.

```python
import numpy as np
import matplotlib.pyplot as plt
from matplotlib import cm
from matplotlib.colors import ListedColormap, LinearSegmentedColormap

# import and setup site and windTurbines
import py_wake
from py_wake.examples.data.hornsrev1 import V80, Hornsrev1Site

site = Hornsrev1Site()
windTurbines = V80()
wt_x, wt_y = site.initial_position.T
```

--------------------------------

### Setting up a WRFSite in PyWake

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/validation

This example demonstrates how to set up a WRFSite using PyWake. This allows for the integration and use of wind resource data generated by the Weather Research and Forecasting (WRF) model.

```python
from pywake.site import WRFSite

# Specify the path to the WRF output file (e.g., NetCDF)
wrf_file_path = 'path/to/your/wrf_output.nc'

# Initialize the WRFSite object
# You may need to specify keys for wind speed, direction, etc. if they differ from defaults
wrf_site = WRFSite(wrf_file_path)

# This WRFSite object can then be used in wind farm simulations
```

--------------------------------

### Import and Set Up Wind Turbines, Site, and Flow Model in PyWake

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/_modules/py_wake/literature/fuga

This snippet demonstrates the initial setup in PyWake, involving importing necessary components and configuring wind turbines, the site, and the flow model. It's a foundational step for any wind farm simulation.

```python
from pywake.examples.quickstart import setup_windfarm

# Example setup (replace with actual parameters)
windTurbines, site, flow_model = setup_windfarm()
print("Wind farm setup complete.")
```

--------------------------------

### Load PyWake Example Data

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/literature_verification/SuperGaussian

Loads example data for PyWake, including wind turbine specifications (V80) and site data (Hornsrev1Site). This setup is commonly used for running examples and performing validations within PyWake.

```python
import numpy as np
import matplotlib.pyplot as plt

from py_wake.examples.data.hornsrev1 import Hornsrev1Site, V80
windTurbines = V80()
site = Hornsrev1Site()
```

--------------------------------

### Define Wind Speed Lower Bounds (Python)

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/RunWindFarmSimulation

Calculates the lower bounds for wind speed bins, denoted as ws_l. These values are derived from the WS array and represent the start of each wind speed interval. For example, the first interval starts at 2.5 m/s.

```python
ws_l = np.array([ 2.5,  3.5,  4.5,  5.5,  6.5,  7.5,  8.5,  9.5, 10.5, 11.5, 12.5,
       13.5, 14.5, 15.5, 16.5, 17.5, 18.5, 19.5, 20.5, 21.5, 22.5, 23.5,
       24.5])
```

--------------------------------

### Initialize Example PyWake Sites

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/Site

Initializes several predefined demonstration sites available in PyWake. These sites represent different types of wind farm scenarios, including uniform wind conditions, Weibull distributed wind speeds, and gridded or time-dependent wind data.

```python
sites = {"IEA37": IEA37Site(n_wt=16),
         "Hornsrev1": Hornsrev1Site(),
         "ParqueFicticio": ParqueFicticioSite(),
         "Hornsrev1WRF": Hornsrev1WRFSite()}
```

--------------------------------

### Import PyWake Wind Turbine Classes and Examples

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/WindTurbines

Imports various wind turbine models and site data from PyWake's example datasets. This includes predefined turbines like V80, IEA37, and DTU10MW, allowing for quick setup of common turbine types.

```python
from py_wake.wind_turbines import WindTurbine, WindTurbines
from py_wake.examples.data.hornsrev1 import V80
from py_wake.examples.data.iea37 import IEA37_WindTurbines, IEA37Site
from py_wake.examples.data.dtu10mw import DTU10MW

v80 = V80()
iea37 = IEA37_WindTurbines()
dtu10mw = DTU10MW()
```

--------------------------------

### Setup and Simulate Wind Farm Interactions (Python)

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/ExternalWindFarms

This code sets up wind farm configurations, including neighboring farms, and performs simulations using both a full turbine model and an external farm model. It then visualizes the resulting flow maps and compares the effective wind speed.

```python
No_neighbours = 2
neighbour_x_y_angle = [(wf_x-6000*i, wf_y, 270) for i in range(1,No_neighbours+1)]
neighbour_x, neighbour_y,_ = zip(*neighbour_x_y_angle)
all_x, all_y = np.r_[wf_x,np.array(neighbour_x).flatten()], np.r_[wf_y,np.array(neighbour_y).flatten()]

types = [v for i in range(No_neighbours+1) for v in [i]*len(wf_x)]
wd = 270
wfm_ref = get_wfm()
sim_res_ref = wfm_ref(all_x, all_y, type=types, wd=wd, ws=10)

ext_farms = setup_ext_farms(ExternalWFMWindFarm, neighbour_x_y_angle)
wfm = get_wfm(ext_farms)
sim_res_ext = wfm(wf_x, wf_y, type=0, wd=wd,ws=10)

grid = XYGrid(x=np.linspace(-15000,3000,150), y=np.linspace(-2500,2500,100))
fm_ref = sim_res_ref.flow_map(grid)
fm_ref.plot_wake_map(levels=np.linspace(4,10,50))
setup_plot(grid=False, figsize=(12,3), axis='scaled')
```

--------------------------------

### Create and Activate Anaconda Environment for PyWake

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/installation

This snippet shows how to create a new Anaconda environment specifically for PyWake with Python 3.12 and then activate it. This is recommended to avoid dependency conflicts.

```bash
conda create --name pywake python=3.12
activate pywake
```

--------------------------------

### Setup Wind Farm Simulation with PyWake

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/RunWindFarmSimulation

Imports necessary libraries and sets up the wind farm site, wind turbines, and a wake model. It configures the simulation environment and prints the initialized wake model.

```python
# import and setup site and windTurbines
%load_ext py_wake.utils.notebook_extensions

from tqdm.notebook import tqdm
from py_wake.utils import layouts
from py_wake.utils.profiling import timeit, profileit
from py_wake.examples.data.hornsrev1 import Hornsrev1Site, V80
from py_wake.literature.gaussian_models import Bastankhah_PorteAgel_2014
from py_wake.utils.plotting import setup_plot
import xarray as xr
xr.set_options(display_expand_data=False)

site = Hornsrev1Site()
x, y = site.initial_position.T
windTurbines = V80()

wf_model = Bastankhah_PorteAgel_2014(site, windTurbines, k=0.0324555)

#this allows you to see what type of engineering models you are simulating
print(wf_model)
```

--------------------------------

### Initialize Site with Wind Speed Gradient (Python)

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/literature_verification/TurbOPark

Initializes an XRSite object with a defined wind speed gradient using PowerShear. This allows the simulation to account for varying wind speeds at different turbine locations. It returns the local wind speed for specified turbine positions.

```python
from py_wake.site import XRSite
from py_wake.wind_shear import PowerShear

# Assuming 'ds', 'x', 'y', 'wts' are defined elsewhere
# Example placeholder definitions:
# ds = xr.Dataset(...)
# x = np.arange(0, 1000, 100)
# y = np.zeros_like(x)
# wts = WindFarmSet(...)

gradient_site = XRSite(ds=ds, shear=PowerShear(h_ref=90, alpha=.1))
# Assuming 'type' is defined elsewhere
# gradient_site.local_wind(x,y,wts.hub_height(type), ws=1)['WS_ilk']
```

--------------------------------

### Setup Site and Wind Turbines

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/_sources/notebooks/exercises/CombineModels.ipynb

Initializes the wind farm site and wind turbine models using data from the IEA37 dataset. It retrieves the initial positions of the wind turbines on the site, which are crucial for defining the wind farm layout.

```python
from py_wake.examples.data.iea37._iea37 import IEA37Site, IEA37_WindTurbines

site = IEA37Site(16)
windTurbines = IEA37_WindTurbines()
x,y = site.initial_position.T
```

--------------------------------

### Load Horns Rev 1 Site and V80 Turbine

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/literature_verification/Gaussian

This snippet shows how to load the Horns Rev 1 wind farm site and the Vestas V80 wind turbine model from PyWake's example data. This setup is used for reproducing results from the Niayifar and Porté-Agel (2016) paper.

```python
from py_wake.examples.data.hornsrev1 import Hornsrev1Site, V80, wt_x, wt_y

# Initialize Vestas V80 wind turbine
v80_pw = V80()
# Initialize Horns Rev 1 site
site = Hornsrev1Site()
```

--------------------------------

### Install TOPFARM

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/Optimization

Installs the TOPFARM package, a Python library for wind farm optimizations. It is recommended to install it for user if the package is not found.

```python
# Install TopFarm if needed
try:
    import topfarm
except ImportError:
    !pip install topfarm --user

```

--------------------------------

### Initialize Site and Turbine Data

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/TurbulenceModels

Sets up the wind farm site and turbine characteristics using data from Hornsrev1. This includes defining turbine positions, diameters, and other relevant parameters for simulation.

```python
import numpy as np
import matplotlib.pyplot as plt

from py_wake.examples.data.hornsrev1 import V80, Hornsrev1Site

site = Hornsrev1Site()
windTurbines = V80()
wt_x, wt_y = site.initial_position.T
D = windTurbines.diameter()
```

--------------------------------

### Initialize Wind Farm Model and Simulate

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/RunWindFarmSimulation

Sets up an IEA37 wind farm site and turbines, then initializes a Bastankhah-Porte-Agel wake model and performs a simulation to get initial results.

```python
from py_wake.examples.data.iea37 import IEA37Site, IEA37_WindTurbines
from py_wake.literature.gaussian_models import Bastankhah_PorteAgel_2014

site = IEA37Site(16)
x, y = site.initial_position.T
windTurbines = IEA37_WindTurbines()

wf_model = Bastankhah_PorteAgel_2014(site, windTurbines, k=0.0324555)
sim_res = wf_model(x,y)
```

--------------------------------

### Install PyWake

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/_sources/notebooks/GroundModels.ipynb

Installs the PyWake library if it's not already present. It attempts to import py_wake and falls back to pip installation from a Git repository if the module is not found. This is crucial for using PyWake's functionalities.

```python
try:
    import py_wake
except ModuleNotFoundError:
    !pip install git+https://gitlab.windenergy.dtu.dk/TOPFARM/PyWake.git
```

--------------------------------

### Install PyWake

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/Optimization

Installs the PyWake package from a Git repository. This is useful if the package is not found in the current environment.

```python
# Install PyWake if needed
try:
    import py_wake
except ModuleNotFoundError:
    !pip install git+https://gitlab.windenergy.dtu.dk/TOPFARM/PyWake.git

```

--------------------------------

### MaxSum Superposition Model Example

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/SuperpositionModels

Shows an example of the MaxSum superposition model in PyWake. This model considers only the largest deficit among the contributing wakes.

```python
from py_wake.superposition_models import MaxSum

max_sum = Bastankhah_PorteAgel_2014(site, windTurbines, k=0.0324555, superpositionModel=MaxSum())
plt.figure(figsize=(10,4))
max_sum([0,200],[0,0],wd=270,ws=10).flow_map().plot_wake_map(levels=np.arange(0,10))
plt.xlabel('x [m]')
plt.ylabel('y [m]')


```

--------------------------------

### Initialize Site Object

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/exercises/Validation

Shows how to initialize a `Site` object, which represents the geographical and atmospheric conditions of a wind farm location. This includes methods for elevation and wind data.

```python
from pywake.site import UniformSite

# Example initialization for a uniform site
site = UniformSite(elevation=0.0, ti=0.1, rho=1.225)

# Example for a site with wind data (e.g., Weibull distribution)
# from pywake.site import UniformWeibullSite
# site_weibull = UniformWeibullSite(wind_speed=8.0, wind_direction=270.0, ti=0.1, rho=1.225, weibull_shape=2.0)
```

--------------------------------

### Visualize Wake Maps with Different Site Setups in PyWake

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/ExternalWindFarms

This snippet visualizes wake maps generated using different site setups within PyWake's external wind farm modeling. It iterates through two site configurations, calculates the flow map for each, and plots the wake map. Dependencies include matplotlib and PyWake's setup functions.

```python
fig, axes = plt.subplots(1,2,figsize=(12,3))
for i, (ax, site_setup) in enumerate(zip(axes, [site_with_streamlines, site]), 1):
    ext_farms = setup_ext_farms(cls, [neighbour_x_y_angle], wfm=get_wfm(site=site_setup), include_wd_range=np.array([0]))

    wfm = get_wfm(ext_farms, site=site_with_streamlines)
    sim_res_ext = wfm(wf_x, wf_y, type=0, wd=270, ws=10)

    fm = sim_res_ext.flow_map(grid)

    fm.plot_wake_map(ax=ax)

    if site_setup==site_with_streamlines:
        idx=[0,1,6,18]

```

--------------------------------

### Setup CostModelComponent and TopFarmProblem in Python

Source: https://topfarm.pages.windenergy.dtu.dk/PyWake/notebooks/Optimization

This code sets up the `CostModelComponent` and `TopFarmProblem`. The `CostModelComponent` is configured to maximize the `mean_power` function, taking `zhub` and `derating` as inputs. `TopFarmProblem` is initialized with design variables, the cost component, and an expected cost value.

```python
cost_comp=CostModelComponent(input_keys=['zhub', 'derating'],
                              n_wt=n_wt,
                              cost_function=mean_power,
                              cost_gradient_function=dmean_power_dzhub_derating,
                              maximize=True # because we want to maximize the mean power
                             )

tf = TopFarmProblem(design_vars={
                        # (initial_values, lower limit, upper limit)
                        'zhub': ([100]*n_wt, 80, 130),
                        'derating': ([0] * n_wt, 0, .9)},
                    n_wt=n_wt,
                    cost_comp=cost_comp,
                    expected_cost=1000, # expected cost impacts the size of the moves performed by the optimizer
                    )

```
Tokens:
Raw