def larsen_1angle(layout_x, layout_y, wind_speed, angle, rotor_radius,
hub_height, TI):
U0 = wind_speed
r0 = rotor_radius
nt = len(layout_y) # Number of turbines
D = 2.0 * r0
A = pi * r0**2.0
H = hub_height # Hub height
ia = TI # Ambient turbulence intensity according to vanluvanee. 8% on average
def deff(u1):
return D * sqrt(
(1.0 + sqrt(1.0 - Ct(u1))) / (2.0 * sqrt(1.0 - Ct(u1))))
rnb = max(1.08 * D, 1.08 * D + 21.7 * D * (ia - 0.05))
r95 = 0.5 * (rnb + min(H, rnb))
def x0(u2):
return 9.5 * D / ((2.0 * r95 / deff(u2))**3.0 - 1.0)
def c1(u3):
return (deff(u3) / 2.0)**(5.0 / 2.0) * (105.0 / 2.0 / pi)**(
-1.0 / 2.0) * (Ct(u3) * A * x0(u3))**(-5.0 / 6.0
) # Prandtl mixing length
angle3 = angle + 180.0
deficit_matrix = [[0.0 for _ in range(nt)] for _ in range(nt)]
distance = [[0.0 for _ in range(2)] for _ in range(nt)]
U = [U0 for _ in range(nt)]
total_deficit = [0.0 for _ in range(nt)]
for tur in range(nt):
distance[tur] = [
distance_to_front(layout_x[tur], layout_y[tur], angle), tur
]
distance.sort()
for turbine in range(nt):
for num in range(turbine):
total_deficit[distance[turbine][1]] += deficit_matrix[
distance[turbine][1]][distance[num][1]]**2.0
total_deficit[distance[turbine][1]] = sqrt(
total_deficit[distance[turbine][1]])
U[distance[turbine][1]] = U0 * (1.0 -
total_deficit[distance[turbine][1]])
flag = [False for _ in range(nt)]
proportion = [0.0 for _ in range(nt)]
perpendicular_distance = [0.0 for _ in range(nt)]
parallel_distance = [0.0 for _ in range(nt)]
for i in range(turbine + 1, nt):
proportion[distance[i][1]], flag[distance[i][1]], perpendicular_distance[distance[i][1]], \
parallel_distance[distance[i][1]] = wake_larsen.determine_if_in_wake_larsen(
layout_x[distance[turbine][1]],
layout_y[distance[turbine][1]],
layout_x[distance[i][1]],
layout_y[distance[i][1]], A,
c1(U[distance[turbine][1]]),
Ct(U[distance[turbine][1]]), angle3,
r0, x0(U[distance[turbine][1]]))
if parallel_distance[distance[i][1]] > 0.0:
if proportion[distance[i][1]] != 0.0:
deficit_matrix[distance[i][1]][
distance[turbine][1]] = proportion[
distance[i][1]] * wake_larsen.wake_deficit(
U[distance[turbine][1]],
Ct(U[distance[turbine][1]]), A,
parallel_distance[distance[i][1]] +
x0(U[distance[turbine][1]]),
perpendicular_distance[distance[i][1]],
c1(U[distance[turbine][1]]))
else:
deficit_matrix[distance[i][1]][distance[turbine][1]] = 0.0
else:
deficit_matrix[distance[i][1]][distance[turbine][1]] = 0.0
return U
def analysis():
layout_x = []
layout_y = []
for line in layout:
columns = line.split()
layout_x.append(float(columns[0]))
layout_y.append(float(columns[1]))
windrose_angle = []
windrose_speed = []
windrose_frequency = []
for line in windrose:
columns = line.split()
windrose_angle.append(float(columns[0]))
windrose_speed.append(float(columns[1]))
windrose_frequency.append(float(columns[2]))
layout.close()
windrose.close()
def Ct(U0):
return 0.0001923077 * U0**4.0 + -0.0075407925 * U0**3.0 + 0.096462704 * U0**2.0 - 0.5012354312 * U0 + 1.7184749184
# def power(U0):
# return -0.0071427272 * U0**5.0 + 0.5981106302 * U0**4.0 - 18.5218157059 * U0**3.0 + 251.0929636046 * U0**2.0 - 1257.8070377904 * U0 + 2043.2240149783
def power(U0):
if U0 < 4.0:
return 0.0
elif U0 >= 4.0:
return 19.7907842158 * U0**2.0 - 74.9080669331 * U0 + 37.257967033 # From 4 to 11 m/s
# def Cp(U0):
# return power(U0) / (0.5 * 1.225 * pi * r0**2.0 * U0**3.0)
# for U0 in range(4, 20):
nt = 80 # Number of turbines
summation = 0.0
p = [0.0 for x in range(nt)]
ct = 0.0
for wind in range(0, len(windrose_speed)):
ct += 1
# for wind in range(180-2, 180+3):
# if wind in [100, 133, 271, 280, 313]:
# continue
# U1 = windrose_speed[wind] # Free stream wind speed
# U0 = U1 * (70.0 / 10.0)**0.11 # Power or log law for wind shear profile
# U0 = U1 * log(70.0 / 0.005) / log(10.0 / 0.005)
U0 = 8.5
k = 0.04 # Decay constant
r0 = 40.0 # Turbine rotor radius
angle = windrose_angle[wind]
angle3 = angle + 180.0
deficit_matrix = [[0.0 for x in range(nt)] for x in range(nt)]
proportion = [[0.0 for x in range(nt)] for x in range(nt)]
affected_matrix = [[] for x in range(nt)]
for turbine in range(0, nt):
flag = [False for x in range(nt)]
for i in range(nt):
if i != turbine:
proportion[i][turbine], flag[
i] = wake.determine_if_in_wake(layout_x[turbine],
layout_y[turbine],
layout_x[i],
layout_y[i], k, r0,
angle3)
elif i == turbine:
proportion[i][turbine] = 0.0
flag[i] = False
if flag[i] is True:
affected_matrix[i].append(turbine)
deficit = [0.0 for x in range(nt)]
length = [0 for x in range(nt)]
U = [0.0 for x in range(nt)]
for i in range(nt):
length[i] = len(affected_matrix[i])
row.write('{0:f}\t{1:f}\t{2:d}\n'.format(layout_x[i], layout_y[i],
len(affected_matrix[i])))
row_vector = [[] for x in range(0, max(length) + 1)]
for i in range(nt):
for n in range(0, max(length) + 1):
if length[i] == n:
row_vector[n].append(i)
total_deficit = [0.0 for x in range(nt)]
counter = 0
for n in range(0, max(length) + 1):
# for n in range(0, 5):
if n == 0:
for turb in row_vector[n]:
deficit[turb] = 0.0
U[turb] = U0
else:
for turb in row_vector[n]:
for i in affected_matrix[turb]:
# print U[i], turb, turb, i, i, counter
if U[i] == 0.0:
row_vector[n].append(turb)
counter += 1
continue
elif deficit_matrix[turb][i] == 0.0:
deficit_matrix[turb][
i] = proportion[turb][i] * wake.wake_deficit(
Ct(U[i]), k,
wake.distance(layout_x[turb],
layout_y[turb], layout_x[i],
layout_y[i]), r0)
total_deficit[turb] += deficit_matrix[turb][i]**2.0
if counter >= 20000:
break
total_deficit[turb] = sqrt(total_deficit[turb])
U[turb] = U0 * (1.0 - total_deficit[turb])
for turb in range(nt):
for i in range(nt):
output.write('{0:f}\t'.format(deficit_matrix[turb][i]))
output.write('\n')
output2.write(
'{0:d}\t{1:.1f}\t{2:.1f}\t{3:f}\t{4:f}\t{5:d}\t{6:f}\n'.format(
turb, layout_x[turb], layout_y[turb], total_deficit[turb],
U[turb], int(angle), power(U[turb])))
output2.write('\n')
# Individual turbine efficiency
# if angle == 0:
# for g in range(nt):
# p[g] += power(U[g])/power(U[row_vector[0][0]])
turb_data.write('{0:f}\t{1:f}\n'.format(angle, power(U[14])))
# Farm efficiency
profit = 0.0
efficiency_proportion = [
0.0 for x in range(0, len(windrose_frequency))
]
for l in range(nt):
profit += power(U[l])
# print row_vector[0][0]
efficiency = profit * 100.0 / (float(nt) * power(U[row_vector[0][0]]))
efficiency_proportion[
wind] = efficiency * windrose_frequency[wind] / 100.0
# print 'Farm efficiency with wind direction = {0:d} deg: {1:2.2f}%'.format(int(angle), efficiency)
print angle, efficiency
direction.write('{0:f}\t{1:f}\n'.format(angle, efficiency))
summation += efficiency_proportion[wind]
print 'total farm efficiency is {0:f} %'.format(summation)
# for g in range(nt):
# turb_data.write('{0:d}\t{1:f}\t{2:f}\t{3:f}\n'.format(g, layout_x[g], layout_y[g], p[g] / ct))
# turb_data.write('\n')
turb_data.close()
output.close()
output2.close()
draw.close()
direction.close()
row.close()
def analysis():
# for U0 in range(4, 20):
nt = len(layout_y) # Number of turbines
summation = 0.0
r0 = 40.0 # Turbine rotor radius
D = 2.0 * r0
A = pi * r0 ** 2.0
H = 70.0 # Hub height
ia = 0.08 # Ambient turbulence intensity according to vanluvanee. 8% on average
def deff(U0):
return D * sqrt((1.0 + sqrt(1.0 - Ct(U0))) / (2.0 * sqrt(1.0 - Ct(U0))))
rnb = max(1.08 * D, 1.08 * D + 21.7 * D * (ia - 0.05))
r95 = 0.5 * (rnb + min(H, rnb))
def x0(U0):
return 9.5 * D / ((2.0 * r95 / deff(U0)) ** 3.0 - 1.0)
def c1(U0):
return (deff(U0) / 2.0) ** (5.0 / 2.0) * (105.0 / 2.0 / pi) ** (- 1.0 / 2.0) * (Ct(U0) * A * x0(U0)) ** (- 5.0 / 6.0) # Prandtl mixing length
def distance_to_front(x, y, theta, r):
theta = deg2rad(theta)
return abs(x + tan(theta) * y - r / cos(theta)) / sqrt(1.0 + tan(theta) ** 2.0)
for wind in range(0, len(windrose_angle)):
# for wind in range(90, 91):
# if wind in [100, 133, 271, 280, 313]:
# continue
# U1 = windrose_speed[wind] # Free stream wind speed
# U0 = U1 * (70.0 / 10.0) ** 0.11 # Power or log law for wind shear profile
# U0 = U1 * log(70.0 / 0.005) / log(10.0 / 0.005)
U0 = 8.5
angle = windrose_angle[wind]
angle3 = angle + 180.0
deficit_matrix = [[0.0 for x in range(nt)] for x in range(nt)]
distance = [[0.0 for x in range(2)] for x in range(nt)]
U = [U0 for x in range(nt)]
total_deficit = [0.0 for x in range(nt)]
for tur in range(nt):
distance[tur] = [distance_to_front(layout_x[tur], layout_y[tur], angle, 100000000.0), tur]
distance.sort()
for turbine in range(nt):
for num in range(turbine):
total_deficit[distance[turbine][1]] += deficit_matrix[distance[turbine][1]][distance[num][1]] ** 2.0
total_deficit[distance[turbine][1]] = sqrt(total_deficit[distance[turbine][1]])
U[distance[turbine][1]] = U0 * (1.0 - total_deficit[distance[turbine][1]])
flag = [False for x in range(nt)]
proportion = [0.0 for x in range(nt)]
perpendicular_distance = [0.0 for x in range(nt)]
parallel_distance = [0.0 for x in range(nt)]
for i in range(turbine + 1, nt):
proportion[distance[i][1]], flag[distance[i][1]], perpendicular_distance[distance[i][1]], parallel_distance[distance[i][1]] = wake.determine_if_in_wake(layout_x[distance[turbine][1]], layout_y[distance[turbine][1]], layout_x[distance[i][1]], layout_y[distance[i][1]], A, c1(U[distance[turbine][1]]), Ct(U[distance[turbine][1]]), angle3, r0, x0(U[distance[turbine][1]]))
if parallel_distance[distance[i][1]] > 0.0: ## Add if proportion is 0, skip operation and deficit_matrix == 0.
deficit_matrix[distance[i][1]][distance[turbine][1]] = proportion[distance[i][1]] * wake.wake_deficit(U[distance[turbine][1]], Ct(U[distance[turbine][1]]), A, parallel_distance[distance[i][1]] + x0(U[distance[turbine][1]]), perpendicular_distance[distance[i][1]], c1(U[distance[turbine][1]]))
else:
deficit_matrix[distance[i][1]][distance[turbine][1]] = 0.0
# for turb in range(nt):
# for i in range(nt):
# output.write('{0:f}\t'.format(deficit_matrix[turb][i]))
# output.write('\n')
# output2.write('{0:d}\t{1:.1f}\t{2:.1f}\t{3:f}\t{4:f}\t{5:d}\t{6:f}\n'.format(turb, layout_x[turb], layout_y[turb], total_deficit[turb], U[turb], int(angle), power(U[turb])))
# output2.write('\n')
# for n in range(nt):
# aver[n] += power(U[n]) / 360.0
# ---------------------------------------TODO UNCOMMENT -----------------------------------------
if withdata:
turb_data.write('{0:f} {1:f}\n'.format(angle, power(U[14])))
# Farm efficiency
profit = 0.0
efficiency_proportion = [0.0 for x in range(0, len(windrose_frequency))]
for l in range(nt):
profit += power(U[l])
efficiency = profit * 100.0 / (float(nt) * power(U[distance[0][1]]))
efficiency_proportion[wind] = efficiency * windrose_frequency[wind] / 100.0
# ---------------------------------------TODO UNCOMMENT ------------------------------------------
if withdata:
direction.write('{0:f} {1:f}\n'.format(angle, profit))
summation += efficiency_proportion[wind]
return summation
def larsen(a, windrose_angle, windrose_speed, windrose_frequency):
import wake_geometry as wake
from math import sqrt, log, tan, cos, pi
from numpy import deg2rad
nt = len(a) # Number of turbines
summation = 0.0
layout_x = [0.0 for x in range(nt)]
layout_y = [0.0 for x in range(nt)]
for x in range(nt):
layout_x[x] = float(a[x][0])
layout_y[x] = float(a[x][1])
def Ct(U0):
if U0 < 4.0:
return 0.1
elif U0 <= 25.0:
return 0.00000073139922126945 * U0**6.0 - 0.0000668905596915255 * U0**5.0 + 0.0023937885 * U0**4.0 + -0.0420283143 * U0**3.0 + 0.3716111285 * U0**2.0 - 1.5686969749 * U0 + 3.2991094727
else:
return 0.0
def power(U0):
if U0 < 4.0:
return 0.0
elif U0 <= 25.0:
return 0.0003234808 * U0**7.0 - 0.0331940121 * U0**6.0 + 1.3883148012 * U0**5.0 - 30.3162345004 * U0**4.0 + 367.6835557011 * U0**3.0 - 2441.6860655008 * U0**2.0 + 8345.6777042343 * U0 - 11352.9366182805
else:
return 0.0
# for U0 in range(4, 20):
r0 = 40.0 # Turbine rotor radius
D = 2.0 * r0
A = pi * r0**2.0
H = 70.0 # Hub height
ia = 0.08 # Ambient turbulence intensity according to vanlucanee. 8% on average
def deff(U0):
return D * sqrt(
(1.0 + sqrt(1.0 - Ct(U0))) / (2.0 * sqrt(1.0 - Ct(U0))))
rnb = max(1.08 * D, 1.08 * D + 21.7 * D * (ia - 0.05))
r95 = 0.5 * (rnb + min(H, rnb))
def x0(U0):
return 9.5 * D / ((2.0 * r95 / deff(U0))**3.0 - 1.0)
def c1(U0):
return (deff(U0) / 2.0)**(5.0 / 2.0) * (105.0 / 2.0 / pi)**(
-1.0 / 2.0) * (Ct(U0) * A * x0(U0))**(-5.0 / 6.0
) # Prandtl mixing length
def distance_to_front(x, y, theta, r):
theta = deg2rad(theta)
return abs(x + tan(theta) * y - r / cos(theta)) / sqrt(1.0 +
tan(theta)**2.0)
for wind in range(0, len(windrose_angle)):
U1 = windrose_speed[wind] # Free stream wind speed
U0 = U1 * (70.0 /
10.0)**0.11 # Power or log law for wind shear profile
angle = windrose_angle[wind]
angle3 = angle + 180.0
deficit_matrix = [[0.0 for x in range(nt)] for x in range(nt)]
distance = [[0.0 for x in range(2)] for x in range(nt)]
U = [U0 for x in range(nt)]
total_deficit = [0.0 for x in range(nt)]
for tur in range(nt):
distance[tur] = [
distance_to_front(layout_x[tur], layout_y[tur], angle,
100000000.0), tur
]
distance.sort()
for turbine in range(nt):
for num in range(turbine):
total_deficit[distance[turbine][1]] += deficit_matrix[
distance[turbine][1]][distance[num][1]]**2.0
total_deficit[distance[turbine][1]] = sqrt(
total_deficit[distance[turbine][1]])
U[distance[turbine]
[1]] = U0 * (1.0 - total_deficit[distance[turbine][1]])
flag = [False for x in range(nt)]
proportion = [0.0 for x in range(nt)]
perpendicular_distance = [0.0 for x in range(nt)]
parallel_distance = [0.0 for x in range(nt)]
for i in range(turbine + 1, nt):
proportion[distance[i][1]], flag[
distance[i][1]], perpendicular_distance[
distance[i][1]], parallel_distance[
distance[i][1]] = wake.determine_if_in_wake(
layout_x[distance[turbine][1]],
layout_y[distance[turbine][1]],
layout_x[distance[i][1]],
layout_y[distance[i][1]], A,
c1(U[distance[turbine][1]]),
Ct(U[distance[turbine][1]]), angle3, r0)
if parallel_distance[distance[i][1]] > 0.0:
deficit_matrix[distance[i][1]][distance[turbine][
1]] = proportion[distance[i][1]] * wake.wake_deficit(
U[distance[turbine][1]], Ct(
U[distance[turbine][1]]), A,
parallel_distance[distance[i][1]],
perpendicular_distance[distance[i][1]],
c1(U[distance[turbine][1]]))
else:
deficit_matrix[distance[i][1]][distance[turbine][1]] = 0.0
# Farm efficiency
profit = 0.0
efficiency_proportion = [
0.0 for x in range(0, len(windrose_frequency))
]
for l in range(nt):
profit += power(U[l])
efficiency = profit * 100.0 / (float(nt) * power(U[distance[0][1]]))
efficiency_proportion[
wind] = efficiency * windrose_frequency[wind] / 100.0
summation += efficiency_proportion[wind]
return 100.0 - summation
def analysis(v):
output = open('matrix_larsen.dat', 'w')
output.write(
'# This file has the wake deficit matrix per turbine per wind direction\n'
)
output2 = open('final_speed_larsen.dat', 'w')
output2.write(
'# This file has the deficit, wind speed and power at each turbine per wind direction.\n# Turbine number\tX-coordinate\tY-coordinate\tTotal speed deficit\tTotal wind speed\tWind direction angle\tPower produced\n'
)
layout = open('../area_overlap/horns_rev.dat',
'r') # Or horns_rev.dat for full layout
windrose = open('horns_rev_windrose2.dat', 'r')
draw = open('draw_horns_rev_larsen.dat', 'w')
draw.write(
'# This file has the turbines affected by the wake of one turbine at one direction.\n'
)
# draw2 = open('drawline.dat', 'w')
turb_data = open('turb17_larsenviejo.dat', 'w')
direction = open('direction_efficiency_larsen.dat', 'w')
direction.write(
'# This file includes the efficiency of the whole farm by wind direction.\n# Wind direction angle\tFarm efficiency\n'
)
nt = 80 # Or 80 for full layout
layout_x = []
layout_y = []
for line in layout:
columns = line.split()
layout_x.append(float(columns[0]))
layout_y.append(float(columns[1]))
windrose_angle = []
windrose_speed = []
windrose_frequency = []
for line in windrose:
columns = line.split()
windrose_angle.append(float(columns[0]))
windrose_speed.append(float(columns[1]))
windrose_frequency.append(float(columns[2]))
layout.close()
windrose.close()
summation = 0.0
def power(U0):
if U0 < 4.0:
return 0.0
elif U0 <= 25.0:
return 0.0003234808 * U0**7.0 - 0.0331940121 * U0**6.0 + 1.3883148012 * U0**5.0 - 30.3162345004 * U0**4.0 + 367.6835557011 * U0**3.0 - 2441.6860655008 * U0**2.0 + 8345.6777042343 * U0 - 11352.9366182805
else:
return 0.0
r0 = 40.0 # Turbine rotor radius
D = 2.0 * r0
A = pi * r0**2.0
ct = 0.81
deff = D * sqrt((1.0 + sqrt(1.0 - ct)) / (2.0 * sqrt(1.0 - ct)))
H = 70.0 # Hub height
ia = 0.08 # Ambient turbulence intensity according to vanlucanee. 8% on average
rnb = max(1.08 * D, 1.08 * D + 21.7 * D * (ia - 0.05))
r95 = 0.5 * (rnb + min(H, rnb))
x0 = 9.5 * D / ((2.0 * r95 / deff)**3.0 - 1.0)
c1 = (deff / 2.0)**(5.0 / 2.0) * (105.0 / 2.0 / pi)**(-1.0 / 2.0) * (
ct * A * x0)**(-5.0 / 6.0) # Prandtl mixing length
for wind in range(0, len(windrose_speed)):
# for wind in range(0, 1):
# U1 = windrose_speed[wind] # Free stream wind speed
# U0 = U1 * (70.0 / 10.0)**0.11 # Power or log law for wind shear profile
# U0 = U1 * log(70.0 / 0.005) / log(10.0 / 0.005)
U0 = 8.5
angle = windrose_angle[wind]
angle3 = angle + 180.0
wake_deficit_matrix = [[0.0 for x in range(nt)] for x in range(nt)]
for turbine in range(nt):
flag = [False for x in range(nt)]
proportion = [0.0 for x in range(nt)]
perpendicular_distance = [0.0 for x in range(nt)]
parallel_distance = [0.0 for x in range(nt)]
for i in range(nt):
proportion[i], flag[i], perpendicular_distance[
i], parallel_distance[i] = wake.determine_if_in_wake(
layout_x[turbine], layout_y[turbine], layout_x[i],
layout_y[i], A, c1, ct, angle3, r0)
# Matrix with effect of each turbine <i = turbine> on every other turbine <j> of the farm
for j in range(nt):
if turbine != j and flag[j] is True:
# print (U0, ct, A, parallel_distance[j], perpendicular_distance[j], c1, x0, r95, rnb, deff)
wake_deficit_matrix[turbine][
j] = proportion[j] * wake.wake_deficit(
U0, ct, A, parallel_distance[j],
perpendicular_distance[j], c1)
elif turbine == j:
wake_deficit_matrix[turbine][j] = 0.0
output.write('{0:f}\t'.format(wake_deficit_matrix[turbine][j]))
output.write('\n')
total_deficit = [0.0 for x in range(nt)]
total_speed = [0.0 for x in range(nt)]
for j in range(nt):
for i in range(nt):
total_deficit[j] += wake_deficit_matrix[i][j]**2.0
total_deficit[j] = sqrt(total_deficit[j])
total_speed[j] = U0 * (1.0 - total_deficit[j])
output2.write(
'{0:d}\t{1:.1f}\t{2:.1f}\t{3:f}\t{4:f}\t{5:d}\t{6:f}\n'.format(
j, layout_x[j], layout_y[j], total_deficit[j],
total_speed[j], int(angle), power(total_speed[j])))
output2.write('\n')
turb_data.write('{0:f}\t{1:f}\n'.format(angle, power(total_speed[14])))
# Individual turbine efficiency
# for g in range(nt):
# turb_data.write('{0:f}\n'.format(total_speed[g]))
# Farm efficiency
profit = 0.0
efficiency_proportion = [
0.0 for x in range(0, len(windrose_frequency))
]
efficiency = 0.0
for l in range(nt):
profit += power(total_speed[l])
efficiency = profit * 100.0 / (nt * power(U0))
efficiency_proportion[
wind] = efficiency / 100.0 * windrose_frequency[wind]
# print 'Farm efficiency with wind direction = {0:d} deg: {1:2.2f}%'.format(int(angle), efficiency)
direction.write('{0:f}\t{1:f}\n'.format(angle, efficiency))
summation += efficiency_proportion[wind]
print('total farm efficiency is {0:f} %'.format(summation))
turb_data.close()
output.close()
output2.close()
draw.close()
direction.close()
def solve_nonlinear(self, params, unknowns, resids):
U0 = params['mean_ambient_wind_speed']
layout_y = params['layout_y']
layout_x = params['layout_x']
angle = params['wind_direction']
nt = num_turb
r0 = params['rotor_radius'] # Turbine rotor radius
D = 2.0 * r0
A = pi * r0**2.0
ia = params[
'TI'] # Ambient turbulence intensity according to vanluvanee. 8% on average
H = params['hub_height']
def deff(U0):
return D * sqrt(
(1.0 + sqrt(1.0 - Ct(U0))) / (2.0 * sqrt(1.0 - Ct(U0))))
rnb = max(1.08 * D, 1.08 * D + 21.7 * D * (ia - 0.05))
r95 = 0.5 * (rnb + min(H, rnb))
def x0(U0):
return 9.5 * D / ((2.0 * r95 / deff(U0))**3.0 - 1.0)
def c1(U0):
return (deff(U0) / 2.0)**(5.0 / 2.0) * (105.0 / 2.0 / pi)**(
-1.0 / 2.0) * (Ct(U0) * A * x0(U0))**(
-5.0 / 6.0) # Prandtl mixing length
angle3 = angle + 180.0
deficit_matrix = [[0.0 for _ in range(nt)] for _ in range(nt)]
distance = [[0.0 for _ in range(2)] for _ in range(nt)]
U = [U0 for _ in range(nt)]
total_deficit = [0.0 for _ in range(nt)]
for tur in range(nt):
distance[tur] = [
distance_to_front(layout_x[tur], layout_y[tur], angle), tur
]
distance.sort()
for turbine in range(nt):
for num in range(turbine):
total_deficit[distance[turbine][1]] += deficit_matrix[
distance[turbine][1]][distance[num][1]]**2.0
total_deficit[distance[turbine][1]] = sqrt(
total_deficit[distance[turbine][1]])
U[distance[turbine]
[1]] = U0 * (1.0 - total_deficit[distance[turbine][1]])
flag = [False for _ in range(nt)]
proportion = [0.0 for _ in range(nt)]
perpendicular_distance = [0.0 for _ in range(nt)]
parallel_distance = [0.0 for _ in range(nt)]
for i in range(turbine + 1, nt):
proportion[distance[i][1]], flag[distance[i][1]], perpendicular_distance[distance[i][1]], \
parallel_distance[distance[i][1]] = wake_larsen.determine_if_in_wake_larsen(
layout_x[distance[turbine][1]],
layout_y[distance[turbine][1]],
layout_x[distance[i][1]],
layout_y[distance[i][1]], A,
c1(U[distance[turbine][1]]),
Ct(U[distance[turbine][1]]), angle3,
r0, x0(U[distance[turbine][1]]))
if parallel_distance[distance[i][1]] > 0.0:
if proportion[distance[i][1]] != 0.0:
deficit_matrix[distance[i][1]][
distance[turbine][1]] = proportion[
distance[i][1]] * wake_larsen.wake_deficit(
U[distance[turbine][1]],
Ct(U[distance[turbine][1]]), A,
parallel_distance[distance[i][1]] +
x0(U[distance[turbine][1]]),
perpendicular_distance[distance[i][1]],
c1(U[distance[turbine][1]]))
else:
deficit_matrix[distance[i][1]][distance[turbine]
[1]] = 0.0
else:
deficit_matrix[distance[i][1]][distance[turbine][1]] = 0.0
unknowns['U'] = array(U)
def analysis():
layout_x = []
layout_y = []
for line in layout:
columns = line.split()
layout_x.append(float(columns[0]))
layout_y.append(float(columns[1]))
windrose_angle = []
windrose_speed = []
windrose_frequency = []
for line in windrose:
columns = line.split()
windrose_angle.append(float(columns[0]))
windrose_speed.append(float(columns[1]))
windrose_frequency.append(float(columns[2]))
layout.close()
windrose.close()
def Ct(U0):
return 0.0001923077 * U0**4.0 + -0.0075407925 * U0**3.0 + 0.096462704 * U0**2.0 - 0.5012354312 * U0 + 1.7184749184
# def power(U0):
# return -0.0071427272 * U0**5.0 + 0.5981106302 * U0**4.0 - 18.5218157059 * U0**3.0 + 251.0929636046 * U0**2.0 - 1257.8070377904 * U0 + 2043.2240149783
def power(U0):
if U0 < 4.0:
return 0.0
elif U0 >= 4.0:
return 19.7907842158 * U0 ** 2.0 - 74.9080669331 * U0 + 37.257967033 # From 4 to 11 m/s
# def Cp(U0):
# return power(U0) / (0.5 * 1.225 * pi * r0**2.0 * U0**3.0)
# for U0 in range(4, 20):
nt = 80 # Number of turbines
summation = 0.0
p = [0.0 for x in range(nt)]
ct = 0.0
for wind in range(0, len(windrose_speed)):
ct += 1
# for wind in range(180-2, 180+3):
# if wind in [100, 133, 271, 280, 313]:
# continue
# U1 = windrose_speed[wind] # Free stream wind speed
# U0 = U1 * (70.0 / 10.0)**0.11 # Power or log law for wind shear profile
# U0 = U1 * log(70.0 / 0.005) / log(10.0 / 0.005)
U0 = 8.5
k = 0.04 # Decay constant
r0 = 40.0 # Turbine rotor radius
angle = windrose_angle[wind]
angle3 = angle + 180.0
deficit_matrix = [[0.0 for x in range(nt)] for x in range(nt)]
proportion = [[0.0 for x in range(nt)] for x in range(nt)]
affected_matrix = [[] for x in range(nt)]
for turbine in range(0, nt):
flag = [False for x in range(nt)]
for i in range(nt):
if i != turbine:
proportion[i][turbine], flag[i] = wake.determine_if_in_wake(layout_x[turbine], layout_y[turbine], layout_x[i], layout_y[i], k, r0, angle3)
elif i == turbine:
proportion[i][turbine] = 0.0
flag[i] = False
if flag[i] is True:
affected_matrix[i].append(turbine)
deficit = [0.0 for x in range(nt)]
length = [0 for x in range(nt)]
U = [0.0 for x in range(nt)]
for i in range(nt):
length[i] = len(affected_matrix[i])
row.write('{0:f}\t{1:f}\t{2:d}\n'.format(layout_x[i], layout_y[i], len(affected_matrix[i])))
row_vector = [[] for x in range(0, max(length) + 1)]
for i in range(nt):
for n in range(0, max(length) + 1):
if length[i] == n:
row_vector[n].append(i)
total_deficit = [0.0 for x in range(nt)]
counter = 0
for n in range(0, max(length) + 1):
# for n in range(0, 5):
if n == 0:
for turb in row_vector[n]:
deficit[turb] = 0.0
U[turb] = U0
else:
for turb in row_vector[n]:
for i in affected_matrix[turb]:
# print U[i], turb, turb, i, i, counter
if U[i] == 0.0:
row_vector[n].append(turb)
counter += 1
continue
elif deficit_matrix[turb][i] == 0.0:
deficit_matrix[turb][i] = proportion[turb][i] * wake.wake_deficit(Ct(U[i]), k, wake.distance(layout_x[turb], layout_y[turb], layout_x[i], layout_y[i]), r0)
total_deficit[turb] += deficit_matrix[turb][i] ** 2.0
if counter >= 20000:
break
total_deficit[turb] = sqrt(total_deficit[turb])
U[turb] = U0 * (1.0 - total_deficit[turb])
for turb in range(nt):
for i in range(nt):
output.write('{0:f}\t'.format(deficit_matrix[turb][i]))
output.write('\n')
output2.write('{0:d}\t{1:.1f}\t{2:.1f}\t{3:f}\t{4:f}\t{5:d}\t{6:f}\n'.format(turb, layout_x[turb], layout_y[turb], total_deficit[turb], U[turb], int(angle), power(U[turb])))
output2.write('\n')
# Individual turbine efficiency
# if angle == 0:
# for g in range(nt):
# p[g] += power(U[g])/power(U[row_vector[0][0]])
turb_data.write('{0:f}\t{1:f}\n'.format(angle, power(U[14])))
# Farm efficiency
profit = 0.0
efficiency_proportion = [0.0 for x in range(0, len(windrose_frequency))]
for l in range(nt):
profit += power(U[l])
# print row_vector[0][0]
efficiency = profit * 100.0 / (float(nt) * power(U[row_vector[0][0]]))
efficiency_proportion[wind] = efficiency * windrose_frequency[wind] / 100.0
# print 'Farm efficiency with wind direction = {0:d} deg: {1:2.2f}%'.format(int(angle), efficiency)
print angle, efficiency
direction.write('{0:f}\t{1:f}\n'.format(angle, efficiency))
summation += efficiency_proportion[wind]
print 'total farm efficiency is {0:f} %'.format(summation)
# for g in range(nt):
# turb_data.write('{0:d}\t{1:f}\t{2:f}\t{3:f}\n'.format(g, layout_x[g], layout_y[g], p[g] / ct))
# turb_data.write('\n')
turb_data.close()
output.close()
output2.close()
draw.close()
direction.close()
row.close()
def larsen(a, windrose_angle, windrose_speed, windrose_frequency):
import wake_geometry as wake
from math import sqrt, log, tan, cos, pi
from numpy import deg2rad
nt = len(a) # Number of turbines
summation = 0.0
layout_x = [0.0 for x in range(nt)]
layout_y = [0.0 for x in range(nt)]
for x in range(nt):
layout_x[x] = float(a[x][0])
layout_y[x] = float(a[x][1])
def Ct(U0):
if U0 < 4.0:
return 0.1
elif U0 <= 25.0:
return 0.00000073139922126945 * U0 ** 6.0 - 0.0000668905596915255 * U0 ** 5.0 + 0.0023937885 * U0 ** 4.0 + - 0.0420283143 * U0 ** 3.0 + 0.3716111285 * U0 ** 2.0 - 1.5686969749 * U0 + 3.2991094727
else:
return 0.0
def power(U0):
if U0 < 4.0:
return 0.0
elif U0 <= 25.0:
return 0.0003234808 * U0 ** 7.0 - 0.0331940121 * U0 ** 6.0 + 1.3883148012 * U0 **5.0 - 30.3162345004 * U0 ** 4.0 + 367.6835557011 * U0 ** 3.0 - 2441.6860655008 * U0 ** 2.0 + 8345.6777042343 * U0 - 11352.9366182805
else:
return 0.0
# for U0 in range(4, 20):
r0 = 40.0 # Turbine rotor radius
D = 2.0 * r0
A = pi * r0 ** 2.0
H = 70.0 # Hub height
ia = 0.08 # Ambient turbulence intensity according to vanlucanee. 8% on average
def deff(U0):
return D * sqrt((1.0 + sqrt(1.0 - Ct(U0))) / (2.0 * sqrt(1.0 - Ct(U0))))
rnb = max(1.08 * D, 1.08 * D + 21.7 * D * (ia - 0.05))
r95 = 0.5 * (rnb + min(H, rnb))
def x0(U0):
return 9.5 * D / ((2.0 * r95 / deff(U0)) ** 3.0 - 1.0)
def c1(U0):
return (deff(U0) / 2.0) ** (5.0 / 2.0) * (105.0 / 2.0 / pi) ** (- 1.0 / 2.0) * (Ct(U0) * A * x0(U0)) ** (- 5.0 / 6.0) # Prandtl mixing length
def distance_to_front(x, y, theta, r):
theta = deg2rad(theta)
return abs(x + tan(theta) * y - r / cos(theta)) / sqrt(1.0 + tan(theta) ** 2.0)
for wind in range(0, len(windrose_angle)):
U1 = windrose_speed[wind] # Free stream wind speed
U0 = U1 * (70.0 / 10.0) ** 0.11 # Power or log law for wind shear profile
angle = windrose_angle[wind]
angle3 = angle + 180.0
deficit_matrix = [[0.0 for x in range(nt)] for x in range(nt)]
distance = [[0.0 for x in range(2)] for x in range(nt)]
U = [U0 for x in range(nt)]
total_deficit = [0.0 for x in range(nt)]
for tur in range(nt):
distance[tur] = [distance_to_front(layout_x[tur], layout_y[tur], angle, 100000000.0), tur]
distance.sort()
for turbine in range(nt):
for num in range(turbine):
total_deficit[distance[turbine][1]] += deficit_matrix[distance[turbine][1]][distance[num][1]] ** 2.0
total_deficit[distance[turbine][1]] = sqrt(total_deficit[distance[turbine][1]])
U[distance[turbine][1]] = U0 * (1.0 - total_deficit[distance[turbine][1]])
flag = [False for x in range(nt)]
proportion = [0.0 for x in range(nt)]
perpendicular_distance = [0.0 for x in range(nt)]
parallel_distance = [0.0 for x in range(nt)]
for i in range(turbine + 1, nt):
proportion[distance[i][1]], flag[distance[i][1]], perpendicular_distance[distance[i][1]], parallel_distance[distance[i][1]] = wake.determine_if_in_wake(layout_x[distance[turbine][1]], layout_y[distance[turbine][1]], layout_x[distance[i][1]], layout_y[distance[i][1]], A, c1(U[distance[turbine][1]]), Ct(U[distance[turbine][1]]), angle3, r0)
if parallel_distance[distance[i][1]] > 0.0:
deficit_matrix[distance[i][1]][distance[turbine][1]] = proportion[distance[i][1]] * wake.wake_deficit(U[distance[turbine][1]], Ct(U[distance[turbine][1]]), A, parallel_distance[distance[i][1]], perpendicular_distance[distance[i][1]], c1(U[distance[turbine][1]]))
else:
deficit_matrix[distance[i][1]][distance[turbine][1]] = 0.0
# Farm efficiency
profit = 0.0
efficiency_proportion = [0.0 for x in range(0, len(windrose_frequency))]
for l in range(nt):
profit += power(U[l])
efficiency = profit * 100.0 / (float(nt) * power(U[distance[0][1]]))
efficiency_proportion[wind] = efficiency * windrose_frequency[wind] / 100.0
summation += efficiency_proportion[wind]
return 100.0 - summation
def larsen_1angle(layout_x, layout_y, wind_speed, angle, rotor_radius, hub_height, TI):
U0 = wind_speed
r0 = rotor_radius
nt = len(layout_y) # Number of turbines
D = 2.0 * r0
A = pi * r0 ** 2.0
H = hub_height # Hub height
ia = TI # Ambient turbulence intensity according to vanluvanee. 8% on average
def deff(u1):
return D * sqrt((1.0 + sqrt(1.0 - Ct(u1))) / (2.0 * sqrt(1.0 - Ct(u1))))
rnb = max(1.08 * D, 1.08 * D + 21.7 * D * (ia - 0.05))
r95 = 0.5 * (rnb + min(H, rnb))
def x0(u2):
return 9.5 * D / ((2.0 * r95 / deff(u2)) ** 3.0 - 1.0)
def c1(u3):
return (deff(u3) / 2.0) ** (5.0 / 2.0) * (105.0 / 2.0 / pi) ** (- 1.0 / 2.0) * (Ct(u3) * A * x0(u3)) ** (
- 5.0 / 6.0) # Prandtl mixing length
angle3 = angle + 180.0
deficit_matrix = [[0.0 for _ in range(nt)] for _ in range(nt)]
distance = [[0.0 for _ in range(2)] for _ in range(nt)]
U = [U0 for _ in range(nt)]
total_deficit = [0.0 for _ in range(nt)]
for tur in range(nt):
distance[tur] = [distance_to_front(layout_x[tur], layout_y[tur], angle), tur]
distance.sort()
for turbine in range(nt):
for num in range(turbine):
total_deficit[distance[turbine][1]] += deficit_matrix[distance[turbine][1]][distance[num][1]] ** 2.0
total_deficit[distance[turbine][1]] = sqrt(total_deficit[distance[turbine][1]])
U[distance[turbine][1]] = U0 * (1.0 - total_deficit[distance[turbine][1]])
flag = [False for _ in range(nt)]
proportion = [0.0 for _ in range(nt)]
perpendicular_distance = [0.0 for _ in range(nt)]
parallel_distance = [0.0 for _ in range(nt)]
for i in range(turbine + 1, nt):
proportion[distance[i][1]], flag[distance[i][1]], perpendicular_distance[distance[i][1]], \
parallel_distance[distance[i][1]] = wake_larsen.determine_if_in_wake_larsen(
layout_x[distance[turbine][1]],
layout_y[distance[turbine][1]],
layout_x[distance[i][1]],
layout_y[distance[i][1]], A,
c1(U[distance[turbine][1]]),
Ct(U[distance[turbine][1]]), angle3,
r0, x0(U[distance[turbine][1]]))
if parallel_distance[
distance[i][1]] > 0.0:
if proportion[distance[i][1]] != 0.0:
deficit_matrix[distance[i][1]][distance[turbine][1]] = proportion[
distance[i][
1]] * wake_larsen.wake_deficit(
U[distance[turbine][1]], Ct(U[distance[turbine][1]]), A,
parallel_distance[distance[i][1]] + x0(U[distance[turbine][1]]),
perpendicular_distance[distance[i][1]], c1(U[distance[turbine][1]]))
else:
deficit_matrix[distance[i][1]][distance[turbine][1]] = 0.0
else:
deficit_matrix[distance[i][1]][distance[turbine][1]] = 0.0
return U
def larsen_windrose(self):
self.efficiency = 0.0
self.profit = []
self.U = []
self.powers = []
self.summation = 0.0
direction = open('direction_power_larsen.dat', 'w', 1)
windrose_angle = self.wind_direction
windrose_speed = self.wind_speed
windrose_frequency = self.wind_frequency
layout_y = self.layout_y
layout_x = self.layout_x
nt = self.nt # Number of turbines
r0 = self.radius # Turbine rotor radius
D = 2.0 * r0
A = pi * r0**2.0
H = self.hub_height # Hub height
ia = 0.08 # Ambient turbulence intensity according to vanluvanee. 8% on average
def deff(U0):
return D * sqrt(
(1.0 + sqrt(1.0 - Ct(U0))) / (2.0 * sqrt(1.0 - Ct(U0))))
rnb = max(1.08 * D, 1.08 * D + 21.7 * D * (ia - 0.05))
r95 = 0.5 * (rnb + min(H, rnb))
def x0(U0):
return 9.5 * D / ((2.0 * r95 / deff(U0))**3.0 - 1.0)
def c1(U0):
return (deff(U0) / 2.0)**(5.0 / 2.0) * (105.0 / 2.0 / pi)**(
-1.0 / 2.0) * (Ct(U0) * A * x0(U0))**(
-5.0 / 6.0) # Prandtl mixing length
for wind in range(0, len(windrose_angle)):
U0 = windrose_speed[wind] # Free stream wind speed
angle = windrose_angle[wind]
angle3 = angle + 180.0
deficit_matrix = [[0.0 for _ in range(nt)] for _ in range(nt)]
distance = [[0.0 for _ in range(2)] for _ in range(nt)]
U = [U0 for _ in range(nt)]
total_deficit = [0.0 for _ in range(nt)]
for tur in range(nt):
distance[tur] = [
distance_to_front(layout_x[tur], layout_y[tur], angle), tur
]
distance.sort()
for turbine in range(nt):
for num in range(turbine):
total_deficit[distance[turbine][1]] += deficit_matrix[
distance[turbine][1]][distance[num][1]]**2.0
total_deficit[distance[turbine][1]] = sqrt(
total_deficit[distance[turbine][1]])
U[distance[turbine]
[1]] = U0 * (1.0 - total_deficit[distance[turbine][1]])
flag = [False for _ in range(nt)]
proportion = [0.0 for _ in range(nt)]
perpendicular_distance = [0.0 for _ in range(nt)]
parallel_distance = [0.0 for _ in range(nt)]
for i in range(turbine + 1, nt):
proportion[distance[i][1]], flag[distance[i][1]], perpendicular_distance[distance[i][1]], \
parallel_distance[distance[i][1]] = wake_larsen.determine_if_in_wake_larsen(
layout_x[distance[turbine][1]],
layout_y[distance[turbine][1]],
layout_x[distance[i][1]],
layout_y[distance[i][1]], A,
c1(U[distance[turbine][1]]),
Ct(U[distance[turbine][1]]), angle3,
r0, x0(U[distance[turbine][1]]))
if parallel_distance[
distance[i]
[1]] > 0.0: ## Add if proportion is 0, skip operation and deficit_matrix == 0.
deficit_matrix[distance[i][1]][
distance[turbine][1]] = proportion[
distance[i][1]] * wake_larsen.wake_deficit(
U[distance[turbine][1]],
Ct(U[distance[turbine][1]]), A,
parallel_distance[distance[i][1]] +
x0(U[distance[turbine][1]]),
perpendicular_distance[distance[i][1]],
c1(U[distance[turbine][1]]))
else:
deficit_matrix[distance[i][1]][distance[turbine]
[1]] = 0.0
# Farm efficiency
profit = 0.0
efficiency_proportion = [
0.0 for x in range(0, len(windrose_frequency))
]
for l in range(nt):
profit += power(U[l])
efficiency = profit * 100.0 / (float(nt) *
power(U[distance[0][1]]))
efficiency_proportion[
wind] = efficiency * windrose_frequency[wind] / 100.0
direction.write('{0:f} {1:f}\n'.format(angle, profit))
self.summation += efficiency_proportion[wind]
direction.close()
def larsen_angle(self, wind_speed, angle):
self.efficiency = 0.0
self.profit = []
self.U = []
self.powers = []
self.summation = 0.0
U0 = wind_speed
layout_y = self.layout_y
layout_x = self.layout_x
nt = len(layout_y) # Number of turbines
r0 = self.radius # Turbine rotor radius
D = 2.0 * r0
A = pi * r0**2.0
H = 100.0 # Hub height
ia = 0.08 # Ambient turbulence intensity according to vanluvanee. 8% on average
def deff(U0):
return D * sqrt(
(1.0 + sqrt(1.0 - Ct(U0))) / (2.0 * sqrt(1.0 - Ct(U0))))
rnb = max(1.08 * D, 1.08 * D + 21.7 * D * (ia - 0.05))
r95 = 0.5 * (rnb + min(H, rnb))
def x0(U0):
return 9.5 * D / ((2.0 * r95 / deff(U0))**3.0 - 1.0)
def c1(U0):
return (deff(U0) / 2.0)**(5.0 / 2.0) * (105.0 / 2.0 / pi)**(
-1.0 / 2.0) * (Ct(U0) * A * x0(U0))**(
-5.0 / 6.0) # Prandtl mixing length
angle3 = angle + 180.0
deficit_matrix = [[0.0 for _ in range(nt)] for _ in range(nt)]
distance = [[0.0 for _ in range(2)] for _ in range(nt)]
self.U = [U0 for _ in range(nt)]
total_deficit = [0.0 for _ in range(nt)]
for tur in range(nt):
distance[tur] = [
distance_to_front(layout_x[tur], layout_y[tur], angle), tur
]
distance.sort()
for turbine in range(nt):
for num in range(turbine):
total_deficit[distance[turbine][1]] += deficit_matrix[
distance[turbine][1]][distance[num][1]]**2.0
total_deficit[distance[turbine][1]] = sqrt(
total_deficit[distance[turbine][1]])
self.U[distance[turbine]
[1]] = U0 * (1.0 - total_deficit[distance[turbine][1]])
flag = [False for _ in range(nt)]
proportion = [0.0 for _ in range(nt)]
perpendicular_distance = [0.0 for _ in range(nt)]
parallel_distance = [0.0 for _ in range(nt)]
for i in range(turbine + 1, nt):
proportion[distance[i][1]], flag[distance[i][1]], perpendicular_distance[distance[i][1]], \
parallel_distance[distance[i][1]] = wake_larsen.determine_if_in_wake_larsen(
layout_x[distance[turbine][1]],
layout_y[distance[turbine][1]],
layout_x[distance[i][1]],
layout_y[distance[i][1]], A,
c1(self.U[distance[turbine][1]]),
Ct(self.U[distance[turbine][1]]), angle3,
r0, x0(self.U[distance[turbine][1]]))
if parallel_distance[
distance[i]
[1]] > 0.0: ## Add if proportion is 0, skip operation and deficit_matrix == 0.
if proportion[distance[i][1]] != 0.0:
deficit_matrix[distance[i][1]][
distance[turbine][1]] = proportion[
distance[i][1]] * wake_larsen.wake_deficit(
self.U[distance[turbine][1]],
Ct(self.U[distance[turbine][1]]), A,
parallel_distance[distance[i][1]] +
x0(self.U[distance[turbine][1]]),
perpendicular_distance[distance[i][1]],
c1(self.U[distance[turbine][1]]))
else:
deficit_matrix[distance[i][1]][distance[turbine]
[1]] = 0.0
else:
deficit_matrix[distance[i][1]][distance[turbine][1]] = 0.0
# Farm efficiency
self.profit = 0.0
for l in range(nt):
self.profit += power(self.U[l])
self.efficiency = self.profit * 100.0 / (
float(nt) * power(self.U[distance[0][1]])) # same as using U0
self.powers = [power(self.U[i]) for i in range(nt)]
with open('speed_larsen.dat', 'w') as out:
for i in range(len(self.U)):
out.write('{0:f}\t{1:f}\n'.format(
self.U[i],
power(self.U[i]) / power(self.U[distance[0][1]])))
def solve_nonlinear(self, params, unknowns, resids):
U0 = params['mean_ambient_wind_speed']
layout_y = params['layout_y']
layout_x = params['layout_x']
angle = params['wind_direction']
nt = num_turb
r0 = params['rotor_radius'] # Turbine rotor radius
D = 2.0 * r0
A = pi * r0 ** 2.0
ia = params['TI'] # Ambient turbulence intensity according to vanluvanee. 8% on average
H = params['hub_height']
def deff(U0):
return D * sqrt((1.0 + sqrt(1.0 - Ct(U0))) / (2.0 * sqrt(1.0 - Ct(U0))))
rnb = max(1.08 * D, 1.08 * D + 21.7 * D * (ia - 0.05))
r95 = 0.5 * (rnb + min(H, rnb))
def x0(U0):
return 9.5 * D / ((2.0 * r95 / deff(U0)) ** 3.0 - 1.0)
def c1(U0):
return (deff(U0) / 2.0) ** (5.0 / 2.0) * (105.0 / 2.0 / pi) ** (- 1.0 / 2.0) * (Ct(U0) * A * x0(U0)) ** (
- 5.0 / 6.0) # Prandtl mixing length
angle3 = angle + 180.0
deficit_matrix = [[0.0 for _ in range(nt)] for _ in range(nt)]
distance = [[0.0 for _ in range(2)] for _ in range(nt)]
U = [U0 for _ in range(nt)]
total_deficit = [0.0 for _ in range(nt)]
for tur in range(nt):
distance[tur] = [distance_to_front(layout_x[tur], layout_y[tur], angle), tur]
distance.sort()
for turbine in range(nt):
for num in range(turbine):
total_deficit[distance[turbine][1]] += deficit_matrix[distance[turbine][1]][distance[num][1]] ** 2.0
total_deficit[distance[turbine][1]] = sqrt(total_deficit[distance[turbine][1]])
U[distance[turbine][1]] = U0 * (1.0 - total_deficit[distance[turbine][1]])
flag = [False for _ in range(nt)]
proportion = [0.0 for _ in range(nt)]
perpendicular_distance = [0.0 for _ in range(nt)]
parallel_distance = [0.0 for _ in range(nt)]
for i in range(turbine + 1, nt):
proportion[distance[i][1]], flag[distance[i][1]], perpendicular_distance[distance[i][1]], \
parallel_distance[distance[i][1]] = wake_larsen.determine_if_in_wake_larsen(
layout_x[distance[turbine][1]],
layout_y[distance[turbine][1]],
layout_x[distance[i][1]],
layout_y[distance[i][1]], A,
c1(U[distance[turbine][1]]),
Ct(U[distance[turbine][1]]), angle3,
r0, x0(U[distance[turbine][1]]))
if parallel_distance[
distance[i][1]] > 0.0:
if proportion[distance[i][1]] != 0.0:
deficit_matrix[distance[i][1]][distance[turbine][1]] = proportion[
distance[i][
1]] * wake_larsen.wake_deficit(
U[distance[turbine][1]], Ct(U[distance[turbine][1]]), A,
parallel_distance[distance[i][1]] + x0(U[distance[turbine][1]]),
perpendicular_distance[distance[i][1]], c1(U[distance[turbine][1]]))
else:
deficit_matrix[distance[i][1]][distance[turbine][1]] = 0.0
else:
deficit_matrix[distance[i][1]][distance[turbine][1]] = 0.0
unknowns['U'] = array(U)