def VAWT_Power(x_v, y_v, x_h, y_h, params): """ inputs: x_v: numpy array with VAWT x locations as follows [x1, x2, ..., xn] y_v: numpy array with VAWT y locations as follows [y1, y2, ..., yn] x_h: numpy array with HAWT x locations as follows [x1, x2, ..., xm] norm_vel_func: function handle that calculates the normalized velocity at each location velf: free stream velocity dia: turbine diameter tsr: tip speed ratio solidity: returns: loss: numpy array with loss of each turbine as follows [L1, L2, ..., Ln] """ velf, r_tower, r_VAWT = params dia = 2*r_VAWT # turbine diameter (m) tsr = 4.0 # tip speed ratio B = 3. # number of blades chord = 0.25 # chord lenth (m) solidity = (chord*B)/(dia/2.) n = np.size(x_v) #number of turbines loss_VT = np.zeros(n) #total loss on each turbine tot_loss = np.zeros(n) power = np.zeros(n) cp = 0.3 rho = 1.1716 h = 2.*dia # ----------------new stuff------------------------ cfd_data = 'velo' #use this for simple wake model men = np.array( [-0.0006344223751663201, 0.01055675755786011, -0.004073212523707764] ) spr = np.array( [-0.005187125854670714, 0.06397918461247416, 0.543874357807372] ) scl = np.array( [6.667328694868336, 5.617498827673229, 21.520026361522778] ) rat = np.array( [-2.129054494312758, 45.17191461412915] ) tns = np.array( [-1.5569348878268718, 31.913143231782648] ) param = np.array([men,spr,scl,rat,tns]) #---------------------------------------------------- #loss on a turbine from all the other turbines [Lj1, Lj2, Lj3, Lj4, ..., Lji] where Ljn = loss on turbine j from turbine n ind_loss = np.zeros(n) for i in range(0, n): for j in range(0, n): if i == j: ind_loss[j] = 0 #i.e. L11 = L22 = L33 = 0... turbine loss from itself is zero else: ind_loss[j] = 1. - velocity_field(x_v[j], y_v[j], x_v[i] - x_v[j], y_v[i] - y_v[j], velf, dia, tsr, solidity, cfd_data, param) loss_VT[i] = np.linalg.norm(ind_loss,2) #calculate the sum of the squares (the 2 norm) ind_loss = np.zeros(n) loss_HT = loss_cylinder(x_h, y_h, x_v, y_v, r_tower, r_VAWT) #loss from HAWT towers for z in range(0, n): tot_loss[z] = (loss_HT[z]**2. + loss_VT[z]**2.)**0.5 if tot_loss[z] > 1.: tot_loss[z] = 1. vel = (1-tot_loss[z])*velf power[z] = 0.5*rho*cp*dia*h*vel**3 return power
elif cfd_data == 'vort2':
loc1,loc2,loc3,spr1,spr2,skw1,skw2,scl1,scl2,scl3 = vorticity2(tsr,solidity)
param = np.array([loc1,loc2,loc3,spr1,spr2,skw1,skw2,scl1,scl2,scl3])
# print param
# import time
#
# time.sleep(10)
elif cfd_data == 'velo2':
spr1,pow1,pow2,spr2,skw,scl1,scl2,scl3 = velocity2(tsr,solidity)
param = np.array([spr1,pow1,pow2,spr2,skw,scl1,scl2,scl3])
vel = velocity_field(xt,yt,xt + x0,yt + y0,velf,dia,tsr,solidity,cfd_data,param)
print '\nNormalized velocity at (',x0,',',y0,') from the turbine =',vel,'\n' # output velocity (normalized by free stream wind speed)
## Plotting
fs = 25 # 18# font size for plots
# Option to plot velocity profiles
vel_slice = True
vel_slice = False # comment this out if desired on
# Option to plot a full velocity domain
plot_dist = True
plot_dist = False # comment this out if desired on
# Plotting velocity profiles
error20 = np.zeros_like(pos20)
tot2 = np.size(pos2)
tot4 = np.size(pos4)
tot6 = np.size(pos6)
tot8 = np.size(pos8)
tot10 = np.size(pos10)
tot15 = np.size(pos15)
tot20 = np.size(pos20)
veltype_in = 'x'
rot = tsr*velf/(dia/2.)
chord = solidity*(dia/2.)/B
for i in range(np.size(pos2)):
velp = velocity_field(xt,yt,2*dia,pos2[i],velf,dia,rot,chord,B,veltype=veltype_in)
error2[i] = ((1.-velp)-(1.-velo2[i]))**2
print '2D',i+1,'of',tot2,'TSR:',tsr,'Solidity:',solidity,'Error:',error2[i],'Velp:',velp,'Velo:',velo2[i],'Pos:',pos2[i]
for i in range(np.size(pos4)):
velp = velocity_field(xt,yt,4*dia,pos4[i],velf,dia,rot,chord,B,veltype=veltype_in)
error4[i] = ((1.-velp)-(1.-velo4[i]))**2
print '4D',i+1,'of',tot4,'TSR:',tsr,'Solidity:',solidity,'Error:',error4[i],'Velp:',velp,'Velo:',velo4[i],'Pos:',pos4[i]
for i in range(np.size(pos6)):
velp = velocity_field(xt,yt,6*dia,pos6[i],velf,dia,rot,chord,B,veltype=veltype_in)
error6[i] = ((1.-velp)-(1.-velo6[i]))**2
print '6D',i+1,'of',tot6,'TSR:',tsr,'Solidity:',solidity,'Error:',error6[i],'Velp:',velp,'Velo:',velo6[i],'Pos:',pos6[i]
for i in range(np.size(pos8)):
velp = velocity_field(xt,yt,8*dia,pos8[i],velf,dia,rot,chord,B,veltype=veltype_in)
error8[i] = ((1.-velp)-(1.-velo8[i]))**2
print '8D',i+1,'of',tot8,'TSR:',tsr,'Solidity:',solidity,'Error:',error8[i],'Velp:',velp,'Velo:',velo8[i],'Pos:',pos8[i]
for i in range(np.size(pos10)):
def test_PIV(self):
x15 = np.array([
-0.867, -0.815, -0.763, -0.71, -0.658, -0.605, -0.553, -0.5,
-0.448, -0.395, -0.343, -0.291, -0.238, -0.186, -0.133, -0.081,
-0.028, 0.024, 0.077, 0.129, 0.182, 0.234, 0.286, 0.339, 0.391,
0.444, 0.496, 0.549, 0.601, 0.654, 0.706, 0.759, 0.811
])
x20 = np.array([
-0.867, -0.815, -0.763, -0.71, -0.658, -0.605, -0.553, -0.5,
-0.448, -0.395, -0.343, -0.291, -0.238, -0.186, -0.133, -0.081,
-0.028, 0.024, 0.077, 0.129, 0.182, 0.234, 0.286, 0.339, 0.391,
0.444, 0.496, 0.549, 0.601, 0.654, 0.706, 0.759, 0.811
])
x25 = np.array([
-0.867, -0.815, -0.763, -0.71, -0.658, -0.605, -0.553, -0.5,
-0.448, -0.395, -0.343, -0.291, -0.238, -0.186, -0.133, -0.081,
-0.028, 0.024, 0.077, 0.129, 0.182, 0.234, 0.286, 0.339, 0.391,
0.444, 0.496, 0.549, 0.601, 0.654, 0.706, 0.759, 0.811
])
x30 = np.array([
-0.867, -0.815, -0.763, -0.71, -0.658, -0.605, -0.553, -0.5,
-0.448, -0.395, -0.343, -0.291, -0.238, -0.186, -0.133, -0.081,
-0.028, 0.024, 0.077, 0.129, 0.182, 0.234, 0.286, 0.339, 0.391,
0.444, 0.496, 0.549, 0.601, 0.654, 0.706, 0.759, 0.811
])
x35 = np.array([
-0.867, -0.815, -0.763, -0.71, -0.658, -0.605, -0.553, -0.5,
-0.448, -0.395, -0.343, -0.291, -0.238, -0.186, -0.133, -0.081,
-0.028, 0.024, 0.077, 0.129, 0.182, 0.234, 0.286, 0.339, 0.391,
0.444, 0.496, 0.549, 0.601, 0.654, 0.706, 0.759, 0.811
])
x40 = np.array([
-0.5, -0.448, -0.395, -0.343, -0.291, -0.238, -0.186, -0.133,
-0.081, -0.028, 0.024, 0.077, 0.129, 0.182, 0.234, 0.286, 0.339,
0.391, 0.444, 0.496, 0.549, 0.601, 0.654, 0.706, 0.759, 0.811
])
y15 = np.array([
0.994109059733553, 0.9963677091332376, 1.0005562115755295,
1.0129863984422722, 1.0507201982582595, 0.9041429426683261,
0.6716433705834841, 0.5201309340176287, 0.508144821028986,
0.45366206008875143, 0.4120816289764176, 0.3841500969704306,
0.36762989356268116, 0.34878204855733175, 0.3239136841769655,
0.30087738601863206, 0.2879935890797586, 0.26790770257593155,
0.2625797365850182, 0.292431451988392, 0.32394314025359344,
0.3491215866639411, 0.3443858871235991, 0.3482695942305222,
0.3129449223429124, 0.36582747813800515, 0.4154704750687794,
0.49039503797192485, 0.6038500532436828, 0.7927363063069286,
0.9055264980137487, 0.9492042298526092, 0.9678480377419288
])
y20 = np.array([
0.9920370542708112, 0.9937027721069257, 0.9957821547724749,
1.0042398848773346, 0.9749571783229305, 0.8545201774180555,
0.565802548086458, 0.5143332054399019, 0.489198302575,
0.44408180130876845, 0.3816702901351002, 0.35005844980465,
0.33679345047454295, 0.3230305737612392, 0.3146901353633469,
0.29915244503218225, 0.2790206166599524, 0.2464443364444221,
0.2475139147846546, 0.25357920856345817, 0.27126299099141044,
0.2987673093397647, 0.3182385501649433, 0.3243813328675722,
0.30742297967502097, 0.32253464736566645, 0.3693305499571722,
0.4191276334361715, 0.5015171898966418, 0.6228502433753057,
0.8230607176338183, 0.9264600739810046, 0.9616530515736079
])
y25 = np.array([
0.9879572983671737, 0.9905509911272896, 0.9933676654604374,
0.9923430478507566, 0.9160865587232668, 0.727774179726256,
0.5833627736796199, 0.4815735966162955, 0.4258818988364446,
0.40697818686203785, 0.3645090556659908, 0.33624432950148214,
0.3254855613810157, 0.3103304514855841, 0.3045151031176352,
0.28401646740896264, 0.2593430020697244, 0.23659060256721978,
0.22300420317944888, 0.2244438460371643, 0.23642978330838485,
0.2568650503421204, 0.28114157843083193, 0.294601202395863,
0.3006303134268269, 0.3118773622351477, 0.3203024532857655,
0.3747931924965308, 0.41075281837916877, 0.5033971635645369,
0.6381178175981282, 0.8832861499445961, 0.9780827152012185
])
y30 = np.array([
0.9807919873645041, 0.9799943204500705, 0.9756659438025117,
0.9597111733105987, 0.8640379300795783, 0.6756090098761603,
0.5574514345456549, 0.48935854692854497, 0.428523583438216,
0.3833992822748339, 0.3480531699708427, 0.32487761318471114,
0.3153752965437699, 0.2971902045364618, 0.2830498661729626,
0.2701094817124857, 0.2525140339109516, 0.22990689461698513,
0.21388156547631884, 0.2009225725260476, 0.2109170460152375,
0.22197598259760387, 0.24007485599064649, 0.2629099716848817,
0.28306559237296497, 0.29465097651166405, 0.29791611270965696,
0.320843380159032, 0.365988216767817, 0.435994478045424,
0.5459295715799363, 0.7790196684279612, 0.9232640197764616
])
y35 = np.array([
0.9771079214279068, 0.9739267876288416, 0.9659755072544549,
0.9409586395095753, 0.8372410989082885, 0.6761226132078453,
0.5567979451297009, 0.46883935558555223, 0.41825105219857445,
0.3643627166731387, 0.33608496528240905, 0.31852020274820736,
0.3061917562496233, 0.28608694443477783, 0.273103042317234,
0.26439124635620204, 0.2478225127262987, 0.22900647970420313,
0.20929176925815257, 0.19435346927934738, 0.19534832002282343,
0.19777809452729966, 0.21620168910917673, 0.23300547991382745,
0.25288024387549046, 0.27049877766131897, 0.2804228982454348,
0.2916868458391746, 0.3235522394271216, 0.3723078207006349,
0.4706069281766252, 0.6090953502184843, 0.8713603615558797
])
y40 = np.array([
0.45465337175396475, 0.3980109024658175, 0.35904507111616846,
0.32774805291916986, 0.31088720860935865, 0.29832097587839296,
0.2821950936769575, 0.26788022954331897, 0.25719920421744913,
0.24586751730014048, 0.2286008521345077, 0.20763836919642048,
0.1912065524478209, 0.1952723101174681, 0.1863567864754898,
0.19527809328409215, 0.21004969265451465, 0.22887599974659367,
0.2507107104057936, 0.26844672767918015, 0.27999051414332765,
0.2936850402917538, 0.33560687204407424, 0.41822453322242903,
0.5404777347489278, 0.7985895165740945
])
# Wake model calculation using PIV data specifications
rad = 0.5
dia = 2 * rad
velf = 9.308422677
tsr = 4.5
rot = tsr * velf / rad
chord = 0.06
B = 2
rom15 = np.zeros_like(x15)
rom20 = np.zeros_like(x20)
rom25 = np.zeros_like(x25)
rom30 = np.zeros_like(x30)
rom35 = np.zeros_like(x35)
rom40 = np.zeros_like(x40)
for i in range(np.size(x15)):
rom15[i] = velocity_field(0.0, 0.0, 0.75, x15[i] * dia, velf, dia,
rot, chord, B)
rom20[i] = velocity_field(0.0, 0.0, 1.0, x20[i] * dia, velf, dia,
rot, chord, B)
rom25[i] = velocity_field(0.0, 0.0, 1.25, x25[i] * dia, velf, dia,
rot, chord, B)
rom30[i] = velocity_field(0.0, 0.0, 1.5, x30[i] * dia, velf, dia,
rot, chord, B)
rom35[i] = velocity_field(0.0, 0.0, 1.75, x35[i] * dia, velf, dia,
rot, chord, B)
for i in range(np.size(x40)):
rom40[i] = velocity_field(0.0, 0.0, 2.0, x40[i] * dia, velf, dia,
rot, chord, B)
idx1 = np.array([
4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
22, 23, 24, 25, 26, 27, 28, 29
])
idx2 = np.array([
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
19, 20, 21, 22, 23, 24, 25
])
np.testing.assert_allclose(rom15[idx1], y15[idx1], atol=0.4)
np.testing.assert_allclose(rom20[idx1], y20[idx1], atol=0.4)
np.testing.assert_allclose(rom25[idx1], y25[idx1], atol=0.4)
np.testing.assert_allclose(rom30[idx1], y30[idx1], atol=0.4)
np.testing.assert_allclose(rom35[idx1], y35[idx1], atol=0.4)
np.testing.assert_allclose(rom40[idx2], y40[idx2], atol=0.6)
# Wind tunnel test data
x15wt = np.linspace(-1.7, 1.7, 21)
y15wt = np.array([
0.98, 0.98, 0.985, 0.99, 0.995, 1.005, 0.96, 0.73, 0.5, 0.44, 0.54,
0.51, 0.66, 0.9, 1.01, 1.0, 0.99, 0.985, 0.98, 0.98, 0.97
])
# Wake model calculation using wind tunnel data specifications
rad = 0.515
dia = 2 * rad
velf = 16.0
sol = 0.5
tsr = 1.6
rot = tsr * velf / rad
B = 3
chord = sol * rad / B
rom15wt = np.zeros_like(x15wt)
for i in range(np.size(rom15wt)):
rom15wt[i] = velocity_field(0.0, 0.0, 1.5 * dia, x15wt[i] * dia,
velf, dia, rot, chord, B)
np.testing.assert_allclose(rom15wt, y15wt, atol=0.4)
n = 200 # number of divisions in the lateral direction (for Simpson's Rule)
# integration = 'gskr' # use 21 Point Gauss-Kronrod Rule Quadrature integration
########################################################################################################################
########################################################################################################################
########################################################################################################################
########################################################################################################################
# CALCULATING VELOCITY AT GIVEN POINT (x0,y0)
vel = velocity_field(xt,
yt,
x0,
y0,
Vinf,
dia,
rot,
chord,
B,
param=None,
veltype=veltype,
integration=integration,
m=m,
n=n)
print '\nNormalized velocity at (', x0, ',', y0, ') =', vel, '\n' # output velocity (normalized by free stream wind speed)
pointval1 = 1.
pointval2 = 0.
pointval3 = 0.
fs = 25 # font size for plots
# PLOTTING VELOCITY PROFILES
if vel_slice == True:
error6 = np.zeros_like(pos6)
error8 = np.zeros_like(pos8)
error10 = np.zeros_like(pos10)
error15 = np.zeros_like(pos15)
error20 = np.zeros_like(pos20)
tot2 = np.size(pos2)
tot4 = np.size(pos4)
tot6 = np.size(pos6)
tot8 = np.size(pos8)
tot10 = np.size(pos10)
tot15 = np.size(pos15)
tot20 = np.size(pos20)
for i in range(np.size(pos2)):
velp = velocity_field(xt,yt,2*dia,pos2[i],velf,dia,tsr,solidity,cfd_data,param)
error2[i] = (velp-velo2[i])/velo2[i]
print '2D',i,'of',tot2,'TSR:',tsr,'Solidity:',solidity
for i in range(np.size(pos4)):
velp = velocity_field(xt,yt,4*dia,pos4[i],velf,dia,tsr,solidity,cfd_data,param)
error4[i] = (velp-velo4[i])/velo4[i]
print '4D',i,'of',tot4,'TSR:',tsr,'Solidity:',solidity
for i in range(np.size(pos6)):
velp = velocity_field(xt,yt,6*dia,pos6[i],velf,dia,tsr,solidity,cfd_data,param)
error6[i] = (velp-velo6[i])/velo6[i]
print '6D',i,'of',tot6,'TSR:',tsr,'Solidity:',solidity
for i in range(np.size(pos8)):
velp = velocity_field(xt,yt,8*dia,pos8[i],velf,dia,tsr,solidity,cfd_data,param)
error8[i] = (velp-velo8[i])/velo8[i]
print '8D',i,'of',tot8,'TSR:',tsr,'Solidity:',solidity
for i in range(np.size(pos10)):
n = 100
x = np.linspace(0,120.,n)
y = np.linspace(-2*6.,2*6.,n)
fs = 15
fig = plt.figure(1,figsize=(10,6))
fig.subplots_adjust(bottom=0,left=0,right=1,top=1)
ax = fig.gca(projection='3d')
X, Y = np.meshgrid(x, y)
G = np.zeros((n,n))
for i in range(n):
for j in range(n):
G[i,j] = velocity_field(0.,0.,X[i,j],Y[i,j],15.,6.,tsr,solidity,'velo',param)
pnt = ax.scatter(posdn,poslt,velod,'b.',label='CFD Data')
surf = ax.plot_surface(X/6., Y/6., G, rstride=1, cstride=1, color='g', linewidth=0, antialiased=True, alpha=0.5, label='SMG Surface')#cmap=cm.parula
ax.azim = -160
ax.elev = 35
ax.set_xlabel('$x/D$',fontsize=fs)
ax.set_ylabel('$y/D$',fontsize=fs)
ax.set_zlabel(r'$u/U_\infty$',fontsize=fs)
ax.set_xlim(0,20)
ax.set_ylim(-2,2)
ax.set_zlim(0,1.2)
ax.set_xticklabels(np.array([0,5,10,15,20]),fontsize=fs)
def overlap(xt,yt,diat,tsr,solidity,x0,y0,dia,velf,hub,out):
"""
Calculating an effective velocity based on overlapping of wakes
Parameters
----------
xt : array
downstream locations of turbines producing wakes (m)
yt : array
lateral locations of turbines producing wakes (m)
diat : array
diameters of each of the turbines producing wakes (m)
tsr : array
tip-speed ratio of each turbine
solidity : array
solidities of each turbine
x0 : float
downstream location of turbine being analyzed (m)
y0 : float
lateral location of turbine being analyzed (m)
dia : float
diameter of turbine being analyzed (m)
velf : float
free stream velocity (m/s)
hub : bool
option of using the hub velocity (True) or an average of
velocities across the turbine's rotation (False)
out : bool
option of outputting the the information of turbines completed
in the overlap calculation (True)
Returns
----------
veleff : float
effective velocity in front of turbine (m/s)
"""
N = np.size(xt) # number of turbines that overlap given turbine
inte = 0. # initializing integration value
r1 = y0 - dia/2. # lower bound of integration
r2 = y0 + dia/2. # upper bound of integration
n = 3
if hub == True:
y = np.array([y0]) # using hub velocity for effective velocity
else:
y = np.linspace(r1,r2,n) # using n velocity values for effective velocity
vel = np.zeros_like(y)
for i in range(N):
for j in range(np.size(y)):
vel[j] = 1. - velocity_field(xt[i],yt[i],x0,y[j],velf,diat[i],tsr[i],solidity[i])
inte_n = np.average(vel)
inte = inte + (inte_n)**2
if out == True:
print 'Turbine '+str(i+1)+' of '+str(N)+' completed'
veleff = velf*(1. - sqrt(inte))
return veleff
def ydiff(y,x,xt,yt,Vinf,dia,rot,c,B):
return velocity_field(xt,yt,x,y,Vinf,dia,rot,c,B,param=None,veltype='vort')*rot
# print tsrn1,tsrn2
# print soln1,soln2
# print p,q
# time.sleep(10)
param = np.array([men1,sdv1,rat1,wdt1,spr1,scl1,men2,sdv2,rat2,wdt2,spr2,scl2,men3,sdv3,rat3,wdt3,spr3,scl3,men4,sdv4,rat4,wdt4,spr4,scl4,p,q])
elif cfd_data == 'velo2':
spr1,pow1,pow2,spr2,skw,scl1,scl2,scl3 = velocity2(tsr,sol)
param = np.array([spr1,pow1,pow2,spr2,skw,scl1,scl2,scl3])
# print param
# import time
#
# time.sleep(10)
for i in range(np.size(x15)):
rom15t[i] = velocity_field(0.,0.,1.5*dia,x15[i]*dia,velf,dia,tsr,sol,cfd_data,param)
error_test[i] = (rom15t[i]-y15o[i])/y15o[i]
error = np.average(fabs(error_test))
errorstd = np.std(fabs(error_test))
for i in range(np.size(rom15)):
rom15[i] = velocity_field(0.,0.,1.5*dia,x15r[i]*dia,velf,dia,tsr,sol,cfd_data,param)
print i
fs = 15
plt.figure(1)
# plt.subplot(2,3,1)
# plt.plot(x15,y15c,'r.',label='Experimental (closed)')
# plt.plot(x15,y15o,'b.',label='Experimental (open)')
if k == 0:
plt.plot(x15,y15o,'b.',label='Experimental')
N = 50
rom_y = np.linspace(-1.5, 1.5, N)
vel_a = np.zeros_like(rom_y)
vel_b = np.zeros_like(rom_y)
vel_c = np.zeros_like(rom_y)
vel_d = np.zeros_like(rom_y)
vel_e = np.zeros_like(rom_y)
for i in range(N):
vel_a[i] = velocity_field(xt,
yt,
xr_a * r,
rom_y[i] * dia,
velf,
dia,
rot,
chord,
B,
param=None,
veltype=veltype)
vel_b[i] = velocity_field(xt,
yt,
xr_b * r,
rom_y[i] * dia,
velf,
dia,
rot,
chord,
B,
param=None,
rom15 = np.zeros(33)
rom20 = np.zeros(33)
rom25 = np.zeros(33)
rom30 = np.zeros(33)
rom35 = np.zeros(33)
rom40 = np.zeros(26)
rom40f = np.zeros(33)
rom15t = np.zeros(33)
rom20t = np.zeros(33)
rom25t = np.zeros(33)
rom30t = np.zeros(33)
rom35t = np.zeros(33)
rom40t = np.zeros(26)
for i in range(33):
rom15[i] = velocity_field(xt,yt,0.75,x15[i]*dia,velf,dia,tsr,sol,cfd_data,param)
rom15t[i] = (rom15[i]-y15[i])/y15[i]
rom20[i] = velocity_field(xt,yt,1.0,x20[i]*dia,velf,dia,tsr,sol,cfd_data,param)
rom20t[i] = (rom20[i]-y20[i])/y20[i]
rom25[i] = velocity_field(xt,yt,1.25,x25[i]*dia,velf,dia,tsr,sol,cfd_data,param)
rom25t[i] = (rom25[i]-y25[i])/y25[i]
rom30[i] = velocity_field(xt,yt,1.5,x30[i]*dia,velf,dia,tsr,sol,cfd_data,param)
rom30t[i] = (rom30[i]-y30[i])/y30[i]
rom35[i] = velocity_field(xt,yt,1.75,x35[i]*dia,velf,dia,tsr,sol,cfd_data,param)
rom35t[i] = (rom35[i]-y35[i])/y35[i]
rom40f[i] = velocity_field(xt,yt,2.0,x35[i]*dia,velf,dia,tsr,sol,cfd_data,param)
print i
for i in range(26):
rom40[i] = velocity_field(xt,yt,4.0*3.,x40[i]*3.,9.308422677,6.,4.5,0.24,cfd_data,param)
rom40t[i] = (rom40[i]-y40[i])/y40[i]
print i
rom20 = np.zeros(33)
rom25 = np.zeros(33)
rom30 = np.zeros(33)
rom35 = np.zeros(33)
rom40 = np.zeros(26)
rom40f = np.zeros(33)
rom15t = np.zeros(33)
rom20t = np.zeros(33)
rom25t = np.zeros(33)
rom30t = np.zeros(33)
rom35t = np.zeros(33)
rom40t = np.zeros(26)
for i in range(33):
rom15[i] = velocity_field(xt,yt,0.75*dia,x15[i]*dia,velf,dia,rot,chord,B,param=None,veltype=veltype)
rom20[i] = velocity_field(xt,yt,1.0*dia,x20[i]*dia,velf,dia,rot,chord,B,param=None,veltype=veltype)
rom25[i] = velocity_field(xt,yt,1.25*dia,x25[i]*dia,velf,dia,rot,chord,B,param=None,veltype=veltype)
rom30[i] = velocity_field(xt,yt,1.5*dia,x30[i]*dia,velf,dia,rot,chord,B,param=None,veltype=veltype)
rom35[i] = velocity_field(xt,yt,1.75*dia,x35[i]*dia,velf,dia,rot,chord,B,param=None,veltype=veltype)
rom40f[i] = velocity_field(xt,yt,2.0*dia,x35[i]*dia,velf,dia,rot,chord,B,param=None,veltype=veltype)
print i
for i in range(26):
rom40[i] = velocity_field(xt,yt,2.0*dia,x40[i]*dia,velf,dia,rot,chord,B,param=None,veltype=veltype)
print i
for i in range(33):
if errortype == 'abs':
rom15t[i] = fabs((1. - rom15[i])-(1. - y15[i]))
elif errortype == 'rel':
if fabs(1. - y15[i]) >= epsilon:
def test_PIV(self):
x15 = np.array( [-0.867, -0.815, -0.763, -0.71, -0.658, -0.605, -0.553, -0.5, -0.448, -0.395, -0.343, -0.291, -0.238, -0.186, -0.133, -0.081, -0.028, 0.024, 0.077, 0.129, 0.182, 0.234, 0.286, 0.339, 0.391, 0.444, 0.496, 0.549, 0.601, 0.654, 0.706, 0.759, 0.811] )
x20 = np.array( [-0.867, -0.815, -0.763, -0.71, -0.658, -0.605, -0.553, -0.5, -0.448, -0.395, -0.343, -0.291, -0.238, -0.186, -0.133, -0.081, -0.028, 0.024, 0.077, 0.129, 0.182, 0.234, 0.286, 0.339, 0.391, 0.444, 0.496, 0.549, 0.601, 0.654, 0.706, 0.759, 0.811] )
x25 = np.array( [-0.867, -0.815, -0.763, -0.71, -0.658, -0.605, -0.553, -0.5, -0.448, -0.395, -0.343, -0.291, -0.238, -0.186, -0.133, -0.081, -0.028, 0.024, 0.077, 0.129, 0.182, 0.234, 0.286, 0.339, 0.391, 0.444, 0.496, 0.549, 0.601, 0.654, 0.706, 0.759, 0.811] )
x30 = np.array( [-0.867, -0.815, -0.763, -0.71, -0.658, -0.605, -0.553, -0.5, -0.448, -0.395, -0.343, -0.291, -0.238, -0.186, -0.133, -0.081, -0.028, 0.024, 0.077, 0.129, 0.182, 0.234, 0.286, 0.339, 0.391, 0.444, 0.496, 0.549, 0.601, 0.654, 0.706, 0.759, 0.811] )
x35 = np.array( [-0.867, -0.815, -0.763, -0.71, -0.658, -0.605, -0.553, -0.5, -0.448, -0.395, -0.343, -0.291, -0.238, -0.186, -0.133, -0.081, -0.028, 0.024, 0.077, 0.129, 0.182, 0.234, 0.286, 0.339, 0.391, 0.444, 0.496, 0.549, 0.601, 0.654, 0.706, 0.759, 0.811] )
x40 = np.array( [-0.5, -0.448, -0.395, -0.343, -0.291, -0.238, -0.186, -0.133, -0.081, -0.028, 0.024, 0.077, 0.129, 0.182, 0.234, 0.286, 0.339, 0.391, 0.444, 0.496, 0.549, 0.601, 0.654, 0.706, 0.759, 0.811] )
y15 = np.array( [0.994109059733553, 0.9963677091332376, 1.0005562115755295, 1.0129863984422722, 1.0507201982582595, 0.9041429426683261, 0.6716433705834841, 0.5201309340176287, 0.508144821028986, 0.45366206008875143, 0.4120816289764176, 0.3841500969704306, 0.36762989356268116, 0.34878204855733175, 0.3239136841769655, 0.30087738601863206, 0.2879935890797586, 0.26790770257593155, 0.2625797365850182, 0.292431451988392, 0.32394314025359344, 0.3491215866639411, 0.3443858871235991, 0.3482695942305222, 0.3129449223429124, 0.36582747813800515, 0.4154704750687794, 0.49039503797192485, 0.6038500532436828, 0.7927363063069286, 0.9055264980137487, 0.9492042298526092, 0.9678480377419288] )
y20 = np.array( [0.9920370542708112, 0.9937027721069257, 0.9957821547724749, 1.0042398848773346, 0.9749571783229305, 0.8545201774180555, 0.565802548086458, 0.5143332054399019, 0.489198302575, 0.44408180130876845, 0.3816702901351002, 0.35005844980465, 0.33679345047454295, 0.3230305737612392, 0.3146901353633469, 0.29915244503218225, 0.2790206166599524, 0.2464443364444221, 0.2475139147846546, 0.25357920856345817, 0.27126299099141044, 0.2987673093397647, 0.3182385501649433, 0.3243813328675722, 0.30742297967502097, 0.32253464736566645, 0.3693305499571722, 0.4191276334361715, 0.5015171898966418, 0.6228502433753057, 0.8230607176338183, 0.9264600739810046, 0.9616530515736079] )
y25 = np.array( [0.9879572983671737, 0.9905509911272896, 0.9933676654604374, 0.9923430478507566, 0.9160865587232668, 0.727774179726256, 0.5833627736796199, 0.4815735966162955, 0.4258818988364446, 0.40697818686203785, 0.3645090556659908, 0.33624432950148214, 0.3254855613810157, 0.3103304514855841, 0.3045151031176352, 0.28401646740896264, 0.2593430020697244, 0.23659060256721978, 0.22300420317944888, 0.2244438460371643, 0.23642978330838485, 0.2568650503421204, 0.28114157843083193, 0.294601202395863, 0.3006303134268269, 0.3118773622351477, 0.3203024532857655, 0.3747931924965308, 0.41075281837916877, 0.5033971635645369, 0.6381178175981282, 0.8832861499445961, 0.9780827152012185] )
y30 = np.array( [0.9807919873645041, 0.9799943204500705, 0.9756659438025117, 0.9597111733105987, 0.8640379300795783, 0.6756090098761603, 0.5574514345456549, 0.48935854692854497, 0.428523583438216, 0.3833992822748339, 0.3480531699708427, 0.32487761318471114, 0.3153752965437699, 0.2971902045364618, 0.2830498661729626, 0.2701094817124857, 0.2525140339109516, 0.22990689461698513, 0.21388156547631884, 0.2009225725260476, 0.2109170460152375, 0.22197598259760387, 0.24007485599064649, 0.2629099716848817, 0.28306559237296497, 0.29465097651166405, 0.29791611270965696, 0.320843380159032, 0.365988216767817, 0.435994478045424, 0.5459295715799363, 0.7790196684279612, 0.9232640197764616] )
y35 = np.array( [0.9771079214279068, 0.9739267876288416, 0.9659755072544549, 0.9409586395095753, 0.8372410989082885, 0.6761226132078453, 0.5567979451297009, 0.46883935558555223, 0.41825105219857445, 0.3643627166731387, 0.33608496528240905, 0.31852020274820736, 0.3061917562496233, 0.28608694443477783, 0.273103042317234, 0.26439124635620204, 0.2478225127262987, 0.22900647970420313, 0.20929176925815257, 0.19435346927934738, 0.19534832002282343, 0.19777809452729966, 0.21620168910917673, 0.23300547991382745, 0.25288024387549046, 0.27049877766131897, 0.2804228982454348, 0.2916868458391746, 0.3235522394271216, 0.3723078207006349, 0.4706069281766252, 0.6090953502184843, 0.8713603615558797] )
y40 = np.array( [0.45465337175396475, 0.3980109024658175, 0.35904507111616846, 0.32774805291916986, 0.31088720860935865, 0.29832097587839296, 0.2821950936769575, 0.26788022954331897, 0.25719920421744913, 0.24586751730014048, 0.2286008521345077, 0.20763836919642048, 0.1912065524478209, 0.1952723101174681, 0.1863567864754898, 0.19527809328409215, 0.21004969265451465, 0.22887599974659367, 0.2507107104057936, 0.26844672767918015, 0.27999051414332765, 0.2936850402917538, 0.33560687204407424, 0.41822453322242903, 0.5404777347489278, 0.7985895165740945] )
# Wake model calculation using PIV data specifications
rad = 0.5
dia = 2*rad
velf = 9.308422677
sol = 0.24
tsr = 4.5
rom15 = np.zeros_like(x15)
rom20 = np.zeros_like(x20)
rom25 = np.zeros_like(x25)
rom30 = np.zeros_like(x30)
rom35 = np.zeros_like(x35)
rom40 = np.zeros_like(x40)
for i in range(np.size(x15)):
rom15[i] = velocity_field(0.0,0.0,0.75,x15[i]*dia,velf,dia,tsr,sol)
rom20[i] = velocity_field(0.0,0.0,1.0,x20[i]*dia,velf,dia,tsr,sol)
rom25[i] = velocity_field(0.0,0.0,1.25,x25[i]*dia,velf,dia,tsr,sol)
rom30[i] = velocity_field(0.0,0.0,1.5,x30[i]*dia,velf,dia,tsr,sol)
rom35[i] = velocity_field(0.0,0.0,1.75,x35[i]*dia,velf,dia,tsr,sol)
for i in range(np.size(x40)):
rom40[i] = velocity_field(0.0,0.0,2.0,x40[i]*dia,velf,dia,tsr,sol)
idx1 = np.array([4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29])
idx2 = np.array([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25])
np.testing.assert_allclose(rom15[idx1],y15[idx1],atol=0.4)
np.testing.assert_allclose(rom20[idx1],y20[idx1],atol=0.4)
np.testing.assert_allclose(rom25[idx1],y25[idx1],atol=0.4)
np.testing.assert_allclose(rom30[idx1],y30[idx1],atol=0.4)
np.testing.assert_allclose(rom35[idx1],y35[idx1],atol=0.4)
np.testing.assert_allclose(rom40[idx2],y40[idx2],atol=0.6)
# Wind tunnel test data
x15wt = np.linspace(-1.7,1.7,21)
y15wt = np.array([0.98,0.98,0.985,0.99,0.995,1.005,0.96,0.73,0.5,0.44,0.54,0.51,0.66,0.9,1.01,1.0,0.99,0.985,0.98,0.98,0.97])
# Wake model calculation using wind tunnel data specifications
rad = 0.515
dia = 2*rad
velf = 16.0
sol = 0.5
tsr = 1.6
rom15wt = np.zeros_like(x15wt)
for i in range(np.size(rom15wt)):
rom15wt[i] = velocity_field(0.0,0.0,1.5*dia,x15wt[i]*dia,velf,dia,tsr,sol)
np.testing.assert_allclose(rom15wt,y15wt,atol=0.4)