AEP calculations considering surge and sway motions for floating wind farm

[MYMahfouz]

Hi ,

I have a question about AEP calculation:
I am using floris to calculate the AEP of a floating wind farm.

I take into account the surge and sway motions of the floating wind turbine therefore, I update the wind farm layout according to the wind direction. This means for me to calculate the AEP of the farm I have to calculate each wind direction separately, then sum them up.

In FLORIS v3 if i use the .get_farm_AEP() for one wind direction it takes the same time it takes if I am calculating all wind directions. This was not the case for FLORIS v2.4 which was faster for my use case.

Is there a way to make FLORIS v3 faster for my purpose?

Thanks in advance.
Youssef

[rafmudaf]

Hi @MYMahfouz good question. Before I dive in, could you please add a minimal working example of the problem to the original post?

[MYMahfouz]

Hi @rafmudaf,

Thanks for your quick reply.

I have copied a piece of my code here
wd: is the wind direction
ws: is the wind speed (in my case i am only interested in one wind speed)
LayoutX and LayoutY: are two dataframes that include the wind farm layout at each wind direction

AEPtotal=[]

for ww in range(len(wd)):
    LayoutperDirection=pd.DataFrame()
    LayoutperDirection['x']= LayoutX.loc[:,wd[ww]]
    LayoutperDirection['y']= LayoutY.loc[:,wd[ww]]  
    fi.reinitialize(layout_x=np.array(LayoutperDirection.x).tolist(),
                    layout_y=np.array(LayoutperDirection.y).tolist(),
                    wind_directions=[wd[ww]],
                    wind_speeds=ws) 
    AEP=fi.get_farm_AEP([freq[ww]])
    AEPtotal.append(AEP)

[rafmudaf]

Thanks @MYMahfouz this is helpful. Can you add the code for calculating the run time to your example? Also, which version of FLORIS are you using?

[MYMahfouz]

Hi @rafmudaf,
I am sorry I don't understand what you mean by the code for calculating run time? Do you mean my full code where I copied this part from? Or you want me to add the time stamp?

I am using FLORIS v3.2.1

[rafmudaf]

Ah my apologies for not being clear. I'm wondering how you determined that the two cases ran in the same amount of time. Did you use the time module and do something like this? If so, that's the part I'm wondering to see - what did you include in the timing?

[MYMahfouz]

No worries, I am not an expert with python so I am not good with the terminology.

I calculated the time like this.

import time
AEPtotal=[]

for ww in range(len(wd)):
    LayoutperDirection=pd.DataFrame()
    LayoutperDirection['x']= LayoutX.loc[:,wd[ww]]
    LayoutperDirection['y']= LayoutY.loc[:,wd[ww]]  
    fi.reinitialize(layout_x=np.array(LayoutperDirection.x).tolist(),
                    layout_y=np.array(LayoutperDirection.y).tolist(),
                    wind_directions=[wd[ww]],
                    wind_speeds=ws) 
    t0=time.time()
    AEP=fi.get_farm_AEP([freq[ww]])
    t1=time.time()
    t=t1-t0
    AEPtotal.append(AEP)

Then I compared the time in the same code but adapted to run with FLORIS v2.4, and the time was less.

I also calculated in v3.2.1 the time for the AEP calculation for all wind directions and one wind directions and they were equal.

[rafmudaf]

Perfect, that's very helpful.

[MYMahfouz]

Hi,
I wanted to ask if there is any update on this?

Thank you.
Youssef

[rafmudaf]

@MYMahfouz I modified one of the examples so that we can have a shared script to work on. For future reference, sharing minimum example that we can run really helps us to understand the issue or question.

import numpy as np
import pandas as pd
from scipy.interpolate import NearestNDInterpolator

from floris.tools import FlorisInterface
import time

df_wr = pd.read_csv("inputs/wind_rose.csv")
wd_array = np.array(df_wr["wd"].unique(), dtype=float)
ws_array = np.array(df_wr["ws"].unique(), dtype=float)

wd_grid, ws_grid = np.meshgrid(wd_array, ws_array, indexing="ij")
freq_interp = NearestNDInterpolator(df_wr[["wd", "ws"]], df_wr["freq_val"])
freq = freq_interp(wd_grid, ws_grid)
freq = freq / np.sum(freq)

fi = FlorisInterface("inputs/gch.yaml") # GCH model

N_TURBINES = 100    # Large wind farm
D = 126             # NREL 5MW diameter
WS_INDEX = 10       # 10 m/s

# 1 wind direction AEP
fi.reinitialize(
    layout_x=[i * 5 * D for i in range(N_TURBINES)],
    layout_y=[0.0] * N_TURBINES,
    wind_directions=[wd_array[0]],
    wind_speeds=[ws_array[WS_INDEX]]
)
t0=time.time()
wd1_aep=fi.get_farm_AEP([freq[0,0:1]])
t1=time.time()
t=t1-t0
print(f"1 wind direction time: {t:.6f}")
print("1 wind direction AEP: {:.3f} GWh".format(wd1_aep / 1.0e9))

# Full wind rose AEP
fi.reinitialize(
    layout_x=[i * 5 * D for i in range(N_TURBINES)],
    layout_y=[0.0] * N_TURBINES,
    wind_directions=wd_array,
    wind_speeds=[ws_array[WS_INDEX]],
)
t0=time.time()
full_aep = fi.get_farm_AEP(freq=freq[:,0:1])
t1=time.time()
t=t1-t0
print(f"Full wind rose time: {t:.6f}")
print("Full wind rose AEP: {:.3f} GWh".format(full_aep / 1.0e9))

The results here show that the 1 wind direction calculation is quite a bit faster than the full wind rose, as expected:

(floris) >>mbp@~/Development/floris/examples (develop *$)$ python 07_calc_aep_from_rose.py 
floris.tools.floris_interface.FlorisInterface WARNING WARNING: The frequency array provided to get_farm_AEP() does not sum to 1.0.
1 wind direction time: 0.212506
1 wind direction AEP: 0.047 GWh
floris.tools.floris_interface.FlorisInterface WARNING WARNING: The frequency array provided to get_farm_AEP() does not sum to 1.0.
Full wind rose time: 3.037485
Full wind rose AEP: 5.558 GWh

Note that I'm using a 100 turbine farm. Whats the size of the farm in your example? As the size of the farm goes lower, I expect the computation time for both to converge. There's very little computational load for small farms.

I hope this helps and please let me know if you have any more questions.

[MYMahfouz]

Hi @rafmudaf,
Thank you for your reply and the comments.

I have a couple of designs from 7 turbines up to 25 turbines. You are right for a smaller wind farm there is no much difference in the time needed for AEP.

I simulate floating wind turbines and I account for the floaters motions in surge and sway directions on the AEP of the wind farm. I try to optimize the mooring system designs so these motions increase the AEP by benefiting from the motions in surge and sway DoFs.

Therefore, I repeat this calculation even for small wind farms thousands of time, therefore this time difference matters in my use case.

As I mentioned before, when I was using FLORIS v2,4 there was a huge difference in energy calculation between one wind direction and all wind directions. This difference was still there for smaller wind farms unlike FLORIS v3.

I would appreciate it if you have a suggestion on how I can decrease the AEP calculation time. Assuming 16 wind directions, for me calculating the full AEP once needs as much time as calculating the AEP of the entire farm 16 times.

Best regards