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, 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, 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 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, 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, 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 __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, 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, 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, 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))
#loading = PointLoading(blade, wind_table, None) thrust_time = [0, 1, 2, 10] thrust_force = [0, 0, 10e3, 10e3] thrust = np.c_[thrust_force, np.zeros((4, 2))].T loadfunc = scipy.interpolate.interp1d(thrust_time, thrust) # Modal element base = RigidConnection('base', rotation=rotmat_y(-np.pi / 2)) el = ModalElement('el', modes, distal=True, damping_freqs=[8.269, 10.248]) rna = RigidBody('rna', 24000, np.diag([6400003, 6400003, 4266667]), nodal_load=loadfunc) base.add_leaf(el) el.add_leaf(rna) system = System(base) integ = Integrator(system) integ.add_output(el.output_deflections()) integ.add_output(el.output_rotations()) integ.add_output(dynamics.LoadOutput(rna.iprox)) linsys = LinearisedSystem(system) def ani_xy(s, t, y): return dynvis.anim(s, t, y, (0, 1), (-5, 45), (-5, 5), velocities=False) def ani_xz(s, t, y): return dynvis.anim(s, t, y, (0, 2), (-5, 45), (-5, 5), velocities=False)
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 yaw_time2 = 6.0 dvyaw = 10 * np.pi / 180 system.prescribe(yaw.istrain, acc=lambda t: (t>=yaw_time1 and t<(yaw_time1+acc_period)) and dvyaw/acc_period or 0 +\ (t>yaw_time2 and t<=(yaw_time2+acc_period)) and -dvyaw/acc_period or 0) system.find_equilibrium()
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) hb1.add_leaf(b1) hb2.add_leaf(b2) hb3.add_leaf(b3) system = System(foundation) def thrust(xp, xd, xstrain, vp, vd, vstrain): f = zeros(NQD * 2) f[6] = -70000 return f def test1(): # Initial conditions system.qd[bearing.istrain[0]] = -10 * pi/180 # Prescribed DOFs #system.prescribe(foundation.istrain, 0.0) system.prescribe(tower.istrain, 0.0) system.prescribe(bearing.istrain, 0.0) system.prescribe(b1.istrain, 0.0)
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))
import numpy as np from scipy.linalg import eig import matplotlib.pyplot as plt import dynamics from dynamics import System, ModalElement, solve_system from linearisation import LinearisedSystem, ModalRepresentation import dynvis dynamics.gravity = 0 # Modal element using data from Bladed model print "Loading modes from 'demo_a.prj'..." modes = ModalRepresentation.from_Bladed('demo_a_simplified.prj') el = ModalElement('el', modes) system = System(el) # Linearise system and find modes - should match with original print "Linearising..." linsys = LinearisedSystem(system) w, v = eig(linsys.K, linsys.M) order = np.argsort(w) w = np.sqrt(np.real(w[order])) f = w / 2 / np.pi v = v[:, order] # Check that modes come out matching what went in assert np.allclose(modes.freqs, w), "Linearised freqs should match" ventries = np.nonzero(abs(v) > 1e-2)[0] assert len(ventries) == len(w) and (ventries == np.arange(4)).all(), \ "Modes should be orthogonal"
# Options dynamics.OPT_GRAVITY = True dynamics.OPT_GEOMETRIC_STIFFNESS = False # Create model bladed_file = r'C:\Users\Rick Lupton\Dropbox\phd\Bladed\Models\OC3-Hywind_SparBuoy_NREL5MW.prj' print "Loading modes from '%s'..." % bladed_file towerdef = Tower(bladed_file) modes = towerdef.modal_rep() endmass = 100000 endinertia = 100 el1 = ModalElement('el', modes, distal=False) system1 = System(el1) el2 = ModalElement('el', modes, distal=True) body = RigidBody('body', endmass, inertia=endinertia * np.eye(3)) el2.add_leaf(body) system2 = System(el2) integ1 = Integrator(system1) integ1.add_output(el1.output_positions()) integ2 = Integrator(system2, outputs=('pos', 'vel', 'acc')) integ2.add_output(el2.output_positions()) integ2.add_output(dynamics.NodeOutput(body.iprox)) integ2.add_output(dynamics.NodeOutput(body.iprox, deriv=2)) integ2.add_output(dynamics.LoadOutput(body.iprox)) integ2.add_output(dynamics.StrainOutput(el2.imult))
modes = ModalRepresentation.from_Bladed(path_damped+'.$pj') print "Loading modes from '%s'..." % path_undamped modes0 = ModalRepresentation.from_Bladed(path_undamped+'.$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) # Modal element el = ModalElement('el', modes, loading) system = System(el) el0 = ModalElement('el0', modes0, loading) system0 = System(el0) integ = Integrator(system) integ0 = Integrator(system0) integ.add_output(el.output_positions(stations=[16,32])) integ0.add_output(el0.output_positions(stations=[16,32])) #def simulate(system, t1=2.0, dt=0.005): # Load Bladed data for comparison import pybladed.data brun = pybladed.data.BladedRun(path_damped) bladed_defl = np.c_[ brun.get('blade 1 x-deflection;2'),
some demographic stuff demo = initial total population of each node tot_pop total population of the graph then the dynamical system is initialized with the varaible F avg_population will be used in the evolution as an "escape parameter" in the markov process see dynamics.py """ demo = np.sum(Z0, 1).astype(int) tot_pop = np.sum(demo) avg_pop = tot_pop / communities print("Total initial populaiton: ", tot_pop) F = System(Z0) print(" ========= NET =========") """ this section builds the network matrix containing the weights they are initialized randomly with uniform distribution and then normalized in the tranport.py file in order to build the transport process network is a sparse scipy matrix, the networkx stuff is just for visualization see mat.py """ #network = random_network(communities,6000) network = scale_free_network(communities) G = nx.Graph(network)