Site

The Site object provides the free wind conditions at the site including mean wind, shear, turbulence etc.

Current implementations are:

TurbulenceFieldSite

TurbulenceFieldSite

[1]:

# imports and default values
import numpy as np
import matplotlib.pyplot as plt
from py_wake.utils.plotting import setup_plot
from dynamiks.sites import TurbulenceFieldSite
from dynamiks.sites.turbulence_fields import MannTurbulenceField, RandomTurbulence
from dynamiks.sites.mean_wind import ConstantWindSpeed
from dynamiks.views import ZView, XYView
from dynamiks.utils.test_utils import DefaultDWMFlowSimulation

ws = 10
ti = 0.1
no_turb_field = RandomTurbulence(ti=0, ws=ws) # turbulence field without turbulence

The TurbulenceFieldSite implements a site defined by a wind speed (object) and a turbulence field

[2]:

help(TurbulenceFieldSite.__init__)

Help on function __init__ in module dynamiks.sites._site:

__init__(self, ws, turbulenceField, turbulence_offset=[0, 0, 0], turbulence_transport_speed=None)
    Site with mean wind and turbulence field

    Parameters
    ----------
    ws : int, float or MeanWind-object
        mean wind speed or MeanWind-object, e.g. ConstantWindSpeed
    turbulenceField : TurbulenceField
        E.g. MannTurbulenceField
    turbulence_offset : tuple(x,y,z), optional
        turbulence (x,y,z)-offset. Default is no offset
    turbulence_transport_speed : int, float or None, optional
        Turbulence field advection speed.
        If None (default), the speed is obtained from the mean wind speed

Mean wind

The mean wind argument can be either a constant uniform mean wind speed value

[3]:

site = TurbulenceFieldSite(ws, no_turb_field)

or a ConstantWindSpeed object

[4]:

const_ws = ConstantWindSpeed(ws=10)
site = TurbulenceFieldSite(const_ws, no_turb_field)

Shear

The latter ConstantWindSpeed option allows specification of vertical shear in terms of a PyWake shear object, e.g. PowerShear or LogShear

[5]:

import numpy as np
from py_wake.site.shear import PowerShear, LogShear


# PyWake shears
power_shear = PowerShear(h_ref=100, # reference height
                   alpha=0.1) # power shear exponent

log_shear = LogShear(h_ref=100, # reference height
                 z0=0.03)   # roughness length

view = ZView(x=0,y=0, z=np.linspace(1,200))

for shear in [power_shear, log_shear]:
    const_ws = ConstantWindSpeed(ws=10, shear=shear)
    site = TurbulenceFieldSite(const_ws, no_turb_field)
    u,v,w = site.get_windspeed(view)
    plt.plot(u, view.z, label=shear.__class__.__name__)
setup_plot(xlabel='Wind speed [m/s]', ylabel='Height [m]')

TurbulenceField

Current implementations

RandomTurbulence
MannTurbulenceField

RandomTurbulence

The RandomTurbulence produces random turbulence. It is very fast but mainly usable for tests

[6]:

from dynamiks.sites.turbulence_fields import RandomTurbulence
site = TurbulenceFieldSite(10, RandomTurbulence(ti=ti, ws=ws))

[7]:

uvw = site.get_windspeed(view)
for ws, n in zip(uvw, 'uvw'):
    plt.plot(ws, view.z, label=n)
setup_plot(xlabel='Wind speed [m/s]', ylabel='Height [m]')

LES precursor

Precursors are typically turbulence field extracted from CFD LES simulations, i.e. simulations where the turbulence has dimenstions \((uvw, time, x, y, z)\).

Often precursor fields are sampled at a plane some distance upstream of the wind farm or wind turbine, which reduces the dimensions to \((uvw, time,y,z)\).

These can be used in Dynamiks similar to normal turbulence fields, but we need to convert the time axis into x coordinate and assume Taylor’s frozen turbulence hypothesis, to obtain turbulence in other areas of the domain.

[18]:

import warnings
import xarray as xr
import numpy as np
from numpy import newaxis as na
import matplotlib.pyplot as plt
from dynamiks.sites import TurbulenceFieldSite
from dynamiks.utils.test_utils import DefaultDWMFlowSimulation, tfp # test_files path
from dynamiks.sites.turbulence_fields import TurbulenceField
from dynamiks.views import XYView, XZView, MultiView
from hipersim import Bounds
from py_wake.utils.plotting import setup_plot

First we load the precursor, in this case a downsampled precursor obtained from Ellipsys.

[19]:

da = xr.load_dataarray(tfp + "precursor.nc")
da.sel(vel='u').isel(y=0).plot(x='t')

To map the time axis into x-coordinates, we need an advection speed. It can specified or extracted as the mean wind speed at a specific height. In this case we take the wind speed at \(z=100m\)

[20]:

U_z = da.sel(vel='u').mean(('y', 't'))
advection_speed = U_z.interp(z=100).item()

[21]:

U_z.plot(y='z')
plt.plot(advection_speed,100,'.', label=f'U(z=100) = {advection_speed:.1f}m/s')
setup_plot(xlabel='U mean [m]', ylabel='height [m]', figsize=(4,3))

Having the advection speed, we can find the distance between time samples

[22]:

dt, dy, dz = [np.diff(v[:2])[0] for v in [da.t, da.y, da.z]]
dx = dt * advection_speed

We can now instantiate a site with the precursor turbulence and plot it

[23]:

def get_flowSimluation(bounds=Bounds.Error, offset=(0,0,0), da=da):
    Nxyz = Nx,Ny,Nz = da.shape[1:] # first dimension is uvw
    tf = TurbulenceField(da.values[:,::-1], # reverse x axis to move precursor forward
                         Nxyz=Nxyz, dxyz=[dx, dy, dz], bounds=bounds)
    site = TurbulenceFieldSite(ws=0, turbulenceField=tf, turbulence_transport_speed=advection_speed,
                               turbulence_offset=np.array([-(Nx-1)*dx,0,0]) + offset) # add box length to count offset from box front
    return DefaultDWMFlowSimulation(x=[0], y=[0], site=site)

fs = get_flowSimluation(Bounds.Repeat)
ax1,ax2 = plt.subplots(2,1, figsize=(12,6))[1]
fs.show(MultiView([XYView(ax=ax1, xlim=[-5500,500], ylim=[-100,900]), XZView(y=0, ax=ax2)]))

The turbine is located at \((0,0)\), so half of the rotor and all wake particles are outside the precursor field. Before running the simulation we need to consider how to deal with areas outside the box. There are different options:

Offset the box to cover the wind farm
Repeat or mirror the box
Use edge values
Extend the the box size

Offset box

We can offset the precursor field such that it covers the turbine and all wake particles during the whole simulation.

[24]:

fs = get_flowSimluation(offset=(2000,-400,0), bounds=Bounds.Error)
ax1,ax2 = plt.subplots(2,1, figsize=(12,6))[1]
fs.visualize(10, MultiView([XYView(ax=ax1), XZView(y=0, ax=ax2)]))

Repeat or mirror the box

In the visualization below, the box is repeated in the x direction and mirrored in the y and z direction.

Note:

If the box is not periodic, repeating it may lead to discontinuities, as seen in the x direction near the turbine
If the box is not homogeneous, mirroring or repeating it leads to wrong behavour as seen below where the low wind speed near the ground is applied again around \(z=900\)

[25]:

fs = get_flowSimluation(bounds=[Bounds.Repeat,Bounds.Mirror,Bounds.Mirror])
fs.visualize(10, view=XZView(y=0, x=np.linspace(-1000,1000), z=np.linspace(0,910)))

Use Edge values

The bounds option Bounds.Warning gives a warning when requesting wind speed outside the box and returns the nearest valid value, i.e. the wind speed at the edge of the box.

[26]:

with warnings.catch_warnings(action='ignore'):
    fs = get_flowSimluation(bounds=[Bounds.Warning,Bounds.Warning,Bounds.Warning])
    fs.visualize(10, view=XZView(y=0, x=np.linspace(-1000,1000), z=np.linspace(0,910)))

Extend the box

In case you know a better estimate of the wind speed outside the box, the wind field can be extended.

Below, the wind speed in 50 time steps in front of the box is set to the mean \(uvw(z)\) profile.

[27]:

da_mean = da[:,:50]*0+da.mean(('y','t')) # 50 time steps of uvw(z) profile
coords = dict(vel=['u','v','w'], t=np.arange(0,200)*dt, y=da.y.values, z=da.z.values)
da_ext = xr.DataArray(np.concatenate([da_mean, da],1), dims=da.dims,coords=coords)
fs = get_flowSimluation(da=da_ext, offset=(50*dx,-200,0))
fs.visualize(10, view=XZView(y=0, x=np.linspace(-1000,1000)))

[ ]:

Site

TurbulenceFieldSite

Mean wind

Shear

TurbulenceField

RandomTurbulence

MannTurbulenceField

Generate turbulence field via Hipersim

Read turbulence field from file

Turbulence intensity and scaling

Turbulence offset

Turbulence transport speed

LES precursor

Offset box

Repeat or mirror the box

Use Edge values

Extend the box