def execute(self):
# aero/hydro loads
wind = self.windLoads
wave = self.waveLoads
hubHt = self.z[-1] # top of tower
betaMain = np.interp(
hubHt, self.z,
wind.beta) # wind coordinate system defined relative to hub height
windLoads = DirectionVector(
wind.Px, wind.Py,
wind.Pz).inertialToWind(betaMain).windToYaw(self.yaw)
waveLoads = DirectionVector(
wave.Px, wave.Py,
wave.Pz).inertialToWind(betaMain).windToYaw(self.yaw)
self.outloads.Px = np.interp(self.z, wind.z, windLoads.x) + np.interp(
self.z, wave.z, waveLoads.x)
self.outloads.Py = np.interp(self.z, wind.z, windLoads.y) + np.interp(
self.z, wave.z, waveLoads.y)
self.outloads.Pz = np.interp(self.z, wind.z, windLoads.z) + np.interp(
self.z, wave.z, waveLoads.z)
self.outloads.qdyn = np.interp(self.z, wind.z, wind.qdyn) + np.interp(
self.z, wave.z, wave.qdyn)
self.outloads.z = self.z
#The following are redundant, at one point we will consolidate them to something that works for both tower (not using vartrees) and jacket (still using vartrees)
self.Px = self.outloads.Px
self.Py = self.outloads.Py
self.Pz = self.outloads.Pz
self.qdyn = self.outloads.qdyn
def linearize(self, params, unknowns, resids):
dF = DirectionVector.fromArray(params['F']).hubToYaw(params['tilt'])
dFx, dFy, dFz = dF.dx, dF.dy, dF.dz
dtopF_dFx = np.array([dFx['dx'], dFy['dx'], dFz['dx']])
dtopF_dFy = np.array([dFx['dy'], dFy['dy'], dFz['dy']])
dtopF_dFz = np.array([dFx['dz'], dFy['dz'], dFz['dz']])
dtopF_dF = hstack([dtopF_dFx, dtopF_dFy, dtopF_dFz])
dtopF_w_dm = np.array([0.0, 0.0, -self.g])
#dtopF = hstack([dtopF_dF, np.zeros((3, 6)), dtopF_w_dm, np.zeros((3, 3))])
dM = DirectionVector.fromArray(params['M']).hubToYaw(params['tilt'])
dMx, dMy, dMz = dM.dx, dM.dy, dM.dz
dMxcross, dMycross, dMzcross = self.save_rhub.cross_deriv(self.saveF, 'dr', 'dF')
dtopM_dMx = np.array([dMx['dx'], dMy['dx'], dMz['dx']])
dtopM_dMy = np.array([dMx['dy'], dMy['dy'], dMz['dy']])
dtopM_dMz = np.array([dMx['dz'], dMy['dz'], dMz['dz']])
dtopM_dM = hstack([dtopM_dMx, dtopM_dMy, dtopM_dMz])
dM_dF = np.array([dMxcross['dF'], dMycross['dF'], dMzcross['dF']])
dtopM_dFx = np.dot(dM_dF, dtopF_dFx)
dtopM_dFy = np.dot(dM_dF, dtopF_dFy)
dtopM_dFz = np.dot(dM_dF, dtopF_dFz)
dtopM_dF = hstack([dtopM_dFx, dtopM_dFy, dtopM_dFz])
dtopM_dr = np.array([dMxcross['dr'], dMycross['dr'], dMzcross['dr']])
dMx_w_cross, dMy_w_cross, dMz_w_cross = self.save_rcm.cross_deriv(self.saveF_w, 'dr', 'dF')
if params['rna_weightM']:
dtopM_drnacm = np.array([dMx_w_cross['dr'], dMy_w_cross['dr'], dMz_w_cross['dr']])
dtopM_dF_w = np.array([dMx_w_cross['dF'], dMy_w_cross['dF'], dMz_w_cross['dF']])
else:
dtopM_drnacm = np.zeros((3, 3))
dtopM_dF_w = np.zeros((3, 3))
dtopM_dm = np.dot(dtopM_dF_w, dtopF_w_dm)
if params['downwind']:
dtopM_dr[:, 0] *= -1
dtopM_drnacm[:, 0] *= -1
#dtopM = hstack([dtopM_dF, dtopM_dM, dtopM_dr, dtopM_dm, dtopM_drnacm])
J = {}
J['top_F', 'F'] = dtopF_dF
J['top_F', 'M'] = np.zeros((3, 3))
J['top_F', 'r_hub'] = np.zeros((3, 3))
J['top_F', 'rna_mass'] = dtopF_w_dm
J['top_F', 'rna_cm'] = np.zeros((3, 3))
J['top_M', 'F'] = dtopM_dF
J['top_M', 'M'] = dtopM_dM
J['top_M', 'r_hub'] = dtopM_dr
J['top_M', 'rna_mass'] = dtopM_dm
J['top_M', 'rna_cm'] = dtopM_drnacm
return J
def provideJ(self):
dF = DirectionVector.fromArray(self.F).hubToYaw(self.tilt)
dFx, dFy, dFz = dF.dx, dF.dy, dF.dz
dtopF_dFx = np.array([dFx['dx'], dFy['dx'], dFz['dx']])
dtopF_dFy = np.array([dFx['dy'], dFy['dy'], dFz['dy']])
dtopF_dFz = np.array([dFx['dz'], dFy['dz'], dFz['dz']])
dtopF_dF = hstack([dtopF_dFx, dtopF_dFy, dtopF_dFz])
dtopF_w_dm = np.array([0.0, 0.0, -self.g])
dtopF = hstack(
[dtopF_dF,
np.zeros((3, 6)), dtopF_w_dm,
np.zeros((3, 3))])
dM = DirectionVector.fromArray(self.M).hubToYaw(self.tilt)
dMx, dMy, dMz = dM.dx, dM.dy, dM.dz
dMxcross, dMycross, dMzcross = self.save_rhub.cross_deriv(
self.saveF, 'dr', 'dF')
dtopM_dMx = np.array([dMx['dx'], dMy['dx'], dMz['dx']])
dtopM_dMy = np.array([dMx['dy'], dMy['dy'], dMz['dy']])
dtopM_dMz = np.array([dMx['dz'], dMy['dz'], dMz['dz']])
dtopM_dM = hstack([dtopM_dMx, dtopM_dMy, dtopM_dMz])
dM_dF = np.array([dMxcross['dF'], dMycross['dF'], dMzcross['dF']])
dtopM_dFx = np.dot(dM_dF, dtopF_dFx)
dtopM_dFy = np.dot(dM_dF, dtopF_dFy)
dtopM_dFz = np.dot(dM_dF, dtopF_dFz)
dtopM_dF = hstack([dtopM_dFx, dtopM_dFy, dtopM_dFz])
dtopM_dr = np.array([dMxcross['dr'], dMycross['dr'], dMzcross['dr']])
dMx_w_cross, dMy_w_cross, dMz_w_cross = self.save_rcm.cross_deriv(
self.saveF_w, 'dr', 'dF')
if self.rna_weightM:
dtopM_drnacm = np.array(
[dMx_w_cross['dr'], dMy_w_cross['dr'], dMz_w_cross['dr']])
dtopM_dF_w = np.array(
[dMx_w_cross['dF'], dMy_w_cross['dF'], dMz_w_cross['dF']])
else:
dtopM_drnacm = np.zeros((3, 3))
dtopM_dF_w = np.zeros((3, 3))
dtopM_dm = np.dot(dtopM_dF_w, dtopF_w_dm)
if self.downwind:
dtopM_dr[:, 0] *= -1
dtopM_drnacm[:, 0] *= -1
dtopM = hstack([dtopM_dF, dtopM_dM, dtopM_dr, dtopM_dm, dtopM_drnacm])
J = vstack([dtopF, dtopM])
return J
def provideJ(self):
dF = DirectionVector.fromArray(self.F).hubToYaw(self.tilt)
dFx, dFy, dFz = dF.dx, dF.dy, dF.dz
dtopF_dFx = np.array([dFx['dx'], dFy['dx'], dFz['dx']])
dtopF_dFy = np.array([dFx['dy'], dFy['dy'], dFz['dy']])
dtopF_dFz = np.array([dFx['dz'], dFy['dz'], dFz['dz']])
dtopF_dF = hstack([dtopF_dFx, dtopF_dFy, dtopF_dFz])
dtopF_w_dm = np.array([0.0, 0.0, -self.g])
dtopF = hstack([dtopF_dF, np.zeros((3, 6)), dtopF_w_dm, np.zeros((3, 3))])
dM = DirectionVector.fromArray(self.M).hubToYaw(self.tilt)
dMx, dMy, dMz = dM.dx, dM.dy, dM.dz
dMxcross, dMycross, dMzcross = self.save_rhub.cross_deriv(self.saveF, 'dr', 'dF')
dtopM_dMx = np.array([dMx['dx'], dMy['dx'], dMz['dx']])
dtopM_dMy = np.array([dMx['dy'], dMy['dy'], dMz['dy']])
dtopM_dMz = np.array([dMx['dz'], dMy['dz'], dMz['dz']])
dtopM_dM = hstack([dtopM_dMx, dtopM_dMy, dtopM_dMz])
dM_dF = np.array([dMxcross['dF'], dMycross['dF'], dMzcross['dF']])
dtopM_dFx = np.dot(dM_dF, dtopF_dFx)
dtopM_dFy = np.dot(dM_dF, dtopF_dFy)
dtopM_dFz = np.dot(dM_dF, dtopF_dFz)
dtopM_dF = hstack([dtopM_dFx, dtopM_dFy, dtopM_dFz])
dtopM_dr = np.array([dMxcross['dr'], dMycross['dr'], dMzcross['dr']])
dMx_w_cross, dMy_w_cross, dMz_w_cross = self.save_rcm.cross_deriv(self.saveF_w, 'dr', 'dF')
if self.rna_weightM:
dtopM_drnacm = np.array([dMx_w_cross['dr'], dMy_w_cross['dr'], dMz_w_cross['dr']])
dtopM_dF_w = np.array([dMx_w_cross['dF'], dMy_w_cross['dF'], dMz_w_cross['dF']])
else:
dtopM_drnacm = np.zeros((3, 3))
dtopM_dF_w = np.zeros((3, 3))
dtopM_dm = np.dot(dtopM_dF_w, dtopF_w_dm)
if self.downwind:
dtopM_dr[:, 0] *= -1
dtopM_drnacm[:, 0] *= -1
dtopM = hstack([dtopM_dF, dtopM_dM, dtopM_dr, dtopM_dm, dtopM_drnacm])
J = vstack([dtopF, dtopM])
return J
def execute(self):
# coordinates of blade tip in yaw c.s.
blade_yaw = DirectionVector(self.precurveTip, self.presweepTip, self.Rtip)\
.bladeToAzimuth(self.precone).azimuthToHub(180.0).hubToYaw(self.tilt)
# find corresponding radius of tower
ztower = (self.towerHt + self.hub_tt[2] +
blade_yaw.z) / self.towerHt # nondimensional location
# rtower = np.interp(ztower, self.tower_z, self.tower_d) / 2.0
dtower, ddtower_dztower, ddtower_dtowerz, ddtower_dtowerd = interp_with_deriv(
ztower, self.tower_z, self.Twrouts.TwrObj.D)
rtower = dtower / 2.0
self.drtower_dztower = ddtower_dztower / 2.0
self.drtower_dtowerz = ddtower_dtowerz / 2.0
self.drtower_dtowerd = ddtower_dtowerd / 2.0
# max deflection before strike
if self.precone >= 0: # upwind
self.max_tip_deflection = -self.hub_tt[0] - blade_yaw.x - rtower
else:
self.max_tip_deflection = -self.hub_tt[0] + blade_yaw.x - rtower
# TODO: need to redo gradients for this case.
# ground clearance
self.ground_clearance = self.towerHt + self.hub_tt[2] + blade_yaw.z
# save for derivs
self.blade_yaw = blade_yaw
def execute(self):
F = self.F
M = self.M
F = DirectionVector.fromArray(F).hubToYaw(self.tilt)
M = DirectionVector.fromArray(M).hubToYaw(self.tilt)
# change x-direction if downwind
r_hub = np.copy(self.r_hub)
rna_cm = np.copy(self.rna_cm)
if self.downwind:
r_hub[0] *= -1
rna_cm[0] *= -1
r_hub = DirectionVector.fromArray(r_hub)
rna_cm = DirectionVector.fromArray(rna_cm)
self.save_rhub = r_hub
self.save_rcm = rna_cm
# aerodynamic moments
M = M + r_hub.cross(F)
self.saveF = F
# add weight loads
F_w = DirectionVector(0.0, 0.0, -self.m_RNA*self.g)
M_w = rna_cm.cross(F_w)
self.saveF_w = F_w
Fout = F + F_w
if self.rna_weightM:
Mout = M + M_w
else:
Mout = M
#REMOVE WEIGHT EFFECT TO ACCOUNT FOR P-Delta Effect
print "!!!! No weight effect on rotor moments -TowerSE !!!!"
# put back in array
self.top_F = np.array([Fout.x, Fout.y, Fout.z])
self.top_M = np.array([Mout.x, Mout.y, Mout.z])
def solve_nonlinear(self, params, unknowns, resids):
F = params['F']
M = params['M']
F = DirectionVector.fromArray(F).hubToYaw(params['tilt'])
M = DirectionVector.fromArray(M).hubToYaw(params['tilt'])
# change x-direction if downwind
r_hub = np.copy(params['r_hub'])
rna_cm = np.copy(params['rna_cm'])
if params['downwind']:
r_hub[0] *= -1
rna_cm[0] *= -1
r_hub = DirectionVector.fromArray(r_hub)
rna_cm = DirectionVector.fromArray(rna_cm)
self.save_rhub = r_hub
self.save_rcm = rna_cm
# aerodynamic moments
M = M + r_hub.cross(F)
self.saveF = F
# add weight loads
F_w = DirectionVector(0.0, 0.0, -params['rna_mass']*gravity)
M_w = rna_cm.cross(F_w)
self.saveF_w = F_w
Fout = F + F_w
if params['rna_weightM']:
Mout = M + M_w
else:
Mout = M
#REMOVE WEIGHT EFFECT TO ACCOUNT FOR P-Delta Effect
print("!!!! No weight effect on rotor moments -TowerSE !!!!")
# put back in array
unknowns['top_F'] = np.array([Fout.x, Fout.y, Fout.z])
unknowns['top_M'] = np.array([Mout.x, Mout.y, Mout.z])
def solve_nonlinear(self, params, unknowns, resids):
# aero/hydro loads
# wind = params['windLoads']
# wave = params['waveLoads']
# outloads = params['outloads']
z = params['z']
hubHt = z[-1] # top of cylinder
windLoads = DirectionVector(params['windLoads_Px'], params['windLoads_Py'], params['windLoads_Pz']).inertialToWind(params['windLoads_beta']).windToYaw(params['yaw'])
waveLoads = DirectionVector(params['waveLoads_Px'], params['waveLoads_Py'], params['waveLoads_Pz']).inertialToWind(params['waveLoads_beta']).windToYaw(params['yaw'])
Px = np.interp(z, params['windLoads_z'], windLoads.x) + np.interp(z, params['waveLoads_z'], waveLoads.x)
Py = np.interp(z, params['windLoads_z'], windLoads.y) + np.interp(z, params['waveLoads_z'], waveLoads.y)
Pz = np.interp(z, params['windLoads_z'], windLoads.z) + np.interp(z, params['waveLoads_z'], waveLoads.z)
qdyn = np.interp(z, params['windLoads_z'], params['windLoads_qdyn']) + np.interp(z, params['waveLoads_z'], params['waveLoads_qdyn'])
# outloads.z = z
#The following are redundant, at one point we will consolidate them to something that works for both cylinder (not using vartrees) and jacket (still using vartrees)
unknowns['Px'] = Px
unknowns['Py'] = Py
unknowns['Pz'] = Pz
unknowns['qdyn'] = qdyn
def solve_nonlinear(self, params, unknowns, resids):
F = params['F']
M = params['M']
F = DirectionVector.fromArray(F).hubToYaw(params['tilt'])
M = DirectionVector.fromArray(M).hubToYaw(params['tilt'])
# change x-direction if downwind
r_hub = np.copy(params['r_hub'])
rna_cm = np.copy(params['rna_cm'])
if params['downwind']:
r_hub[0] *= -1
rna_cm[0] *= -1
r_hub = DirectionVector.fromArray(r_hub)
rna_cm = DirectionVector.fromArray(rna_cm)
self.save_rhub = r_hub
self.save_rcm = rna_cm
# aerodynamic moments
M = M + r_hub.cross(F)
self.saveF = F
# add weight loads
F_w = DirectionVector(0.0, 0.0, -params['rna_mass'] * gravity)
M_w = rna_cm.cross(F_w)
self.saveF_w = F_w
Fout = F + F_w
if params['rna_weightM']:
Mout = M + M_w
else:
Mout = M
#REMOVE WEIGHT EFFECT TO ACCOUNT FOR P-Delta Effect
print("!!!! No weight effect on rotor moments -TowerSE !!!!")
# put back in array
unknowns['top_F'] = np.array([Fout.x, Fout.y, Fout.z])
unknowns['top_M'] = np.array([Mout.x, Mout.y, Mout.z])
def execute(self):
F = self.F
M = self.M
F = DirectionVector.fromArray(F).hubToYaw(self.tilt)
M = DirectionVector.fromArray(M).hubToYaw(self.tilt)
# change x-direction if downwind
r_hub = np.copy(self.r_hub)
rna_cm = np.copy(self.rna_cm)
if self.downwind:
r_hub[0] *= -1
rna_cm[0] *= -1
r_hub = DirectionVector.fromArray(r_hub)
rna_cm = DirectionVector.fromArray(rna_cm)
self.save_rhub = r_hub
self.save_rcm = rna_cm
# aerodynamic moments
M = M + r_hub.cross(F)
self.saveF = F
# add weight loads
F_w = DirectionVector(0.0, 0.0, -self.m_RNA * self.g)
M_w = rna_cm.cross(F_w)
self.saveF_w = F_w
Fout = F + F_w
if self.rna_weightM:
Mout = M + M_w
else:
Mout = M
#REMOVE WEIGHT EFFECT TO ACCOUNT FOR P-Delta Effect
print "!!!! No weight effect on rotor moments -TowerSE !!!!"
# put back in array
self.top_F = np.array([Fout.x, Fout.y, Fout.z])
self.top_M = np.array([Mout.x, Mout.y, Mout.z])
def linearize(self, params, unknowns, resids):
dF = DirectionVector.fromArray(params['F']).hubToYaw(params['tilt'])
dFx, dFy, dFz = dF.dx, dF.dy, dF.dz
dtopF_dFx = np.array([dFx['dx'], dFy['dx'], dFz['dx']])
dtopF_dFy = np.array([dFx['dy'], dFy['dy'], dFz['dy']])
dtopF_dFz = np.array([dFx['dz'], dFy['dz'], dFz['dz']])
dtopF_dF = hstack([dtopF_dFx, dtopF_dFy, dtopF_dFz])
dtopF_w_dm = np.array([0.0, 0.0, -self.g])
#dtopF = hstack([dtopF_dF, np.zeros((3, 6)), dtopF_w_dm, np.zeros((3, 3))])
dM = DirectionVector.fromArray(params['M']).hubToYaw(params['tilt'])
dMx, dMy, dMz = dM.dx, dM.dy, dM.dz
dMxcross, dMycross, dMzcross = self.save_rhub.cross_deriv(
self.saveF, 'dr', 'dF')
dtopM_dMx = np.array([dMx['dx'], dMy['dx'], dMz['dx']])
dtopM_dMy = np.array([dMx['dy'], dMy['dy'], dMz['dy']])
dtopM_dMz = np.array([dMx['dz'], dMy['dz'], dMz['dz']])
dtopM_dM = hstack([dtopM_dMx, dtopM_dMy, dtopM_dMz])
dM_dF = np.array([dMxcross['dF'], dMycross['dF'], dMzcross['dF']])
dtopM_dFx = np.dot(dM_dF, dtopF_dFx)
dtopM_dFy = np.dot(dM_dF, dtopF_dFy)
dtopM_dFz = np.dot(dM_dF, dtopF_dFz)
dtopM_dF = hstack([dtopM_dFx, dtopM_dFy, dtopM_dFz])
dtopM_dr = np.array([dMxcross['dr'], dMycross['dr'], dMzcross['dr']])
dMx_w_cross, dMy_w_cross, dMz_w_cross = self.save_rcm.cross_deriv(
self.saveF_w, 'dr', 'dF')
if params['rna_weightM']:
dtopM_drnacm = np.array(
[dMx_w_cross['dr'], dMy_w_cross['dr'], dMz_w_cross['dr']])
dtopM_dF_w = np.array(
[dMx_w_cross['dF'], dMy_w_cross['dF'], dMz_w_cross['dF']])
else:
dtopM_drnacm = np.zeros((3, 3))
dtopM_dF_w = np.zeros((3, 3))
dtopM_dm = np.dot(dtopM_dF_w, dtopF_w_dm)
if params['downwind']:
dtopM_dr[:, 0] *= -1
dtopM_drnacm[:, 0] *= -1
#dtopM = hstack([dtopM_dF, dtopM_dM, dtopM_dr, dtopM_dm, dtopM_drnacm])
J = {}
J['top_F', 'F'] = dtopF_dF
J['top_F', 'M'] = np.zeros((3, 3))
J['top_F', 'r_hub'] = np.zeros((3, 3))
J['top_F', 'rna_mass'] = dtopF_w_dm
J['top_F', 'rna_cm'] = np.zeros((3, 3))
J['top_M', 'F'] = dtopM_dF
J['top_M', 'M'] = dtopM_dM
J['top_M', 'r_hub'] = dtopM_dr
J['top_M', 'rna_mass'] = dtopM_dm
J['top_M', 'rna_cm'] = dtopM_drnacm
return J
