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