def __init__(self, length, radius, mass, spin):
self.length = length
self.radius = radius
self.mass = mass
self.spin = spin
x = np.linspace(0, length)
modes = linearisation.ModalRepresentation(
x =x,
shapes =np.zeros((len(x),3,0)),
rotations =np.zeros((len(x),3,0)),
density =np.ones_like(x) * mass/length,
mass_axis =np.zeros((len(x),2)),
section_inertia=np.ones_like(x) * radius**2 / 4,
freqs =np.zeros((0,)),
)
self.bearing = Hinge('bearing', [0,0,1])
self.pivot = Hinge('pivot', [0,1,0])
self.axis = Hinge('axis', [1,0,0])
self.body = ModalElement('body', modes)
self.bearing.add_leaf(self.pivot)
self.pivot.add_leaf(self.axis)
self.axis.add_leaf(self.body)
self.system = System(self.bearing)
# Prescribed DOF accelerations
self.system.prescribe(self.axis, acc=0.0) # constant rotational speed
def __init__(self, length, radius, mass, endmass):
self.length = length
self.radius = radius
self.mass = mass
self.endmass = endmass
Jx = mass * radius**2 / 2
Jyz = mass * (3 * radius**2 + length**2) / 12
self.A = Jyz + endmass * (length / 2)**2
self.C = Jx
self.pivot = Hinge('pivot', [0, 1, 0])
self.offset = RigidConnection('offset', [0, 0, -length / 2])
self.axis = Hinge('axis', [0, 0, 1], rotmat_y(-np.pi / 2))
self.body = UniformBeam('body',
length,
mass / length,
1,
1,
1,
Jx=Jx / 2) # /2 because added to both ends
self.endoffset = RigidConnection('endoffset', [0, 0, length / 2])
self.endbody = RigidBody('end', endmass)
self.pivot.add_leaf(self.offset)
self.offset.add_leaf(self.axis)
self.axis.add_leaf(self.body)
self.pivot.add_leaf(self.endoffset)
self.endoffset.add_leaf(self.endbody)
self.system = System(self.pivot)
# Prescribed DOF accelerations
self.system.prescribe(self.axis, acc=0.0) # constant rotational speed
self.system.prescribe(self.body, acc=0.0) # rigid beam
def __init__(self, length, radius, mass, endmass):
self.length = length
self.radius = radius
self.mass = mass
self.endmass = endmass
Jz = radius**2 / 2
Jxy = (3*radius**2 + length**2) / 12
inertia = mass * np.diag([Jxy, Jxy, Jz])
self.A = mass*Jxy + endmass*(length/2)**2
self.C = mass*Jz
self.pivot = Hinge('pivot', [0,1,0])
self.axis = Hinge('axis', [0,0,1])
self.body = RigidBody('body', mass, inertia)
self.offset = RigidConnection('offset', [0,0,length/2])
self.endbody = RigidBody('end', endmass)
self.pivot.add_leaf(self.axis)
self.axis.add_leaf(self.body)
self.pivot.add_leaf(self.offset)
self.offset.add_leaf(self.endbody)
self.system = System(self.pivot)
# Prescribed DOF accelerations
self.system.prescribe(self.axis, acc=0.0) # constant rotational speed
def __init__(self, length, radius, mass, spin, endmass):
self.length = length
self.radius = radius
self.mass = mass
self.spin = spin
self.endmass = endmass
Jx = mass * radius**2 / 2
self.bearing = Hinge('bearing', [0,0,1])
self.pivot = Hinge('pivot', [0,1,0])
self.offset = RigidConnection('offset', [-length/2,0,0])
self.axis = Hinge('axis', [1,0,0])
self.body = UniformBeam('body', length, mass/length,
1, 1, 1, Jx=Jx/2) # /2 because added to both ends
self.endbody = RigidBody('end', endmass)
self.bearing.add_leaf(self.pivot)
self.pivot.add_leaf(self.offset)
self.offset.add_leaf(self.axis)
self.axis.add_leaf(self.body)
self.offset.add_leaf(self.endbody)
self.system = System(self.bearing)
# Prescribed DOF accelerations
self.system.prescribe(self.axis, acc=0.0) # constant rotational speed
self.system.prescribe(self.body, acc=0.0) # rigid beam
def __init__(self, length, radius, mass, endmass):
self.length = length
self.radius = radius
self.mass = mass
self.endmass = endmass
Jz = radius**2 / 2
Jxy = (3 * radius**2 + length**2) / 12
inertia = mass * np.diag([Jxy, Jxy, Jz])
self.A = mass * Jxy + endmass * (length / 2)**2
self.C = mass * Jz
self.pivot = Hinge('pivot', [0, 1, 0])
self.axis = Hinge('axis', [0, 0, 1])
self.body = RigidBody('body', mass, inertia)
self.offset = RigidConnection('offset', [0, 0, length / 2])
self.endbody = RigidBody('end', endmass)
self.pivot.add_leaf(self.axis)
self.axis.add_leaf(self.body)
self.pivot.add_leaf(self.offset)
self.offset.add_leaf(self.endbody)
self.system = System(self.pivot)
# Prescribed DOF accelerations
self.system.prescribe(self.axis, acc=0.0) # constant rotational speed
def __init__(self, length, radius, mass, endmass):
self.length = length
self.radius = radius
self.mass = mass
self.endmass = endmass
Jx = mass * radius**2 / 2
Jyz = mass*(3*radius**2 + length**2) / 12
self.A = Jyz + endmass*(length/2)**2
self.C = Jx
self.pivot = Hinge('pivot', [0,1,0])
self.offset = RigidConnection('offset', [0,0,-length/2])
self.axis = Hinge('axis', [0,0,1], rotmat_y(-np.pi/2))
self.body = UniformBeam('body', length, mass/length,
1, 1, 1, Jx=Jx/2) # /2 because added to both ends
self.endoffset = RigidConnection('endoffset', [0,0,length/2])
self.endbody = RigidBody('end', endmass)
self.pivot.add_leaf(self.offset)
self.offset.add_leaf(self.axis)
self.axis.add_leaf(self.body)
self.pivot.add_leaf(self.endoffset)
self.endoffset.add_leaf(self.endbody)
self.system = System(self.pivot)
# Prescribed DOF accelerations
self.system.prescribe(self.axis, acc=0.0) # constant rotational speed
self.system.prescribe(self.body, acc=0.0) # rigid beam
class Rotor(object):
def __init__(self, mode_source_file, root_length=0):
# Modal element using data from Bladed model
print "Loading modes from '%s'..." % mode_source_file
self.modes = ModalRepresentation.from_Bladed(mode_source_file)
self.bearing = Hinge('bearing', [0,0,1])
self.offset = RigidConnection('offset', [root_length, 0, 0])
self.blade = ModalElement('blade', self.modes)
self.bearing.add_leaf(self.offset)
self.offset.add_leaf(self.blade)
self.system = System(self.bearing)
# Prescribed DOF accelerations
self.system.prescribe(self.bearing.istrain, vel=0.0, acc=0.0) # constant spin speed
def simulate(self, qm0, spin=10.0, t1=1.5, dt=0.01):
# reset
self.system.q [:] = 0.0
self.system.qd[:] = 0.0
# initial conditions
self.system.q[self.blade.istrain] = qm0 # initial modal amplitudes
self.system.prescribe(self.bearing.istrain, vel=spin, acc=0.0) #acc=spin/t1)
# setup integrator
self.integ = Integrator(self.system, ('pos','vel'))
self.integ.add_output(dynamics.LoadOutput(self.bearing.iprox))
self.integ.add_output(dynamics.LoadOutput(self.blade.iprox))
self.integ.add_output(dynamics.LoadOutput(self.blade.iprox, local=True))
self.integ.add_output(dynamics.CustomOutput(
lambda s: self.blade.station_positions()[-1], label="Tip pos"))
self.integ.add_output(dynamics.CustomOutput(
lambda s: self.blade.quad_stress, label="Quad stress"))
# simulate
self.t,self.y = self.integ.integrate(t1, dt)
return self.t, self.y
def lin(self, qm0, spin=10.0):
# reset
self.system.q [:] = 0.0
self.system.qd[:] = 0.0
# initial conditions
self.system.q[self.blade.istrain] = qm0 # initial modal amplitudes
self.system.prescribe(self.bearing.istrain, vel=spin, acc=0.0) # constant speed
linsys = linearisation.LinearisedSystem(self.system, qm0)
return linsys
def ani(self, vs=1):
l = 40
return dynvis.anim(self.system, self.t, self.y,
(0,vs), (-l,l), (-l,l), velocities=False, only_free=True)
class ModalGyroscope(Gyroscope):
def __init__(self, length, radius, mass, spin, endmass):
self.length = length
self.radius = radius
self.mass = mass
self.spin = spin
self.endmass = endmass
x = np.linspace(-length/2, length/2)
modes = linearisation.ModalRepresentation(
x =x,
shapes =np.zeros((len(x),3,0)),
rotations =np.zeros((len(x),3,0)),
density =np.ones_like(x) * mass/length,
mass_axis =np.zeros((len(x),2)),
section_inertia=np.ones_like(x) * radius**2 / 4,
freqs =np.zeros((0,)),
)
self.bearing = Hinge('bearing', [0,0,1])
self.pivot = Hinge('pivot', [0,1,0])
self.axis = Hinge('axis', [0,0,1], rotmat_y(-np.pi/2))
self.body = ModalElement('body', modes)
self.offset = RigidConnection('offset', [0,0,length/2])
self.endbody = RigidBody('end', endmass)
self.bearing.add_leaf(self.pivot)
self.pivot.add_leaf(self.axis)
self.axis.add_leaf(self.body)
self.pivot.add_leaf(self.offset)
self.offset.add_leaf(self.endbody)
self.system = System(self.bearing)
# Prescribed DOF accelerations
self.system.prescribe(self.axis, acc=0.0) # constant rotational speed
class ModalGyroscope(Gyroscope):
def __init__(self, length, radius, mass, spin, endmass):
self.length = length
self.radius = radius
self.mass = mass
self.spin = spin
self.endmass = endmass
x = np.linspace(-length / 2, length / 2)
modes = linearisation.ModalRepresentation(
x=x,
shapes=np.zeros((len(x), 3, 0)),
rotations=np.zeros((len(x), 3, 0)),
density=np.ones_like(x) * mass / length,
mass_axis=np.zeros((len(x), 2)),
section_inertia=np.ones_like(x) * radius**2 / 4,
freqs=np.zeros((0, )),
)
self.bearing = Hinge('bearing', [0, 0, 1])
self.pivot = Hinge('pivot', [0, 1, 0])
self.axis = Hinge('axis', [0, 0, 1], rotmat_y(-np.pi / 2))
self.body = ModalElement('body', modes)
self.offset = RigidConnection('offset', [0, 0, length / 2])
self.endbody = RigidBody('end', endmass)
self.bearing.add_leaf(self.pivot)
self.pivot.add_leaf(self.axis)
self.axis.add_leaf(self.body)
self.pivot.add_leaf(self.offset)
self.offset.add_leaf(self.endbody)
self.system = System(self.bearing)
# Prescribed DOF accelerations
self.system.prescribe(self.axis, acc=0.0) # constant rotational speed
def __init__(self, mode_source_file, root_length=0):
# Modal element using data from Bladed model
print "Loading modes from '%s'..." % mode_source_file
self.modes = ModalRepresentation.from_Bladed(mode_source_file)
self.bearing = Hinge('bearing', [0, 0, 1])
self.offset = RigidConnection('offset', [root_length, 0, 0])
self.blade = ModalElement('blade', self.modes)
self.bearing.add_leaf(self.offset)
self.offset.add_leaf(self.blade)
self.system = System(self.bearing)
# Prescribed DOF accelerations
self.system.prescribe(self.bearing.istrain, vel=0.0,
acc=0.0) # constant spin speed
class Gyroscope(object):
def __init__(self, length, radius, mass, spin, endmass):
self.length = length
self.radius = radius
self.mass = mass
self.spin = spin
self.endmass = endmass
Jz = radius**2 / 2
Jxy = (3*radius**2 + length**2) / 12
inertia = mass * np.diag([Jxy, Jxy, Jz])
self.bearing = Hinge('bearing', [0,0,1])
self.pivot = Hinge('pivot', [0,1,0])
self.axis = Hinge('axis', [0,0,1])
self.body = RigidBody('body', mass, inertia)
self.offset = RigidConnection('offset', [0,0,length/2])
self.endbody = RigidBody('end', endmass)
self.bearing.add_leaf(self.pivot)
self.pivot.add_leaf(self.axis)
self.axis.add_leaf(self.body)
self.pivot.add_leaf(self.offset)
self.offset.add_leaf(self.endbody)
self.system = System(self.bearing)
# Prescribed DOF accelerations
self.system.prescribe(self.axis, acc=0.0) # constant rotational speed
def simulate(self, xpivot=0.0, vprec=0.0, t1=10, dt=0.05):
# reset
self.system.q [:] = 0.0
self.system.qd[:] = 0.0
# initial conditions
self.system.q [self.pivot.istrain][0] = xpivot # initial elevation
self.system.qd[self.bearing.istrain][0] = vprec # initial azimuth spd
self.system.qd[self.axis.istrain][0] = self.spin # initial rotation speed
self.integ = Integrator(self.system, ('pos','vel'))
self.integ.add_output(dynamics.LoadOutput(self.axis.iprox))
self.integ.add_output(dynamics.LoadOutput(self.pivot.iprox))
self.integ.add_output(dynamics.LoadOutput(self.bearing.iprox))
#integ.add_output(dynamics.CustomOutput(
# lambda s: np.dot(self.axis.mass_vv, self.system.qdd[el.iprox+el.idist]) + \
# np.dot(el.mass_ve, self.system.qdd[el.istrain])))
# simulate
if t1 > 0:
self.t, self.y = self.integ.integrate(t1, dt)
for i,lab in enumerate(self.integ.labels()):
print "%2d %s" % (i,lab)
return self.t, self.y
def ani(self, vs=1):
l = self.length * 1.1
return dynvis.anim(self.system, self.t, self.y,
(0,vs), (-l,l), (-l,l), velocities=False)
def __init__(self, mode_source_file, root_length=0):
# Modal element using data from Bladed model
print "Loading modes from '%s'..." % mode_source_file
self.modes = ModalRepresentation.from_Bladed(mode_source_file)
Ry = rotmat_y(-pi / 2)
Rhb1 = rotmat_x(0 * 2 * pi / 3)
Rhb2 = rotmat_x(1 * 2 * pi / 3)
Rhb3 = rotmat_x(2 * 2 * pi / 3)
self.bearing = Hinge('bearing', [1, 0, 0])
root1 = RigidConnection('root1', root_length * np.dot(Rhb1, [0, 0, 1]),
dot(Rhb1, Ry))
root2 = RigidConnection('root2', root_length * np.dot(Rhb2, [0, 0, 1]),
dot(Rhb2, Ry))
root3 = RigidConnection('root3', root_length * np.dot(Rhb3, [0, 0, 1]),
dot(Rhb3, Ry))
self.blade1 = ModalElement('blade1', self.modes)
self.blade2 = ModalElement('blade2', self.modes)
self.blade3 = ModalElement('blade3', self.modes)
self.bearing.add_leaf(root1)
self.bearing.add_leaf(root2)
self.bearing.add_leaf(root3)
root1.add_leaf(self.blade1)
root2.add_leaf(self.blade2)
root3.add_leaf(self.blade3)
self.system = System(self.bearing)
# Prescribed DOF accelerations - constant rotor speed
self.system.prescribe(self.bearing.istrain, vel=0.0, acc=0.0)
# setup integrator
self.integ = Integrator(self.system, ('pos', 'vel'))
self.integ.add_output(dynamics.LoadOutput(self.bearing.iprox))
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(dynamics.LoadOutput(b.iprox, local=True))
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(
dynamics.CustomOutput(lambda s: b.station_positions()[-1],
label="{} tip defl".format(b)))
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(
dynamics.CustomOutput(lambda s: dot(b.Rp,
b.station_positions()[-1]),
label="{} tip pos".format(b)))
def __init__(self, bladed_file, root_length=0, rigid=False):
# Modal element using data from Bladed model
print "Loading modes from '%s'..." % bladed_file
self.blade = Blade(bladed_file)
self.tower = Tower(bladed_file)
self.modes = self.blade.modal_rep()
#self.tmodes = self.tower.modal_rep()
Ry = rotmat_y(-pi/2)
Rhb1 = rotmat_x(0 * 2*pi/3)
Rhb2 = rotmat_x(1 * 2*pi/3)
Rhb3 = rotmat_x(2 * 2*pi/3)
self.base = FreeJoint('base')
self.towerlink = RigidConnection('tower', [0,0,self.tower.hubheight])
self.bearing = Hinge('bearing', [1,0,0])
root1 = RigidConnection('root1', root_length*np.dot(Rhb1,[0,0,1]), dot(Rhb1,Ry))
root2 = RigidConnection('root2', root_length*np.dot(Rhb2,[0,0,1]), dot(Rhb2,Ry))
root3 = RigidConnection('root3', root_length*np.dot(Rhb3,[0,0,1]), dot(Rhb3,Ry))
self.blade1 = ModalElement('blade1', self.modes)
self.blade2 = ModalElement('blade2', self.modes)
self.blade3 = ModalElement('blade3', self.modes)
self.base.add_leaf(self.towerlink)
self.towerlink.add_leaf(self.bearing)
self.bearing.add_leaf(root1)
self.bearing.add_leaf(root2)
self.bearing.add_leaf(root3)
root1.add_leaf(self.blade1)
root2.add_leaf(self.blade2)
root3.add_leaf(self.blade3)
self.system = System(self.base)
# Prescribed DOF accelerations - constant rotor speed
self.base_motion = None
self.base_motion_amp = 0
self.system.prescribe(self.bearing, vel=0)
self.system.prescribe(self.base, vel=0)
if rigid:
for b in (self.blade1, self.blade2, self.blade3):
self.system.prescribe(b, vel=0)
# setup integrator
self.integ = Integrator(self.system, ('pos','vel','acc'))
self.integ.add_output(dynamics.LoadOutput(self.base.iprox))
self.integ.add_output(dynamics.LoadOutput(self.towerlink.iprox))
self.integ.add_output(dynamics.LoadOutput(self.bearing.iprox))
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(dynamics.LoadOutput(b.iprox, local=True))
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(b.output_deflections())
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(b.output_positions())
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(dynamics.NodeOutput(b.iprox, local=True, deriv=2))
def __init__(self, mode_source_file, root_length=0, wind_table=None):
# Modal element using data from Bladed model
print "Loading modes from '%s'..." % mode_source_file
self.blade = Blade(mode_source_file)
self.modes = self.blade.modal_rep()
if wind_table is not None:
loading = BladeLoading(self.blade, wind_table, None)
else:
loading = None
Ry = rotmat_y(-pi/2)
Rhb1 = rotmat_x(0 * 2*pi/3)
Rhb2 = rotmat_x(1 * 2*pi/3)
Rhb3 = rotmat_x(2 * 2*pi/3)
self.bearing = Hinge('bearing', [1,0,0])
root1 = RigidConnection('root1', root_length*np.dot(Rhb1,[0,0,1]), dot(Rhb1,Ry))
root2 = RigidConnection('root2', root_length*np.dot(Rhb2,[0,0,1]), dot(Rhb2,Ry))
root3 = RigidConnection('root3', root_length*np.dot(Rhb3,[0,0,1]), dot(Rhb3,Ry))
self.blade1 = ModalElement('blade1', self.modes, loading)
self.blade2 = ModalElement('blade2', self.modes)
self.blade3 = ModalElement('blade3', self.modes)
self.bearing.add_leaf(root1)
self.bearing.add_leaf(root2)
self.bearing.add_leaf(root3)
root1.add_leaf(self.blade1)
root2.add_leaf(self.blade2)
root3.add_leaf(self.blade3)
self.system = System(self.bearing)
# Prescribed DOF accelerations - constant rotor speed
self.system.prescribe(self.bearing, vel=0.0, acc=0.0)
# setup integrator
self.integ = Integrator(self.system, ('pos','vel'))
self.integ.add_output(dynamics.LoadOutput(self.bearing.iprox))
self.integ.add_output(dynamics.LoadOutput(self.blade1.iprox, local=True))
self.integ.add_output(self.blade1.output_deflections())
self.integ.add_output(self.blade1.output_positions())
def __init__(self, length, radius, mass, spin):
self.length = length
self.radius = radius
self.mass = mass
self.spin = spin
Jx = mass * radius**2 / 2
self.bearing = Hinge('bearing', [0,0,1])
self.pivot = Hinge('pivot', [0,1,0])
self.axis = Hinge('axis', [1,0,0])
self.body = UniformBeam('body', length, mass/length,
1, 1, 1, Jx=Jx/2) # /2 because added to both ends
self.bearing.add_leaf(self.pivot)
self.pivot.add_leaf(self.axis)
self.axis.add_leaf(self.body)
self.system = System(self.bearing)
# Prescribed DOF accelerations
self.system.prescribe(self.axis.istrain, 0.0) # constant rotational speed
self.system.prescribe(self.body.istrain, 0.0) # rigid beam
def __init__(self, length, radius, mass, spin):
self.length = length
self.radius = radius
self.mass = mass
self.spin = spin
Jx = mass * radius**2 / 2
self.bearing = Hinge('bearing', [0, 0, 1])
self.pivot = Hinge('pivot', [0, 1, 0])
self.axis = Hinge('axis', [1, 0, 0])
self.body = UniformBeam('body',
length,
mass / length,
1,
1,
1,
Jx=Jx / 2) # /2 because added to both ends
self.bearing.add_leaf(self.pivot)
self.pivot.add_leaf(self.axis)
self.axis.add_leaf(self.body)
self.system = System(self.bearing)
# Prescribed DOF accelerations
self.system.prescribe(self.axis.istrain,
0.0) # constant rotational speed
self.system.prescribe(self.body.istrain, 0.0) # rigid beam
def __init__(self, length, radius, mass, spin):
self.length = length
self.radius = radius
self.mass = mass
self.spin = spin
x = np.linspace(0, length)
modes = linearisation.ModalRepresentation(
x=x,
shapes=np.zeros((len(x), 3, 0)),
rotations=np.zeros((len(x), 3, 0)),
density=np.ones_like(x) * mass / length,
mass_axis=np.zeros((len(x), 2)),
section_inertia=np.ones_like(x) * radius**2 / 4,
freqs=np.zeros((0, )),
)
self.bearing = Hinge('bearing', [0, 0, 1])
self.pivot = Hinge('pivot', [0, 1, 0])
self.axis = Hinge('axis', [1, 0, 0])
self.body = ModalElement('body', modes)
self.bearing.add_leaf(self.pivot)
self.pivot.add_leaf(self.axis)
self.axis.add_leaf(self.body)
self.system = System(self.bearing)
# Prescribed DOF accelerations
self.system.prescribe(self.axis.istrain,
0.0) # constant rotational speed
def __init__(self, length, radius, mass, spin, endmass):
self.length = length
self.radius = radius
self.mass = mass
self.spin = spin
self.endmass = endmass
Jx = mass * radius**2 / 2
self.bearing = Hinge('bearing', [0, 0, 1])
self.pivot = Hinge('pivot', [0, 1, 0])
self.offset = RigidConnection('offset', [-length / 2, 0, 0])
self.axis = Hinge('axis', [1, 0, 0])
self.body = UniformBeam('body',
length,
mass / length,
1,
1,
1,
Jx=Jx / 2) # /2 because added to both ends
self.endbody = RigidBody('end', endmass)
self.bearing.add_leaf(self.pivot)
self.pivot.add_leaf(self.offset)
self.offset.add_leaf(self.axis)
self.axis.add_leaf(self.body)
self.offset.add_leaf(self.endbody)
self.system = System(self.bearing)
# Prescribed DOF accelerations
self.system.prescribe(self.axis, acc=0.0) # constant rotational speed
self.system.prescribe(self.body, acc=0.0) # rigid beam
def __init__(self, length, radius, mass, endmass):
self.length = length
self.radius = radius
self.mass = mass
self.endmass = endmass
# corrected radius for lumped masses
mr = radius / np.sqrt(2)
root3 = np.sqrt(3)
self.A = 3 * (mass/3) * mr**2 / 2 + endmass*(length/2)**2
self.C = 3 * (mass/3) * mr**2
self.pivot = Hinge('pivot', [0,1,0])
self.axis = Hinge('axis', [0,0,1])
self.arm1 = RigidConnection('arm1', [mr,0,0])
self.arm2 = RigidConnection('arm2', [-mr/2, mr*root3/2,0])
self.arm3 = RigidConnection('arm3', [-mr/2,-mr*root3/2,0])
self.body = RigidBody('body', mass/3)
self.body2 = RigidBody('body2', mass/3)
self.body3 = RigidBody('body3', mass/3)
self.offset = RigidConnection('offset', [0,0,length/2])
self.endbody = RigidBody('end', endmass)
self.pivot.add_leaf(self.axis)
self.axis.add_leaf(self.arm1)
self.axis.add_leaf(self.arm2)
self.axis.add_leaf(self.arm3)
self.arm1.add_leaf(self.body)
self.arm2.add_leaf(self.body2)
self.arm3.add_leaf(self.body3)
self.pivot.add_leaf(self.offset)
self.offset.add_leaf(self.endbody)
self.system = System(self.pivot)
# Prescribed DOF accelerations
self.system.prescribe(self.axis, acc=0.0) # constant rotational speed
def __init__(self, length, radius, mass, endmass):
self.length = length
self.radius = radius
self.mass = mass
self.endmass = endmass
# corrected radius for lumped masses
mr = radius / np.sqrt(2)
root3 = np.sqrt(3)
self.A = 3 * (mass / 3) * mr**2 / 2 + endmass * (length / 2)**2
self.C = 3 * (mass / 3) * mr**2
self.pivot = Hinge('pivot', [0, 1, 0])
self.axis = Hinge('axis', [0, 0, 1])
self.arm1 = RigidConnection('arm1', [mr, 0, 0])
self.arm2 = RigidConnection('arm2', [-mr / 2, mr * root3 / 2, 0])
self.arm3 = RigidConnection('arm3', [-mr / 2, -mr * root3 / 2, 0])
self.body = RigidBody('body', mass / 3)
self.body2 = RigidBody('body2', mass / 3)
self.body3 = RigidBody('body3', mass / 3)
self.offset = RigidConnection('offset', [0, 0, length / 2])
self.endbody = RigidBody('end', endmass)
self.pivot.add_leaf(self.axis)
self.axis.add_leaf(self.arm1)
self.axis.add_leaf(self.arm2)
self.axis.add_leaf(self.arm3)
self.arm1.add_leaf(self.body)
self.arm2.add_leaf(self.body2)
self.arm3.add_leaf(self.body3)
self.pivot.add_leaf(self.offset)
self.offset.add_leaf(self.endbody)
self.system = System(self.pivot)
# Prescribed DOF accelerations
self.system.prescribe(self.axis, acc=0.0) # constant rotational speed
def __init__(self, length, radius, mass, spin):
self.length = length
self.radius = radius
self.mass = mass
self.spin = spin
Jx = radius**2 / 2
Jyz = (3*radius**2 + length**2) / 12
Jyz_0 = Jyz + (length/2)**2 # parallel axis theorem
inertia = mass * np.diag([Jx, Jyz_0, Jyz_0])
self.bearing = Hinge('bearing', [0,0,1])
self.pivot = Hinge('pivot', [0,1,0])
self.axis = Hinge('axis', [1,0,0])
self.body = RigidBody('body', mass, inertia, [length/2, 0, 0])
self.bearing.add_leaf(self.pivot)
self.pivot.add_leaf(self.axis)
self.axis.add_leaf(self.body)
self.system = System(self.bearing)
# Prescribed DOF accelerations
self.system.prescribe(self.axis, acc=0.0) # constant rotational speed
def __init__(self, mode_source_file, root_length=0):
# Modal element using data from Bladed model
print "Loading modes from '%s'..." % mode_source_file
self.modes = ModalRepresentation.from_Bladed(mode_source_file)
self.bearing = Hinge('bearing', [0,0,1])
self.offset = RigidConnection('offset', [root_length, 0, 0])
self.blade = ModalElement('blade', self.modes)
self.bearing.add_leaf(self.offset)
self.offset.add_leaf(self.blade)
self.system = System(self.bearing)
# Prescribed DOF accelerations
self.system.prescribe(self.bearing.istrain, vel=0.0, acc=0.0) # constant spin speed
class Gyroscope(object):
def __init__(self, length, radius, mass, spin):
self.length = length
self.radius = radius
self.mass = mass
self.spin = spin
Jx = radius**2 / 2
Jyz = (3 * radius**2 + length**2) / 12
Jyz_0 = Jyz + (length / 2)**2 # parallel axis theorem
inertia = mass * np.diag([Jx, Jyz_0, Jyz_0])
self.bearing = Hinge('bearing', [0, 0, 1])
self.pivot = Hinge('pivot', [0, 1, 0])
self.axis = Hinge('axis', [1, 0, 0])
self.body = RigidBody('body', mass, inertia, [length / 2, 0, 0])
self.bearing.add_leaf(self.pivot)
self.pivot.add_leaf(self.axis)
self.axis.add_leaf(self.body)
self.system = System(self.bearing)
# Prescribed DOF accelerations
self.system.prescribe(self.axis, acc=0.0) # constant rotational speed
def simulate(self, xpivot=0.0, vprec=0.0, t1=10, dt=0.05):
# reset
self.system.q[:] = 0.0
self.system.qd[:] = 0.0
# initial conditions
self.system.q[self.pivot.istrain][0] = xpivot # initial elevation
self.system.qd[
self.bearing.istrain][0] = vprec # initial elevation spd
self.system.qd[
self.axis.istrain][0] = self.spin # initial rotation speed
self.integ = Integrator(self.system, ('pos', 'vel'))
self.integ.add_output(dynamics.LoadOutput(self.axis.iprox))
self.integ.add_output(dynamics.LoadOutput(self.pivot.iprox))
self.integ.add_output(dynamics.LoadOutput(self.bearing.iprox))
# simulate
if t1 > 0:
self.t, self.y = self.integ.integrate(t1, dt)
for i, lab in enumerate(self.integ.labels()):
print "%2d %s" % (i, lab)
return self.t, self.y
def ani(self, vs=1):
l = self.length * 1.1
return dynvis.anim(self.system,
self.t,
self.y, (0, vs), (-l, l), (-l, l),
velocities=False)
class Gyroscope(object):
def __init__(self, length, radius, mass, spin):
self.length = length
self.radius = radius
self.mass = mass
self.spin = spin
Jx = radius**2 / 2
Jyz = (3*radius**2 + length**2) / 12
Jyz_0 = Jyz + (length/2)**2 # parallel axis theorem
inertia = mass * np.diag([Jx, Jyz_0, Jyz_0])
self.bearing = Hinge('bearing', [0,0,1])
self.pivot = Hinge('pivot', [0,1,0])
self.axis = Hinge('axis', [1,0,0])
self.body = RigidBody('body', mass, inertia, [length/2, 0, 0])
self.bearing.add_leaf(self.pivot)
self.pivot.add_leaf(self.axis)
self.axis.add_leaf(self.body)
self.system = System(self.bearing)
# Prescribed DOF accelerations
self.system.prescribe(self.axis, acc=0.0) # constant rotational speed
def simulate(self, xpivot=0.0, vprec=0.0, t1=10, dt=0.05):
# reset
self.system.q [:] = 0.0
self.system.qd[:] = 0.0
# initial conditions
self.system.q [self.pivot.istrain][0] = xpivot # initial elevation
self.system.qd[self.bearing.istrain][0] = vprec # initial elevation spd
self.system.qd[self.axis .istrain][0] = self.spin # initial rotation speed
self.integ = Integrator(self.system, ('pos','vel'))
self.integ.add_output(dynamics.LoadOutput(self.axis.iprox))
self.integ.add_output(dynamics.LoadOutput(self.pivot.iprox))
self.integ.add_output(dynamics.LoadOutput(self.bearing.iprox))
# simulate
if t1 > 0:
self.t, self.y = self.integ.integrate(t1, dt)
for i,lab in enumerate(self.integ.labels()):
print "%2d %s" % (i,lab)
return self.t, self.y
def ani(self, vs=1):
l = self.length * 1.1
return dynvis.anim(self.system, self.t, self.y,
(0,vs), (-l,l), (-l,l), velocities=False)
def __init__(self, mode_source_file, root_length=0):
# Modal element using data from Bladed model
print "Loading modes from '%s'..." % mode_source_file
self.modes = ModalRepresentation.from_Bladed(mode_source_file)
Ry = rotmat_y(-pi/2)
Rhb1 = rotmat_x(0 * 2*pi/3)
Rhb2 = rotmat_x(1 * 2*pi/3)
Rhb3 = rotmat_x(2 * 2*pi/3)
self.bearing = Hinge('bearing', [1,0,0])
root1 = RigidConnection('root1', root_length*np.dot(Rhb1,[0,0,1]), dot(Rhb1,Ry))
root2 = RigidConnection('root2', root_length*np.dot(Rhb2,[0,0,1]), dot(Rhb2,Ry))
root3 = RigidConnection('root3', root_length*np.dot(Rhb3,[0,0,1]), dot(Rhb3,Ry))
self.blade1 = ModalElement('blade1', self.modes)
self.blade2 = ModalElement('blade2', self.modes)
self.blade3 = ModalElement('blade3', self.modes)
self.bearing.add_leaf(root1)
self.bearing.add_leaf(root2)
self.bearing.add_leaf(root3)
root1.add_leaf(self.blade1)
root2.add_leaf(self.blade2)
root3.add_leaf(self.blade3)
self.system = System(self.bearing)
# Prescribed DOF accelerations - constant rotor speed
self.system.prescribe(self.bearing.istrain, vel=0.0, acc=0.0)
# setup integrator
self.integ = Integrator(self.system, ('pos','vel'))
self.integ.add_output(dynamics.LoadOutput(self.bearing.iprox))
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(dynamics.LoadOutput(b.iprox, local=True))
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(dynamics.CustomOutput(
lambda s: b.station_positions()[-1], label="{} tip defl".format(b)))
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(dynamics.CustomOutput(
lambda s: dot(b.Rp, b.station_positions()[-1]), label="{} tip pos".format(b)))
class Gyroscope(object):
def __init__(self, length, radius, mass, spin):
self.length = length
self.radius = radius
self.mass = mass
self.spin = spin
Jx = radius**2 / 2
Jyz = (3 * radius**2 + length**2) / 12
Jyz_0 = Jyz + (length / 2)**2 # parallel axis theorem
inertia = mass * np.diag([Jx, Jyz_0, Jyz_0])
self.bearing = Hinge('bearing', [0, 0, 1])
self.pivot = Hinge('pivot', [0, 1, 0])
self.axis = Hinge('axis', [1, 0, 0])
self.body = RigidBody('body', mass, inertia, [length / 2, 0, 0])
self.bearing.add_leaf(self.pivot)
self.pivot.add_leaf(self.axis)
self.axis.add_leaf(self.body)
self.system = System(self.bearing)
# Prescribed DOF accelerations
self.system.prescribe(self.axis.istrain,
0.0) # constant rotational speed
def simulate(self, xpivot=0.0, vpivot=0.0, t1=1.5, dt=0.01):
# reset
self.system.q[:] = 0.0
self.system.qd[:] = 0.0
# initial conditions
self.system.q[self.pivot.istrain[0]] = xpivot # initial elevation
self.system.qd[self.pivot.istrain[0]] = vpivot # initial elevation spd
self.system.qd[
self.axis.istrain[0]] = self.spin # initial rotation speed
# simulate
self.t = np.arange(0, t1, dt)
self.y = solve_system(self.system, self.t, outputs='vels')
def ani(self, vs=1):
l = self.length * 1.1
return dynvis.anim(self.system,
self.t,
self.y, (0, vs), (-l, l), (-l, l),
velocities=False)
class Gyroscope(object):
def __init__(self, length, radius, mass, spin):
self.length = length
self.radius = radius
self.mass = mass
self.spin = spin
Jx = radius**2 / 2
Jyz = (3*radius**2 + length**2) / 12
Jyz_0 = Jyz + (length/2)**2 # parallel axis theorem
inertia = mass * np.diag([Jx, Jyz_0, Jyz_0])
self.bearing = Hinge('bearing', [0,0,1])
self.pivot = Hinge('pivot', [0,1,0])
self.axis = Hinge('axis', [1,0,0])
self.body = RigidBody('body', mass, inertia, [length/2, 0, 0])
self.bearing.add_leaf(self.pivot)
self.pivot.add_leaf(self.axis)
self.axis.add_leaf(self.body)
self.system = System(self.bearing)
# Prescribed DOF accelerations
self.system.prescribe(self.axis.istrain, 0.0) # constant rotational speed
def simulate(self, xpivot=0.0, vpivot=0.0, t1=1.5, dt=0.01):
# reset
self.system.q [:] = 0.0
self.system.qd[:] = 0.0
# initial conditions
self.system.q [self.pivot.istrain[0]] = xpivot # initial elevation
self.system.qd[self.pivot.istrain[0]] = vpivot # initial elevation spd
self.system.qd[self.axis .istrain[0]] = self.spin # initial rotation speed
# simulate
self.t = np.arange(0, t1, dt)
self.y = solve_system(self.system, self.t, outputs='vels')
def ani(self, vs=1):
l = self.length * 1.1
return dynvis.anim(self.system, self.t, self.y,
(0,vs), (-l,l), (-l,l), velocities=False)
def __init__(self, length, radius, mass, spin):
self.length = length
self.radius = radius
self.mass = mass
self.spin = spin
Jx = radius**2 / 2
Jyz = (3 * radius**2 + length**2) / 12
Jyz_0 = Jyz + (length / 2)**2 # parallel axis theorem
inertia = mass * np.diag([Jx, Jyz_0, Jyz_0])
self.bearing = Hinge('bearing', [0, 0, 1])
self.pivot = Hinge('pivot', [0, 1, 0])
self.axis = Hinge('axis', [1, 0, 0])
self.body = RigidBody('body', mass, inertia, [length / 2, 0, 0])
self.bearing.add_leaf(self.pivot)
self.pivot.add_leaf(self.axis)
self.axis.add_leaf(self.body)
self.system = System(self.bearing)
# Prescribed DOF accelerations
self.system.prescribe(self.axis, acc=0.0) # constant rotational speed
class Rotor(object):
def __init__(self, mode_source_file, root_length=0):
# Modal element using data from Bladed model
print "Loading modes from '%s'..." % mode_source_file
self.blade = Blade(mode_source_file)
self.modes = self.blade.modal_rep()
Ry = rotmat_y(-pi/2)
Rhb1 = rotmat_x(0 * 2*pi/3)
Rhb2 = rotmat_x(1 * 2*pi/3)
Rhb3 = rotmat_x(2 * 2*pi/3)
self.bearing = Hinge('bearing', [1,0,0])
root1 = RigidConnection('root1', root_length*np.dot(Rhb1,[0,0,1]), dot(Rhb1,Ry))
root2 = RigidConnection('root2', root_length*np.dot(Rhb2,[0,0,1]), dot(Rhb2,Ry))
root3 = RigidConnection('root3', root_length*np.dot(Rhb3,[0,0,1]), dot(Rhb3,Ry))
self.blade1 = ModalElement('blade1', self.modes)
self.blade2 = ModalElement('blade2', self.modes)
self.blade3 = ModalElement('blade3', self.modes)
self.bearing.add_leaf(root1)
self.bearing.add_leaf(root2)
self.bearing.add_leaf(root3)
root1.add_leaf(self.blade1)
root2.add_leaf(self.blade2)
root3.add_leaf(self.blade3)
self.system = System(self.bearing)
# Prescribed DOF accelerations - constant rotor speed
self.system.prescribe(self.bearing, acc=0.0)
# setup integrator
self.integ = Integrator(self.system, ('pos','vel'))
self.integ.add_output(dynamics.LoadOutput(self.bearing.iprox))
self.integ.add_output(dynamics.LoadOutput(self.blade1.iprox, local=True))
self.integ.add_output(self.blade1.output_deflections())
self.integ.add_output(self.blade1.output_positions())
def simulate(self, qm0=None, spin=10.0, t1=1.5, dt=0.01):
# reset
self.system.q [:] = 0.0
self.system.qd[:] = 0.0
# initial conditions
if qm0 is not None: # initial modal amplitudes
self.system.q[self.blade1.istrain] = qm0
self.system.q[self.blade2.istrain] = qm0
self.system.q[self.blade3.istrain] = qm0
self.system.qd[self.bearing.istrain][0] = spin
# simulate
self.t,self.y = self.integ.integrate(t1, dt)
for i,lab in enumerate(self.integ.labels()):
print "%2d %s" % (i,lab)
return self.t, self.y
def lin(self, qm0=None, spin=10.0):
# reset
self.system.q [:] = 0.0
self.system.qd[:] = 0.0
# initial conditions
if qm0 is not None: # initial modal amplitudes
self.system.q[self.blade1.istrain] = qm0
self.system.q[self.blade2.istrain] = qm0
self.system.q[self.blade3.istrain] = qm0
else:
qm0 = np.zeros(self.blade1._nstrain * 3)
self.system.prescribe(self.bearing, vel=spin, acc=0.0)
self.system.qd[self.bearing.istrain][0] = spin
linsys = linearisation.LinearisedSystem(self.system, qm0)
return linsys
def ani(self, t=None, y=None, planview=True):
if t is None: t = self.t
if y is None: y = self.y
l = 40
if planview:
return dynvis.anim(self.system, t, y, (1,2), (-l,l), (-l,l))
else:
return dynvis.anim(self.system, t, y, (0,1), (-l,l), (-5,5))
from linearisation import ModalRepresentation
import dynvis
dynamics.gravity = 0
bladedpath = '/bladed/gyro_effects/simpleblade_10rpm_10degs'
# Modal element using data from Bladed model
print "Loading modes from '%s'..." % bladedpath
modes = ModalRepresentation.from_Bladed(bladedpath+'.$pj')
rotorspeed = 10 * np.pi/30 # 10 rpm
overhang = 1 # 1m
# Modal element
yaw = Hinge('yaw', [0,0,1])
overhang = RigidConnection('overhang', [-overhang,0,0])
bearing = Hinge('bearing', [1,0,0],np.dot(rotmat_y(-np.pi/2), rotmat_x(-np.pi/2)))
el = ModalElement('el', modes)
yaw.add_leaf(overhang)
overhang.add_leaf(bearing)
bearing.add_leaf(el)
system = System(yaw)
# Prescribe rotation speed
system.prescribe(bearing.istrain, 0.0)
system.qd[bearing.istrain] = rotorspeed
# Prescribed yaw angle
acc_period = 0.1
yaw_time1 = 3.0
class Gyroscope(object):
def __init__(self, length, radius, mass, spin, endmass):
self.length = length
self.radius = radius
self.mass = mass
self.spin = spin
self.endmass = endmass
Jz = radius**2 / 2
Jxy = (3 * radius**2 + length**2) / 12
inertia = mass * np.diag([Jxy, Jxy, Jz])
self.bearing = Hinge('bearing', [0, 0, 1])
self.pivot = Hinge('pivot', [0, 1, 0])
self.axis = Hinge('axis', [0, 0, 1])
self.body = RigidBody('body', mass, inertia)
self.offset = RigidConnection('offset', [0, 0, length / 2])
self.endbody = RigidBody('end', endmass)
self.bearing.add_leaf(self.pivot)
self.pivot.add_leaf(self.axis)
self.axis.add_leaf(self.body)
self.pivot.add_leaf(self.offset)
self.offset.add_leaf(self.endbody)
self.system = System(self.bearing)
# Prescribed DOF accelerations
self.system.prescribe(self.axis, acc=0.0) # constant rotational speed
def simulate(self, xpivot=0.0, vprec=0.0, t1=10, dt=0.05):
# reset
self.system.q[:] = 0.0
self.system.qd[:] = 0.0
# initial conditions
self.system.q[self.pivot.istrain][0] = xpivot # initial elevation
self.system.qd[self.bearing.istrain][0] = vprec # initial azimuth spd
self.system.qd[
self.axis.istrain][0] = self.spin # initial rotation speed
self.integ = Integrator(self.system, ('pos', 'vel'))
self.integ.add_output(dynamics.LoadOutput(self.axis.iprox))
self.integ.add_output(dynamics.LoadOutput(self.pivot.iprox))
self.integ.add_output(dynamics.LoadOutput(self.bearing.iprox))
#integ.add_output(dynamics.CustomOutput(
# lambda s: np.dot(self.axis.mass_vv, self.system.qdd[el.iprox+el.idist]) + \
# np.dot(el.mass_ve, self.system.qdd[el.istrain])))
# simulate
if t1 > 0:
self.t, self.y = self.integ.integrate(t1, dt)
for i, lab in enumerate(self.integ.labels()):
print "%2d %s" % (i, lab)
return self.t, self.y
def ani(self, vs=1):
l = self.length * 1.1
return dynvis.anim(self.system,
self.t,
self.y, (0, vs), (-l, l), (-l, l),
velocities=False)
class Rotor(object):
def __init__(self, mode_source_file, root_length=0):
# Modal element using data from Bladed model
print "Loading modes from '%s'..." % mode_source_file
self.modes = ModalRepresentation.from_Bladed(mode_source_file)
self.bearing = Hinge('bearing', [0, 0, 1])
self.offset = RigidConnection('offset', [root_length, 0, 0])
self.blade = ModalElement('blade', self.modes)
self.bearing.add_leaf(self.offset)
self.offset.add_leaf(self.blade)
self.system = System(self.bearing)
# Prescribed DOF accelerations
self.system.prescribe(self.bearing.istrain, vel=0.0,
acc=0.0) # constant spin speed
def simulate(self, qm0, spin=10.0, t1=1.5, dt=0.01):
# reset
self.system.q[:] = 0.0
self.system.qd[:] = 0.0
# initial conditions
self.system.q[self.blade.istrain] = qm0 # initial modal amplitudes
self.system.prescribe(self.bearing.istrain, vel=spin,
acc=0.0) #acc=spin/t1)
# setup integrator
self.integ = Integrator(self.system, ('pos', 'vel'))
self.integ.add_output(dynamics.LoadOutput(self.bearing.iprox))
self.integ.add_output(dynamics.LoadOutput(self.blade.iprox))
self.integ.add_output(dynamics.LoadOutput(self.blade.iprox,
local=True))
self.integ.add_output(
dynamics.CustomOutput(lambda s: self.blade.station_positions()[-1],
label="Tip pos"))
self.integ.add_output(
dynamics.CustomOutput(lambda s: self.blade.quad_stress,
label="Quad stress"))
# simulate
self.t, self.y = self.integ.integrate(t1, dt)
return self.t, self.y
def lin(self, qm0, spin=10.0):
# reset
self.system.q[:] = 0.0
self.system.qd[:] = 0.0
# initial conditions
self.system.q[self.blade.istrain] = qm0 # initial modal amplitudes
self.system.prescribe(self.bearing.istrain, vel=spin,
acc=0.0) # constant speed
linsys = linearisation.LinearisedSystem(self.system, qm0)
return linsys
def ani(self, vs=1):
l = 40
return dynvis.anim(self.system,
self.t,
self.y, (0, vs), (-l, l), (-l, l),
velocities=False,
only_free=True)
class FlappedBladeTurbine(object):
def __init__(self, bladed_file, root_length=0):
# Load modes but use a simple flapped blade
print "Loading modes from '%s'..." % bladed_file
self.blade = Blade(bladed_file)
self.tower = Tower(bladed_file)
self.modes = self.blade.modal_rep()
# Calculate equivalent blade properties
I1 = self.modes.I0[0]
I2 = self.modes.J0[0, 0]
print I1, I2
wflap = self.modes.freqs[0]
bmass = self.modes.mass
inertia = self.modes.inertia_tensor(np.zeros(len(self.modes.freqs)))
Xc = [I1 / bmass, 0, 0]
kflap = I2 * wflap**2
Ry = rotmat_y(-pi / 2)
Rhb1 = rotmat_x(0 * 2 * pi / 3)
Rhb2 = rotmat_x(1 * 2 * pi / 3)
Rhb3 = rotmat_x(2 * 2 * pi / 3)
self.base = FreeJoint('base')
self.towerlink = RigidConnection('tower', [0, 0, self.tower.hubheight])
self.bearing = Hinge('bearing', [1, 0, 0])
root1 = RigidConnection('root1', root_length * np.dot(Rhb1, [0, 0, 1]),
dot(Rhb1, Ry))
root2 = RigidConnection('root2', root_length * np.dot(Rhb2, [0, 0, 1]),
dot(Rhb2, Ry))
root3 = RigidConnection('root3', root_length * np.dot(Rhb3, [0, 0, 1]),
dot(Rhb3, Ry))
self.flap1 = Hinge('flap1', [0, 1, 0])
self.flap2 = Hinge('flap2', [0, 1, 0])
self.flap3 = Hinge('flap3', [0, 1, 0])
self.blade1 = RigidBody('blade1', bmass, inertia, Xc)
self.blade2 = RigidBody('blade2', bmass, inertia, Xc)
self.blade3 = RigidBody('blade3', bmass, inertia, Xc)
self.flap1.stiffness = self.flap2.stiffness = self.flap3.stiffness = kflap
self.base.add_leaf(self.towerlink)
self.towerlink.add_leaf(self.bearing)
self.bearing.add_leaf(root1)
self.bearing.add_leaf(root2)
self.bearing.add_leaf(root3)
root1.add_leaf(self.flap1)
root2.add_leaf(self.flap2)
root3.add_leaf(self.flap3)
self.flap1.add_leaf(self.blade1)
self.flap2.add_leaf(self.blade2)
self.flap3.add_leaf(self.blade3)
self.system = System(self.base)
# Prescribed DOF accelerations - constant rotor speed
self.base_motion = None
self.base_motion_amp = 0
self.system.prescribe(self.bearing, vel=0)
self.system.prescribe(self.base, vel=0)
# setup integrator
self.integ = Integrator(self.system, ('pos', 'vel', 'acc'))
self.integ.add_output(dynamics.LoadOutput(self.base.iprox))
self.integ.add_output(dynamics.LoadOutput(self.towerlink.iprox))
self.integ.add_output(
dynamics.LoadOutput(self.bearing.iprox, local=True))
self.integ.add_output(
dynamics.LoadOutput(self.bearing.idist[0], local=True))
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(dynamics.LoadOutput(b.iprox, local=True))
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(
dynamics.NodeOutput(b.iprox, local=True, deriv=2))
def set_base_motion(self, dof, w, amp):
self.base_motion = dof
self.base_motion_amp = amp
self.system.prescribe(self.base,
part=dof,
vel=lambda t: -w * amp * np.sin(w * t),
acc=lambda t: -w**2 * amp * np.cos(w * t))
def set_initial_conditions(self, qm0=None, az0=None, rotor_speed=None):
# initial conditions
if qm0 is not None: # initial hinge angle
self.system.q[self.flap1.istrain][0] = qm0
self.system.q[self.flap2.istrain][0] = qm0
self.system.q[self.flap3.istrain][0] = qm0
if az0 is not None:
self.system.q[self.bearing.istrain][0] = az0
if self.base_motion is not None:
self.system.q[self.base.istrain][
self.base_motion] = self.base_motion_amp
if rotor_speed is not None:
self.system.prescribe(self.bearing, vel=rotor_speed)
def simulate(self,
qm0=None,
az0=0.0,
rotor_speed=10.0,
t1=None,
dt=0.01,
t0=0.0,
init=False):
# reset
self.system.q[:] = 0.0
self.system.qd[:] = 0.0
self.set_initial_conditions(qm0, az0, rotor_speed)
if t1 is None:
t1 = 4 * pi / rotor_speed if (rotor_speed != 0.0) else 2
if init:
self.system.find_equilibrium()
# simulate
t, y = self.integ.integrate(t1, dt, t0)
#for i,lab in enumerate(self.integ.labels):
# print "%2d %s" % (i,lab)
#return self.t, self.y
# Build results structure
results = FlappedTurbineResults(t, y)
return results
def lin(self, qm0=None, az0=None, rotor_speed=None, init=False):
# reset
self.system.q[:] = 0.0
self.system.qd[:] = 0.0
self.set_initial_conditions(qm0, az0, rotor_speed)
if init:
self.system.find_equilibrium()
# need initial amplitudes for linearisation point
if qm0 is None:
qm0 = self.system.q[self.blade1.istrain]
linsys = linearisation.LinearisedSystem(self.system, np.tile(qm0, 3))
return linsys
def ani(self, results, x=0, y=1):
H = self.tower.hubheight + self.blade.radii[-1]
limits = [(-H, H), (-H, H), (-5, H + 5)]
return dynvis.anim(self.system, results.t, results.strains.as_matrix(),
(x, y), limits[x], limits[y])
from linearisation import ModalRepresentation
import dynvis
dynamics.gravity = 0
bladedpath = '/bladed/gyro_effects/simpleblade_10rpm_10degs'
# Modal element using data from Bladed model
print "Loading modes from '%s'..." % bladedpath
modes = ModalRepresentation.from_Bladed(bladedpath + '.$pj')
rotorspeed = 10 * np.pi / 30 # 10 rpm
overhang = 1 # 1m
# Modal element
yaw = Hinge('yaw', [0, 0, 1])
overhang = RigidConnection('overhang', [-overhang, 0, 0])
bearing = Hinge('bearing', [1, 0, 0],
np.dot(rotmat_y(-np.pi / 2), rotmat_x(-np.pi / 2)))
el = ModalElement('el', modes)
yaw.add_leaf(overhang)
overhang.add_leaf(bearing)
bearing.add_leaf(el)
system = System(yaw)
# Prescribe rotation speed
system.prescribe(bearing.istrain, 0.0)
system.qd[bearing.istrain] = rotorspeed
# Prescribed yaw angle
acc_period = 0.1
class Gyroscope(object):
def __init__(self, length, radius, mass, endmass):
self.length = length
self.radius = radius
self.mass = mass
self.endmass = endmass
Jz = radius**2 / 2
Jxy = (3*radius**2 + length**2) / 12
inertia = mass * np.diag([Jxy, Jxy, Jz])
self.A = mass*Jxy + endmass*(length/2)**2
self.C = mass*Jz
self.pivot = Hinge('pivot', [0,1,0])
self.axis = Hinge('axis', [0,0,1])
self.body = RigidBody('body', mass, inertia)
self.offset = RigidConnection('offset', [0,0,length/2])
self.endbody = RigidBody('end', endmass)
self.pivot.add_leaf(self.axis)
self.axis.add_leaf(self.body)
self.pivot.add_leaf(self.offset)
self.offset.add_leaf(self.endbody)
self.system = System(self.pivot)
# Prescribed DOF accelerations
self.system.prescribe(self.axis, acc=0.0) # constant rotational speed
def applied_torque(self, s):
# applied torque about y axis, Q2
elevation = s.q[self.pivot.istrain][0]
return self.endmass * dynamics.gravity * self.length/2 * np.sin(elevation)
def thetadotdot(self, s):
# acceleration about y axis, thetadotdot
Q2 = self.applied_torque(s)
return Q2 / self.A
def gyro_torque(self, s):
# gyroscopic sideways torque, Q1
spin = s.qd[self.axis.istrain][0] # spin speed
thetadot = s.qd[self.pivot.istrain][0]
return self.C * spin * thetadot
def simulate(self, xpivot=0.0, spin=10.0, t1=1.5, dt=0.01):
# reset
self.system.q [:] = 0.0
self.system.qd[:] = 0.0
# initial conditions
self.system.q [self.pivot.istrain][0] = xpivot # initial elevation
self.system.qd[self.axis .istrain][0] = spin # initial rotation speed
# setup integrator
#self.integ = Integrator(self.system, ('pos','vel','acc'))
self.integ = Integrator(self.system, ())
for istrain in (self.pivot.istrain, self.axis.istrain):
self.integ.add_output(dynamics.StrainOutput(istrain, deriv=0))
self.integ.add_output(dynamics.StrainOutput(istrain, deriv=1))
self.integ.add_output(dynamics.StrainOutput(istrain, deriv=2))
self.integ.add_output(dynamics.LoadOutput(self.pivot.idist[0]))
self.integ.add_output(dynamics.LoadOutput(self.pivot.idist[0], local=True))
self.integ.add_output(dynamics.LoadOutput(self.body.iprox))
self.integ.add_output(dynamics.LoadOutput(self.endbody.iprox))
self.integ.add_output(dynamics.CustomOutput(self.applied_torque, "Q2"))
self.integ.add_output(dynamics.CustomOutput(self.thetadotdot, "thetadotdot"))
self.integ.add_output(dynamics.CustomOutput(self.gyro_torque, "Q1"))
# simulate
if t1 > 0:
self.t,self.y = self.integ.integrate(t1, dt)
def ani(self, vs=1):
l = self.length * 1.1
return dynvis.anim(self.system, self.t, self.y,
(0,vs), (-l,l), (-l,l), velocities=False, only_free=True)
print "Loading modes from '%s'..." % bladedpath
modes = ModalRepresentation.from_Bladed(bladedpath+'.$pj')
# Blade loading
wind_table = np.array([
[0, 1, 2, 10], # time
[0, 0, 0, 0 ], # x
[0, 0, 20, 20], # y
[0, 0, 0, 0 ], # z
])
loading = BladeLoading(modes.x, wind_table, None)
rotorspeed = 10 * np.pi/30 # 10 rpm
# Modal element
bearing = Hinge('bearing', [0,1,0])
el = ModalElement('el', modes, loading)
bearing.add_leaf(el)
system = System(bearing)
# Prescribe rotation speed
system.prescribe(bearing.istrain, 0.0)
system.qd[bearing.istrain] = rotorspeed
system.find_equilibrium()
integ = Integrator(system, ())
integ.add_position_output(bearing.istrain)
integ.add_custom_output(lambda s: el.modes.X(el.xstrain)[(16,32),1:3].flatten(), 'defl')
integ.add_custom_output(lambda s: el._get_loading()[16,:], 'loading')
integ.add_custom_output(lambda s: el.quad_forces, 'quad_forces')
r_root = 0.5
blade_length = 60.0
EIy = 1000e6
EIz = 1000e6
Ry = rotmat_y(-pi/2)
Rhb1 = rotmat_x(0 * 2*pi/3)
Rhb2 = rotmat_x(1 * 2*pi/3)
Rhb3 = rotmat_x(2 * 2*pi/3)
fstiff = 1e6 * diag([1, 1, 5, 1000, 1000, 100])
foundation = FreeJoint('foundation', fstiff, post_transform=rotmat_y(-pi/2))
tower = EulerBeam('tower', tower_height, 3000, 100e6, 300e6, 300e6, 200e6)
nacelle = RigidConnection('nacelle', [0,0,overhang], rotmat_y(100*pi/180))
bearing = Hinge('bearing', [1,0,0])
hb1 = RigidConnection('hb1', np.dot(Rhb1,[0,0,1]), np.dot(Rhb1,Ry))
hb2 = RigidConnection('hb2', np.dot(Rhb2,[0,0,1]), np.dot(Rhb2,Ry))
hb3 = RigidConnection('hb3', np.dot(Rhb3,[0,0,1]), np.dot(Rhb3,Ry))
b1 = EulerBeam('b1',blade_length, 250, 1000e6, EIy, EIz, 200e6)
b2 = EulerBeam('b2',blade_length, 250, 1000e6, EIy, EIz, 200e6)
b3 = EulerBeam('b3',blade_length, 250, 1000e6, EIy, EIz, 200e6)
tower.damping = 0.05
foundation.add_leaf(tower)
tower.add_leaf(nacelle)
nacelle.add_leaf(bearing)
bearing.add_leaf(hb1)
bearing.add_leaf(hb2)
bearing.add_leaf(hb3)
class Turbine(object):
def __init__(self, bladed_file, root_length=0, rigid=False):
# Modal element using data from Bladed model
print "Loading modes from '%s'..." % bladed_file
self.blade = Blade(bladed_file)
self.tower = Tower(bladed_file)
self.modes = self.blade.modal_rep()
#self.tmodes = self.tower.modal_rep()
Ry = rotmat_y(-pi/2)
Rhb1 = rotmat_x(0 * 2*pi/3)
Rhb2 = rotmat_x(1 * 2*pi/3)
Rhb3 = rotmat_x(2 * 2*pi/3)
self.base = FreeJoint('base')
self.towerlink = RigidConnection('tower', [0,0,self.tower.hubheight])
self.bearing = Hinge('bearing', [1,0,0])
root1 = RigidConnection('root1', root_length*np.dot(Rhb1,[0,0,1]), dot(Rhb1,Ry))
root2 = RigidConnection('root2', root_length*np.dot(Rhb2,[0,0,1]), dot(Rhb2,Ry))
root3 = RigidConnection('root3', root_length*np.dot(Rhb3,[0,0,1]), dot(Rhb3,Ry))
self.blade1 = ModalElement('blade1', self.modes)
self.blade2 = ModalElement('blade2', self.modes)
self.blade3 = ModalElement('blade3', self.modes)
self.base.add_leaf(self.towerlink)
self.towerlink.add_leaf(self.bearing)
self.bearing.add_leaf(root1)
self.bearing.add_leaf(root2)
self.bearing.add_leaf(root3)
root1.add_leaf(self.blade1)
root2.add_leaf(self.blade2)
root3.add_leaf(self.blade3)
self.system = System(self.base)
# Prescribed DOF accelerations - constant rotor speed
self.base_motion = None
self.base_motion_amp = 0
self.system.prescribe(self.bearing, vel=0)
self.system.prescribe(self.base, vel=0)
if rigid:
for b in (self.blade1, self.blade2, self.blade3):
self.system.prescribe(b, vel=0)
# setup integrator
self.integ = Integrator(self.system, ('pos','vel','acc'))
self.integ.add_output(dynamics.LoadOutput(self.base.iprox))
self.integ.add_output(dynamics.LoadOutput(self.towerlink.iprox))
self.integ.add_output(dynamics.LoadOutput(self.bearing.iprox))
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(dynamics.LoadOutput(b.iprox, local=True))
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(b.output_deflections())
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(b.output_positions())
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(dynamics.NodeOutput(b.iprox, local=True, deriv=2))
@property
def mass(self):
"""Total mass of turbine"""
return self.tower.total_mass + self.modes.mass * 3
@property
def inertia(self):
"""Total rotational inertia of turbine about base"""
inertia = self.tower.total_inertia
inertia[(0,1),(0,1)] = self.modes.mass * 3 * self.tower.hubheight
return inertia
# XXX neglecting rotor rotational inertia
def set_base_motion(self, dof, w, amp):
self.base_motion = dof
self.base_motion_amp = amp
self.system.prescribe(self.base, part=dof,
vel=lambda t: -w *amp*np.sin(w*t),
acc=lambda t: -w**2*amp*np.cos(w*t))
def set_initial_conditions(self, qm0=None, az0=None, rotor_speed=None):
# initial conditions
if qm0 is not None: # initial modal amplitudes
self.system.q[self.blade1.istrain] = qm0
self.system.q[self.blade2.istrain] = qm0
self.system.q[self.blade3.istrain] = qm0
if az0 is not None:
self.system.q[self.bearing.istrain][0] = az0
if self.base_motion is not None:
self.system.q[self.base.istrain][self.base_motion] = self.base_motion_amp
if rotor_speed is not None:
self.system.prescribe(self.bearing, vel=rotor_speed)
def simulate(self, qm0=None, az0=0.0, rotor_speed=10.0, t1=None,
dt=0.01, t0=0.0, init=False):
# reset
self.system.q [:] = 0.0
self.system.qd[:] = 0.0
self.set_initial_conditions(qm0, az0, rotor_speed)
if t1 is None:
t1 = 4*pi/rotor_speed if (rotor_speed != 0.0) else 2
if init:
self.system.find_equilibrium()
# simulate
self.t,self.y = self.integ.integrate(t1, dt, t0)
for i,lab in enumerate(self.integ.labels()):
print "%2d %s" % (i,lab)
return self.t, self.y
def lin(self, qm0=None, az0=None, rotor_speed=None, init=False):
# reset
self.system.q [:] = 0.0
self.system.qd[:] = 0.0
self.set_initial_conditions(qm0, az0, rotor_speed)
if init:
self.system.find_equilibrium()
linsys = linearisation.LinearisedSystem(self.system)
return linsys
def ani(self, vs=(0,1), t=None, y=None):
if t is None: t = self.t
if y is None: y = self.y
limits = [(-10,10), (-42,42), (-5,110)]
return dynvis.anim(self.system, t, y, vs, limits[vs[0]], limits[vs[1]])
class Turbine(object):
def __init__(self, bladed_file, root_length=0, rigid=False):
# Modal element using data from Bladed model
print "Loading modes from '%s'..." % bladed_file
self.blade = Blade(bladed_file)
self.tower = Tower(bladed_file)
self.modes = self.blade.modal_rep()
Ry = rotmat_y(-pi/2)
Rhb1 = rotmat_x(0 * 2*pi/3)
Rhb2 = rotmat_x(1 * 2*pi/3)
Rhb3 = rotmat_x(2 * 2*pi/3)
self.base = FreeJoint('base')
self.towerlink = RigidConnection('tower', [0,0,self.tower.hubheight])
self.bearing = Hinge('bearing', [1,0,0])
root1 = RigidConnection('root1', root_length*np.dot(Rhb1,[0,0,1]), dot(Rhb1,Ry))
root2 = RigidConnection('root2', root_length*np.dot(Rhb2,[0,0,1]), dot(Rhb2,Ry))
root3 = RigidConnection('root3', root_length*np.dot(Rhb3,[0,0,1]), dot(Rhb3,Ry))
self.blade1 = ModalElement('blade1', self.modes)
self.blade2 = ModalElement('blade2', self.modes)
self.blade3 = ModalElement('blade3', self.modes)
self.base.add_leaf(self.towerlink)
self.towerlink.add_leaf(self.bearing)
self.bearing.add_leaf(root1)
self.bearing.add_leaf(root2)
self.bearing.add_leaf(root3)
root1.add_leaf(self.blade1)
root2.add_leaf(self.blade2)
root3.add_leaf(self.blade3)
self.system = System(self.base)
# Prescribed DOF accelerations - constant rotor speed
self.base_motion = None
self.base_motion_amp = 0
self.system.prescribe(self.bearing, vel=0)
self.system.prescribe(self.base, vel=0)
if rigid:
for b in (self.blade1, self.blade2, self.blade3):
self.system.prescribe(b, vel=0)
# setup integrator
self.integ = Integrator(self.system, ('pos','vel','acc'))
self.integ.add_output(dynamics.LoadOutput(self.base.iprox))
self.integ.add_output(dynamics.LoadOutput(self.towerlink.iprox))
self.integ.add_output(dynamics.LoadOutput(self.bearing.iprox, local=True))
self.integ.add_output(dynamics.LoadOutput(self.bearing.idist[0], local=True))
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(dynamics.LoadOutput(b.iprox, local=True))
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(b.output_deflections())
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(b.output_positions())
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(dynamics.NodeOutput(b.iprox, local=True, deriv=2))
def set_base_motion(self, dof, w, amp):
self.base_motion = dof
self.base_motion_amp = amp
self.system.prescribe(self.base, part=dof,
vel=lambda t: -w *amp*np.sin(w*t),
acc=lambda t: -w**2*amp*np.cos(w*t))
def set_initial_conditions(self, qm0=None, az0=None, rotor_speed=None):
# initial conditions
if qm0 is not None: # initial modal amplitudes
self.system.q[self.blade1.istrain] = qm0
self.system.q[self.blade2.istrain] = qm0
self.system.q[self.blade3.istrain] = qm0
if az0 is not None:
self.system.q[self.bearing.istrain][0] = az0
if self.base_motion is not None:
self.system.q[self.base.istrain][self.base_motion] = self.base_motion_amp
if rotor_speed is not None:
self.system.prescribe(self.bearing, vel=rotor_speed)
def simulate(self, qm0=None, az0=0.0, rotor_speed=10.0, t1=None,
dt=0.01, t0=0.0, init=False):
# reset
self.system.q [:] = 0.0
self.system.qd[:] = 0.0
self.set_initial_conditions(qm0, az0, rotor_speed)
if t1 is None:
t1 = 4*pi/rotor_speed if (rotor_speed != 0.0) else 2
if init:
self.system.find_equilibrium()
# simulate
t,y = self.integ.integrate(t1, dt, t0)
#for i,lab in enumerate(self.integ.labels):
# print "%2d %s" % (i,lab)
#return self.t, self.y
# Build results structure
results = TurbineResults(t, y, self.modes.mode_names)
return results
def lin(self, qm0=None, az0=None, rotor_speed=None, init=False):
# reset
self.system.q [:] = 0.0
self.system.qd[:] = 0.0
self.set_initial_conditions(qm0, az0, rotor_speed)
if init:
self.system.find_equilibrium()
# need initial amplitudes for linearisation point
if qm0 is None:
qm0 = self.system.q[self.blade1.istrain]
linsys = linearisation.LinearisedSystem(self.system, np.tile(qm0, 3))
return linsys
def ani(self, results, x=0, y=1):
H = self.tower.hubheight + self.blade.radii[-1]
limits = [(-H,H), (-H,H), (-5,H+5)]
return dynvis.anim(self.system, results.t, results.strains.as_matrix(),
(x, y), limits[x], limits[y])
def __init__(self, bladed_file, root_length=0):
# Load modes but use a simple flapped blade
print "Loading modes from '%s'..." % bladed_file
self.blade = Blade(bladed_file)
self.tower = Tower(bladed_file)
self.modes = self.blade.modal_rep()
# Calculate equivalent blade properties
I1 = self.modes.I0[0]
I2 = self.modes.J0[0,0]
print I1, I2
wflap = self.modes.freqs[0]
bmass = self.modes.mass
inertia = self.modes.inertia_tensor(np.zeros(len(self.modes.freqs)))
Xc = [I1 / bmass, 0, 0]
kflap = I2 * wflap**2
Ry = rotmat_y(-pi/2)
Rhb1 = rotmat_x(0 * 2*pi/3)
Rhb2 = rotmat_x(1 * 2*pi/3)
Rhb3 = rotmat_x(2 * 2*pi/3)
self.base = FreeJoint('base')
self.towerlink = RigidConnection('tower', [0,0,self.tower.hubheight])
self.bearing = Hinge('bearing', [1,0,0])
root1 = RigidConnection('root1', root_length*np.dot(Rhb1,[0,0,1]), dot(Rhb1,Ry))
root2 = RigidConnection('root2', root_length*np.dot(Rhb2,[0,0,1]), dot(Rhb2,Ry))
root3 = RigidConnection('root3', root_length*np.dot(Rhb3,[0,0,1]), dot(Rhb3,Ry))
self.flap1 = Hinge('flap1', [0,1,0])
self.flap2 = Hinge('flap2', [0,1,0])
self.flap3 = Hinge('flap3', [0,1,0])
self.blade1 = RigidBody('blade1', bmass, inertia, Xc)
self.blade2 = RigidBody('blade2', bmass, inertia, Xc)
self.blade3 = RigidBody('blade3', bmass, inertia, Xc)
self.flap1.stiffness = self.flap2.stiffness = self.flap3.stiffness = kflap
self.base.add_leaf(self.towerlink)
self.towerlink.add_leaf(self.bearing)
self.bearing.add_leaf(root1)
self.bearing.add_leaf(root2)
self.bearing.add_leaf(root3)
root1.add_leaf(self.flap1)
root2.add_leaf(self.flap2)
root3.add_leaf(self.flap3)
self.flap1.add_leaf(self.blade1)
self.flap2.add_leaf(self.blade2)
self.flap3.add_leaf(self.blade3)
self.system = System(self.base)
# Prescribed DOF accelerations - constant rotor speed
self.base_motion = None
self.base_motion_amp = 0
self.system.prescribe(self.bearing, vel=0)
self.system.prescribe(self.base, vel=0)
# setup integrator
self.integ = Integrator(self.system, ('pos','vel','acc'))
self.integ.add_output(dynamics.LoadOutput(self.base.iprox))
self.integ.add_output(dynamics.LoadOutput(self.towerlink.iprox))
self.integ.add_output(dynamics.LoadOutput(self.bearing.iprox, local=True))
self.integ.add_output(dynamics.LoadOutput(self.bearing.idist[0], local=True))
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(dynamics.LoadOutput(b.iprox, local=True))
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(dynamics.NodeOutput(b.iprox, local=True, deriv=2))
class FlappedBladeTurbine(object):
def __init__(self, bladed_file, root_length=0):
# Load modes but use a simple flapped blade
print "Loading modes from '%s'..." % bladed_file
self.blade = Blade(bladed_file)
self.tower = Tower(bladed_file)
self.modes = self.blade.modal_rep()
# Calculate equivalent blade properties
I1 = self.modes.I0[0]
I2 = self.modes.J0[0,0]
print I1, I2
wflap = self.modes.freqs[0]
bmass = self.modes.mass
inertia = self.modes.inertia_tensor(np.zeros(len(self.modes.freqs)))
Xc = [I1 / bmass, 0, 0]
kflap = I2 * wflap**2
Ry = rotmat_y(-pi/2)
Rhb1 = rotmat_x(0 * 2*pi/3)
Rhb2 = rotmat_x(1 * 2*pi/3)
Rhb3 = rotmat_x(2 * 2*pi/3)
self.base = FreeJoint('base')
self.towerlink = RigidConnection('tower', [0,0,self.tower.hubheight])
self.bearing = Hinge('bearing', [1,0,0])
root1 = RigidConnection('root1', root_length*np.dot(Rhb1,[0,0,1]), dot(Rhb1,Ry))
root2 = RigidConnection('root2', root_length*np.dot(Rhb2,[0,0,1]), dot(Rhb2,Ry))
root3 = RigidConnection('root3', root_length*np.dot(Rhb3,[0,0,1]), dot(Rhb3,Ry))
self.flap1 = Hinge('flap1', [0,1,0])
self.flap2 = Hinge('flap2', [0,1,0])
self.flap3 = Hinge('flap3', [0,1,0])
self.blade1 = RigidBody('blade1', bmass, inertia, Xc)
self.blade2 = RigidBody('blade2', bmass, inertia, Xc)
self.blade3 = RigidBody('blade3', bmass, inertia, Xc)
self.flap1.stiffness = self.flap2.stiffness = self.flap3.stiffness = kflap
self.base.add_leaf(self.towerlink)
self.towerlink.add_leaf(self.bearing)
self.bearing.add_leaf(root1)
self.bearing.add_leaf(root2)
self.bearing.add_leaf(root3)
root1.add_leaf(self.flap1)
root2.add_leaf(self.flap2)
root3.add_leaf(self.flap3)
self.flap1.add_leaf(self.blade1)
self.flap2.add_leaf(self.blade2)
self.flap3.add_leaf(self.blade3)
self.system = System(self.base)
# Prescribed DOF accelerations - constant rotor speed
self.base_motion = None
self.base_motion_amp = 0
self.system.prescribe(self.bearing, vel=0)
self.system.prescribe(self.base, vel=0)
# setup integrator
self.integ = Integrator(self.system, ('pos','vel','acc'))
self.integ.add_output(dynamics.LoadOutput(self.base.iprox))
self.integ.add_output(dynamics.LoadOutput(self.towerlink.iprox))
self.integ.add_output(dynamics.LoadOutput(self.bearing.iprox, local=True))
self.integ.add_output(dynamics.LoadOutput(self.bearing.idist[0], local=True))
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(dynamics.LoadOutput(b.iprox, local=True))
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(dynamics.NodeOutput(b.iprox, local=True, deriv=2))
def set_base_motion(self, dof, w, amp):
self.base_motion = dof
self.base_motion_amp = amp
self.system.prescribe(self.base, part=dof,
vel=lambda t: -w *amp*np.sin(w*t),
acc=lambda t: -w**2*amp*np.cos(w*t))
def set_initial_conditions(self, qm0=None, az0=None, rotor_speed=None):
# initial conditions
if qm0 is not None: # initial hinge angle
self.system.q[self.flap1.istrain][0] = qm0
self.system.q[self.flap2.istrain][0] = qm0
self.system.q[self.flap3.istrain][0] = qm0
if az0 is not None:
self.system.q[self.bearing.istrain][0] = az0
if self.base_motion is not None:
self.system.q[self.base.istrain][self.base_motion] = self.base_motion_amp
if rotor_speed is not None:
self.system.prescribe(self.bearing, vel=rotor_speed)
def simulate(self, qm0=None, az0=0.0, rotor_speed=10.0, t1=None,
dt=0.01, t0=0.0, init=False):
# reset
self.system.q [:] = 0.0
self.system.qd[:] = 0.0
self.set_initial_conditions(qm0, az0, rotor_speed)
if t1 is None:
t1 = 4*pi/rotor_speed if (rotor_speed != 0.0) else 2
if init:
self.system.find_equilibrium()
# simulate
t,y = self.integ.integrate(t1, dt, t0)
#for i,lab in enumerate(self.integ.labels):
# print "%2d %s" % (i,lab)
#return self.t, self.y
# Build results structure
results = FlappedTurbineResults(t, y)
return results
def lin(self, qm0=None, az0=None, rotor_speed=None, init=False):
# reset
self.system.q [:] = 0.0
self.system.qd[:] = 0.0
self.set_initial_conditions(qm0, az0, rotor_speed)
if init:
self.system.find_equilibrium()
# need initial amplitudes for linearisation point
if qm0 is None:
qm0 = self.system.q[self.blade1.istrain]
linsys = linearisation.LinearisedSystem(self.system, np.tile(qm0, 3))
return linsys
def ani(self, results, x=0, y=1):
H = self.tower.hubheight + self.blade.radii[-1]
limits = [(-H,H), (-H,H), (-5,H+5)]
return dynvis.anim(self.system, results.t, results.strains.as_matrix(),
(x, y), limits[x], limits[y])
class Rotor(object):
def __init__(self, mode_source_file, root_length=0):
# Modal element using data from Bladed model
print "Loading modes from '%s'..." % mode_source_file
self.blade = Blade(mode_source_file)
self.modes = self.blade.modal_rep()
Ry = rotmat_y(-pi / 2)
Rhb1 = rotmat_x(0 * 2 * pi / 3)
Rhb2 = rotmat_x(1 * 2 * pi / 3)
Rhb3 = rotmat_x(2 * 2 * pi / 3)
self.bearing = Hinge('bearing', [1, 0, 0])
root1 = RigidConnection('root1', root_length * np.dot(Rhb1, [0, 0, 1]),
dot(Rhb1, Ry))
root2 = RigidConnection('root2', root_length * np.dot(Rhb2, [0, 0, 1]),
dot(Rhb2, Ry))
root3 = RigidConnection('root3', root_length * np.dot(Rhb3, [0, 0, 1]),
dot(Rhb3, Ry))
self.blade1 = ModalElement('blade1', self.modes)
self.blade2 = ModalElement('blade2', self.modes)
self.blade3 = ModalElement('blade3', self.modes)
self.bearing.add_leaf(root1)
self.bearing.add_leaf(root2)
self.bearing.add_leaf(root3)
root1.add_leaf(self.blade1)
root2.add_leaf(self.blade2)
root3.add_leaf(self.blade3)
self.system = System(self.bearing)
# Prescribed DOF accelerations - constant rotor speed
self.system.prescribe(self.bearing, acc=0.0)
# setup integrator
self.integ = Integrator(self.system, ('pos', 'vel'))
self.integ.add_output(dynamics.LoadOutput(self.bearing.iprox))
self.integ.add_output(
dynamics.LoadOutput(self.blade1.iprox, local=True))
self.integ.add_output(self.blade1.output_deflections())
self.integ.add_output(self.blade1.output_positions())
def simulate(self, qm0=None, spin=10.0, t1=1.5, dt=0.01):
# reset
self.system.q[:] = 0.0
self.system.qd[:] = 0.0
# initial conditions
if qm0 is not None: # initial modal amplitudes
self.system.q[self.blade1.istrain] = qm0
self.system.q[self.blade2.istrain] = qm0
self.system.q[self.blade3.istrain] = qm0
self.system.qd[self.bearing.istrain][0] = spin
# simulate
self.t, self.y = self.integ.integrate(t1, dt)
for i, lab in enumerate(self.integ.labels()):
print "%2d %s" % (i, lab)
return self.t, self.y
def lin(self, qm0=None, spin=10.0):
# reset
self.system.q[:] = 0.0
self.system.qd[:] = 0.0
# initial conditions
if qm0 is not None: # initial modal amplitudes
self.system.q[self.blade1.istrain] = qm0
self.system.q[self.blade2.istrain] = qm0
self.system.q[self.blade3.istrain] = qm0
else:
qm0 = np.zeros(self.blade1._nstrain * 3)
self.system.prescribe(self.bearing, vel=spin, acc=0.0)
self.system.qd[self.bearing.istrain][0] = spin
linsys = linearisation.LinearisedSystem(self.system, qm0)
return linsys
def ani(self, t=None, y=None, planview=True):
if t is None: t = self.t
if y is None: y = self.y
l = 40
if planview:
return dynvis.anim(self.system, t, y, (1, 2), (-l, l), (-l, l))
else:
return dynvis.anim(self.system, t, y, (0, 1), (-l, l), (-5, 5))
def __init__(self, bladed_file, root_length=0):
# Load modes but use a simple flapped blade
print "Loading modes from '%s'..." % bladed_file
self.blade = Blade(bladed_file)
self.tower = Tower(bladed_file)
self.modes = self.blade.modal_rep()
# Calculate equivalent blade properties
I1 = self.modes.I0[0]
I2 = self.modes.J0[0, 0]
print I1, I2
wflap = self.modes.freqs[0]
bmass = self.modes.mass
inertia = self.modes.inertia_tensor(np.zeros(len(self.modes.freqs)))
Xc = [I1 / bmass, 0, 0]
kflap = I2 * wflap**2
Ry = rotmat_y(-pi / 2)
Rhb1 = rotmat_x(0 * 2 * pi / 3)
Rhb2 = rotmat_x(1 * 2 * pi / 3)
Rhb3 = rotmat_x(2 * 2 * pi / 3)
self.base = FreeJoint('base')
self.towerlink = RigidConnection('tower', [0, 0, self.tower.hubheight])
self.bearing = Hinge('bearing', [1, 0, 0])
root1 = RigidConnection('root1', root_length * np.dot(Rhb1, [0, 0, 1]),
dot(Rhb1, Ry))
root2 = RigidConnection('root2', root_length * np.dot(Rhb2, [0, 0, 1]),
dot(Rhb2, Ry))
root3 = RigidConnection('root3', root_length * np.dot(Rhb3, [0, 0, 1]),
dot(Rhb3, Ry))
self.flap1 = Hinge('flap1', [0, 1, 0])
self.flap2 = Hinge('flap2', [0, 1, 0])
self.flap3 = Hinge('flap3', [0, 1, 0])
self.blade1 = RigidBody('blade1', bmass, inertia, Xc)
self.blade2 = RigidBody('blade2', bmass, inertia, Xc)
self.blade3 = RigidBody('blade3', bmass, inertia, Xc)
self.flap1.stiffness = self.flap2.stiffness = self.flap3.stiffness = kflap
self.base.add_leaf(self.towerlink)
self.towerlink.add_leaf(self.bearing)
self.bearing.add_leaf(root1)
self.bearing.add_leaf(root2)
self.bearing.add_leaf(root3)
root1.add_leaf(self.flap1)
root2.add_leaf(self.flap2)
root3.add_leaf(self.flap3)
self.flap1.add_leaf(self.blade1)
self.flap2.add_leaf(self.blade2)
self.flap3.add_leaf(self.blade3)
self.system = System(self.base)
# Prescribed DOF accelerations - constant rotor speed
self.base_motion = None
self.base_motion_amp = 0
self.system.prescribe(self.bearing, vel=0)
self.system.prescribe(self.base, vel=0)
# setup integrator
self.integ = Integrator(self.system, ('pos', 'vel', 'acc'))
self.integ.add_output(dynamics.LoadOutput(self.base.iprox))
self.integ.add_output(dynamics.LoadOutput(self.towerlink.iprox))
self.integ.add_output(
dynamics.LoadOutput(self.bearing.iprox, local=True))
self.integ.add_output(
dynamics.LoadOutput(self.bearing.idist[0], local=True))
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(dynamics.LoadOutput(b.iprox, local=True))
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(
dynamics.NodeOutput(b.iprox, local=True, deriv=2))
class Gyroscope(object):
def __init__(self, length, radius, mass, endmass):
self.length = length
self.radius = radius
self.mass = mass
self.endmass = endmass
Jz = radius**2 / 2
Jxy = (3 * radius**2 + length**2) / 12
inertia = mass * np.diag([Jxy, Jxy, Jz])
self.A = mass * Jxy + endmass * (length / 2)**2
self.C = mass * Jz
self.pivot = Hinge('pivot', [0, 1, 0])
self.axis = Hinge('axis', [0, 0, 1])
self.body = RigidBody('body', mass, inertia)
self.offset = RigidConnection('offset', [0, 0, length / 2])
self.endbody = RigidBody('end', endmass)
self.pivot.add_leaf(self.axis)
self.axis.add_leaf(self.body)
self.pivot.add_leaf(self.offset)
self.offset.add_leaf(self.endbody)
self.system = System(self.pivot)
# Prescribed DOF accelerations
self.system.prescribe(self.axis, acc=0.0) # constant rotational speed
def applied_torque(self, s):
# applied torque about y axis, Q2
elevation = s.q[self.pivot.istrain][0]
return self.endmass * dynamics.gravity * self.length / 2 * np.sin(
elevation)
def thetadotdot(self, s):
# acceleration about y axis, thetadotdot
Q2 = self.applied_torque(s)
return Q2 / self.A
def gyro_torque(self, s):
# gyroscopic sideways torque, Q1
spin = s.qd[self.axis.istrain][0] # spin speed
thetadot = s.qd[self.pivot.istrain][0]
return self.C * spin * thetadot
def simulate(self, xpivot=0.0, spin=10.0, t1=1.5, dt=0.01):
# reset
self.system.q[:] = 0.0
self.system.qd[:] = 0.0
# initial conditions
self.system.q[self.pivot.istrain][0] = xpivot # initial elevation
self.system.qd[self.axis.istrain][0] = spin # initial rotation speed
# setup integrator
#self.integ = Integrator(self.system, ('pos','vel','acc'))
self.integ = Integrator(self.system, ())
for istrain in (self.pivot.istrain, self.axis.istrain):
self.integ.add_output(dynamics.StrainOutput(istrain, deriv=0))
self.integ.add_output(dynamics.StrainOutput(istrain, deriv=1))
self.integ.add_output(dynamics.StrainOutput(istrain, deriv=2))
self.integ.add_output(dynamics.LoadOutput(self.pivot.idist[0]))
self.integ.add_output(
dynamics.LoadOutput(self.pivot.idist[0], local=True))
self.integ.add_output(dynamics.LoadOutput(self.body.iprox))
self.integ.add_output(dynamics.LoadOutput(self.endbody.iprox))
self.integ.add_output(dynamics.CustomOutput(self.applied_torque, "Q2"))
self.integ.add_output(
dynamics.CustomOutput(self.thetadotdot, "thetadotdot"))
self.integ.add_output(dynamics.CustomOutput(self.gyro_torque, "Q1"))
# simulate
if t1 > 0:
self.t, self.y = self.integ.integrate(t1, dt)
def ani(self, vs=1):
l = self.length * 1.1
return dynvis.anim(self.system,
self.t,
self.y, (0, vs), (-l, l), (-l, l),
velocities=False,
only_free=True)
def __init__(self, bladed_file, root_length=0, rigid=False):
# Modal element using data from Bladed model
print "Loading modes from '%s'..." % bladed_file
self.blade = Blade(bladed_file)
self.tower = Tower(bladed_file)
self.modes = self.blade.modal_rep()
Ry = rotmat_y(-pi / 2)
Rhb1 = rotmat_x(0 * 2 * pi / 3)
Rhb2 = rotmat_x(1 * 2 * pi / 3)
Rhb3 = rotmat_x(2 * 2 * pi / 3)
self.base = FreeJoint('base')
self.towerlink = RigidConnection('tower', [0, 0, self.tower.hubheight])
self.bearing = Hinge('bearing', [1, 0, 0])
root1 = RigidConnection('root1', root_length * np.dot(Rhb1, [0, 0, 1]),
dot(Rhb1, Ry))
root2 = RigidConnection('root2', root_length * np.dot(Rhb2, [0, 0, 1]),
dot(Rhb2, Ry))
root3 = RigidConnection('root3', root_length * np.dot(Rhb3, [0, 0, 1]),
dot(Rhb3, Ry))
self.blade1 = ModalElement('blade1', self.modes)
self.blade2 = ModalElement('blade2', self.modes)
self.blade3 = ModalElement('blade3', self.modes)
self.base.add_leaf(self.towerlink)
self.towerlink.add_leaf(self.bearing)
self.bearing.add_leaf(root1)
self.bearing.add_leaf(root2)
self.bearing.add_leaf(root3)
root1.add_leaf(self.blade1)
root2.add_leaf(self.blade2)
root3.add_leaf(self.blade3)
self.system = System(self.base)
# Prescribed DOF accelerations - constant rotor speed
self.base_motion = None
self.base_motion_amp = 0
self.system.prescribe(self.bearing, vel=0)
self.system.prescribe(self.base, vel=0)
if rigid:
for b in (self.blade1, self.blade2, self.blade3):
self.system.prescribe(b, vel=0)
# setup integrator
self.integ = Integrator(self.system, ('pos', 'vel', 'acc'))
self.integ.add_output(dynamics.LoadOutput(self.base.iprox))
self.integ.add_output(dynamics.LoadOutput(self.towerlink.iprox))
self.integ.add_output(
dynamics.LoadOutput(self.bearing.iprox, local=True))
self.integ.add_output(
dynamics.LoadOutput(self.bearing.idist[0], local=True))
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(dynamics.LoadOutput(b.iprox, local=True))
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(b.output_deflections())
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(b.output_positions())
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(
dynamics.NodeOutput(b.iprox, local=True, deriv=2))
class Rotor(object):
def __init__(self, mode_source_file, root_length=0):
# Modal element using data from Bladed model
print "Loading modes from '%s'..." % mode_source_file
self.modes = ModalRepresentation.from_Bladed(mode_source_file)
Ry = rotmat_y(-pi/2)
Rhb1 = rotmat_x(0 * 2*pi/3)
Rhb2 = rotmat_x(1 * 2*pi/3)
Rhb3 = rotmat_x(2 * 2*pi/3)
self.bearing = Hinge('bearing', [1,0,0])
root1 = RigidConnection('root1', root_length*np.dot(Rhb1,[0,0,1]), dot(Rhb1,Ry))
root2 = RigidConnection('root2', root_length*np.dot(Rhb2,[0,0,1]), dot(Rhb2,Ry))
root3 = RigidConnection('root3', root_length*np.dot(Rhb3,[0,0,1]), dot(Rhb3,Ry))
self.blade1 = ModalElement('blade1', self.modes)
self.blade2 = ModalElement('blade2', self.modes)
self.blade3 = ModalElement('blade3', self.modes)
self.bearing.add_leaf(root1)
self.bearing.add_leaf(root2)
self.bearing.add_leaf(root3)
root1.add_leaf(self.blade1)
root2.add_leaf(self.blade2)
root3.add_leaf(self.blade3)
self.system = System(self.bearing)
# Prescribed DOF accelerations - constant rotor speed
self.system.prescribe(self.bearing.istrain, vel=0.0, acc=0.0)
# setup integrator
self.integ = Integrator(self.system, ('pos','vel'))
self.integ.add_output(dynamics.LoadOutput(self.bearing.iprox))
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(dynamics.LoadOutput(b.iprox, local=True))
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(dynamics.CustomOutput(
lambda s: b.station_positions()[-1], label="{} tip defl".format(b)))
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(dynamics.CustomOutput(
lambda s: dot(b.Rp, b.station_positions()[-1]), label="{} tip pos".format(b)))
def simulate(self, qm0=None, spin=10.0, t1=1.5, dt=0.01):
# reset
self.system.q [:] = 0.0
self.system.qd[:] = 0.0
# initial conditions
if qm0 is not None: # initial modal amplitudes
self.system.q[self.blade1.istrain] = qm0
self.system.q[self.blade2.istrain] = qm0
self.system.q[self.blade3.istrain] = qm0
self.system.prescribe(self.bearing.istrain, vel=spin, acc=0.0)
# simulate
self.t,self.y = self.integ.integrate(t1, dt)
return self.t, self.y
def lin(self, qm0=None, spin=10.0):
# reset
self.system.q [:] = 0.0
self.system.qd[:] = 0.0
# initial conditions
if qm0 is not None: # initial modal amplitudes
self.system.q[self.blade1.istrain] = qm0
self.system.q[self.blade2.istrain] = qm0
self.system.q[self.blade3.istrain] = qm0
else:
qm0 = np.zeros(self.blade1._nstrain * 3)
self.system.prescribe(self.bearing.istrain, vel=spin, acc=0.0)
linsys = linearisation.LinearisedSystem(self.system, qm0)
return linsys
def ani(self, vs=1):
l = 40
return dynvis.anim(self.system, self.t, self.y, (0,vs), (-l,l), (-l,l))
class Turbine(object):
def __init__(self, bladed_file, root_length=0, rigid=False):
# Modal element using data from Bladed model
print "Loading modes from '%s'..." % bladed_file
self.blade = Blade(bladed_file)
self.tower = Tower(bladed_file)
self.modes = self.blade.modal_rep()
Ry = rotmat_y(-pi / 2)
Rhb1 = rotmat_x(0 * 2 * pi / 3)
Rhb2 = rotmat_x(1 * 2 * pi / 3)
Rhb3 = rotmat_x(2 * 2 * pi / 3)
self.base = FreeJoint('base')
self.towerlink = RigidConnection('tower', [0, 0, self.tower.hubheight])
self.bearing = Hinge('bearing', [1, 0, 0])
root1 = RigidConnection('root1', root_length * np.dot(Rhb1, [0, 0, 1]),
dot(Rhb1, Ry))
root2 = RigidConnection('root2', root_length * np.dot(Rhb2, [0, 0, 1]),
dot(Rhb2, Ry))
root3 = RigidConnection('root3', root_length * np.dot(Rhb3, [0, 0, 1]),
dot(Rhb3, Ry))
self.blade1 = ModalElement('blade1', self.modes)
self.blade2 = ModalElement('blade2', self.modes)
self.blade3 = ModalElement('blade3', self.modes)
self.base.add_leaf(self.towerlink)
self.towerlink.add_leaf(self.bearing)
self.bearing.add_leaf(root1)
self.bearing.add_leaf(root2)
self.bearing.add_leaf(root3)
root1.add_leaf(self.blade1)
root2.add_leaf(self.blade2)
root3.add_leaf(self.blade3)
self.system = System(self.base)
# Prescribed DOF accelerations - constant rotor speed
self.base_motion = None
self.base_motion_amp = 0
self.system.prescribe(self.bearing, vel=0)
self.system.prescribe(self.base, vel=0)
if rigid:
for b in (self.blade1, self.blade2, self.blade3):
self.system.prescribe(b, vel=0)
# setup integrator
self.integ = Integrator(self.system, ('pos', 'vel', 'acc'))
self.integ.add_output(dynamics.LoadOutput(self.base.iprox))
self.integ.add_output(dynamics.LoadOutput(self.towerlink.iprox))
self.integ.add_output(
dynamics.LoadOutput(self.bearing.iprox, local=True))
self.integ.add_output(
dynamics.LoadOutput(self.bearing.idist[0], local=True))
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(dynamics.LoadOutput(b.iprox, local=True))
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(b.output_deflections())
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(b.output_positions())
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(
dynamics.NodeOutput(b.iprox, local=True, deriv=2))
def set_base_motion(self, dof, w, amp):
self.base_motion = dof
self.base_motion_amp = amp
self.system.prescribe(self.base,
part=dof,
vel=lambda t: -w * amp * np.sin(w * t),
acc=lambda t: -w**2 * amp * np.cos(w * t))
def set_initial_conditions(self, qm0=None, az0=None, rotor_speed=None):
# initial conditions
if qm0 is not None: # initial modal amplitudes
self.system.q[self.blade1.istrain] = qm0
self.system.q[self.blade2.istrain] = qm0
self.system.q[self.blade3.istrain] = qm0
if az0 is not None:
self.system.q[self.bearing.istrain][0] = az0
if self.base_motion is not None:
self.system.q[self.base.istrain][
self.base_motion] = self.base_motion_amp
if rotor_speed is not None:
self.system.prescribe(self.bearing, vel=rotor_speed)
def simulate(self,
qm0=None,
az0=0.0,
rotor_speed=10.0,
t1=None,
dt=0.01,
t0=0.0,
init=False):
# reset
self.system.q[:] = 0.0
self.system.qd[:] = 0.0
self.set_initial_conditions(qm0, az0, rotor_speed)
if t1 is None:
t1 = 4 * pi / rotor_speed if (rotor_speed != 0.0) else 2
if init:
self.system.find_equilibrium()
# simulate
t, y = self.integ.integrate(t1, dt, t0)
#for i,lab in enumerate(self.integ.labels):
# print "%2d %s" % (i,lab)
#return self.t, self.y
# Build results structure
results = TurbineResults(t, y, self.modes.mode_names)
return results
def lin(self, qm0=None, az0=None, rotor_speed=None, init=False):
# reset
self.system.q[:] = 0.0
self.system.qd[:] = 0.0
self.set_initial_conditions(qm0, az0, rotor_speed)
if init:
self.system.find_equilibrium()
# need initial amplitudes for linearisation point
if qm0 is None:
qm0 = self.system.q[self.blade1.istrain]
linsys = linearisation.LinearisedSystem(self.system, np.tile(qm0, 3))
return linsys
def ani(self, results, x=0, y=1):
H = self.tower.hubheight + self.blade.radii[-1]
limits = [(-H, H), (-H, H), (-5, H + 5)]
return dynvis.anim(self.system, results.t, results.strains.as_matrix(),
(x, y), limits[x], limits[y])
class Rotor(object):
def __init__(self, mode_source_file, root_length=0):
# Modal element using data from Bladed model
print "Loading modes from '%s'..." % mode_source_file
self.modes = ModalRepresentation.from_Bladed(mode_source_file)
Ry = rotmat_y(-pi / 2)
Rhb1 = rotmat_x(0 * 2 * pi / 3)
Rhb2 = rotmat_x(1 * 2 * pi / 3)
Rhb3 = rotmat_x(2 * 2 * pi / 3)
self.bearing = Hinge('bearing', [1, 0, 0])
root1 = RigidConnection('root1', root_length * np.dot(Rhb1, [0, 0, 1]),
dot(Rhb1, Ry))
root2 = RigidConnection('root2', root_length * np.dot(Rhb2, [0, 0, 1]),
dot(Rhb2, Ry))
root3 = RigidConnection('root3', root_length * np.dot(Rhb3, [0, 0, 1]),
dot(Rhb3, Ry))
self.blade1 = ModalElement('blade1', self.modes)
self.blade2 = ModalElement('blade2', self.modes)
self.blade3 = ModalElement('blade3', self.modes)
self.bearing.add_leaf(root1)
self.bearing.add_leaf(root2)
self.bearing.add_leaf(root3)
root1.add_leaf(self.blade1)
root2.add_leaf(self.blade2)
root3.add_leaf(self.blade3)
self.system = System(self.bearing)
# Prescribed DOF accelerations - constant rotor speed
self.system.prescribe(self.bearing.istrain, vel=0.0, acc=0.0)
# setup integrator
self.integ = Integrator(self.system, ('pos', 'vel'))
self.integ.add_output(dynamics.LoadOutput(self.bearing.iprox))
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(dynamics.LoadOutput(b.iprox, local=True))
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(
dynamics.CustomOutput(lambda s: b.station_positions()[-1],
label="{} tip defl".format(b)))
for b in (self.blade1, self.blade2, self.blade3):
self.integ.add_output(
dynamics.CustomOutput(lambda s: dot(b.Rp,
b.station_positions()[-1]),
label="{} tip pos".format(b)))
def simulate(self, qm0=None, spin=10.0, t1=1.5, dt=0.01):
# reset
self.system.q[:] = 0.0
self.system.qd[:] = 0.0
# initial conditions
if qm0 is not None: # initial modal amplitudes
self.system.q[self.blade1.istrain] = qm0
self.system.q[self.blade2.istrain] = qm0
self.system.q[self.blade3.istrain] = qm0
self.system.prescribe(self.bearing.istrain, vel=spin, acc=0.0)
# simulate
self.t, self.y = self.integ.integrate(t1, dt)
return self.t, self.y
def lin(self, qm0=None, spin=10.0):
# reset
self.system.q[:] = 0.0
self.system.qd[:] = 0.0
# initial conditions
if qm0 is not None: # initial modal amplitudes
self.system.q[self.blade1.istrain] = qm0
self.system.q[self.blade2.istrain] = qm0
self.system.q[self.blade3.istrain] = qm0
else:
qm0 = np.zeros(self.blade1._nstrain * 3)
self.system.prescribe(self.bearing.istrain, vel=spin, acc=0.0)
linsys = linearisation.LinearisedSystem(self.system, qm0)
return linsys
def ani(self, vs=1):
l = 40
return dynvis.anim(self.system, self.t, self.y, (0, vs), (-l, l),
(-l, l))