def setUp(self):
cout.cout_wrap.initialise(False, False)
A = scio.loadmat(TestKrylov.test_dir + '/src/' + 'A.mat')
B = scio.loadmat(TestKrylov.test_dir + '/src/' + 'B.mat')
C = scio.loadmat(TestKrylov.test_dir + '/src/' + 'C.mat')
A = libsp.csc_matrix(A['A'])
B = B['B']
C = C['C']
D = np.zeros((B.shape[1], C.shape[0]))
A = A.todense()
self.ss = libss.ss(A, B, C, D)
self.rom = krylov.Krylov()
if not os.path.exists(self.test_dir + '/figs/'):
os.makedirs(self.test_dir + '/figs/')
# # Assemble UVLM
uvlm.assemble_ss()
# # Scale UVLM
# t_uvlm_scale0 = time.time()
# print('Scaling UVLM...')
# uvlm.nondimss()
# length_ref = uvlm.ScalingFacts['length']
# speed_ref = uvlm.ScalingFacts['speed']
# force_ref = uvlm.ScalingFacts['force']
# time_ref = uvlm.ScalingFacts['time']
# t_uvlm_scale = time.time() - t_uvlm_scale0
# print('...UVLM Scaling complete in %.2f s' % t_uvlm_scale)
# UVLM remove gust input - gusts not required in analysis
uvlm.SS.B = libsp.csc_matrix(
aeroelastic_system.linuvlm.SS.B[:, :6 * aeroelastic_system.linuvlm.Kzeta])
uvlm.SS.D = libsp.csc_matrix(
aeroelastic_system.linuvlm.SS.D[:, :6 * aeroelastic_system.linuvlm.Kzeta])
#
# UVLM projection onto modes
print('Projecting UVLM onto modes')
gain_input = libsp.dot(
gain_struct_2_aero,
sclalg.block_diag(beam.U[:, :beam.Nmodes], beam.U[:, :beam.Nmodes]))
gain_output = libsp.dot(beam.U[:, :beam.Nmodes].T, gain_aero_2_struct)
uvlm.SS.addGain(gain_input, where='in')
uvlm.SS.addGain(gain_output, where='out')
print('...complete')
# # Krylov MOR
# rom = krylovrom.KrylovReducedOrderModel()
dt = ws.dt
tsaero.rho = ws.rho
scaling_factors = {
'length': 1, #0.5*ws.c_ref,
'speed': 1, #u_inf,
'density': 1
} #ws.rho}
# Linearise UVLM
aeroelastic_system = linaeroela.LinAeroEla(data)
uvlm = aeroelastic_system.linuvlm
uvlm.assemble_ss()
aeroelastic_system.get_gebm2uvlm_gains()
# Remove lattice coordinates and velocities from the inputs to the system
uvlm.SS.B = libsp.csc_matrix(uvlm.SS.B[:, -uvlm.Kzeta:])
uvlm.SS.D = libsp.csc_matrix(uvlm.SS.D[:, -uvlm.Kzeta:])
# Create system to transmit a vertical gust across the chord in time
A_gust = np.zeros((M + 1, M + 1))
A_gust[1:, :-1] = np.eye(M)
B_gust = np.zeros((M + 1, 1))
B_gust[0] = 1
C_gust = np.eye(M + 1)
D_gust = np.zeros((C_gust.shape[0], 1))
print(D_gust.shape)
if use_sparse:
A_gust = libsp.csc_matrix(A_gust)
B_gust = libsp.csc_matrix(B_gust)
C_gust = libsp.csc_matrix(C_gust)
D_gust = libsp.csc_matrix(D_gust)
Sol.linuvlm.assemble_ss()
# scale
print('Scaling of UVLM eq.s started...')
Sol.linuvlm.nondimss()
Lref0=Sol.linuvlm.ScalingFacts['length']
Uref0=Sol.linuvlm.ScalingFacts['speed']
Fref0=Sol.linuvlm.ScalingFacts['force']
tref0=Sol.linuvlm.ScalingFacts['time']
print('\t\tdone in %.2f sec' %Sol.linuvlm.cpu_summary['nondim'])
# remove gust input
print('removing gust input started...')
t0=time.time()
Sol.linuvlm.SS.B=libsp.csc_matrix(Sol.linuvlm.SS.B[:,:6*Sol.linuvlm.Kzeta])
Sol.linuvlm.SS.D=Sol.linuvlm.SS.D[:,:6*Sol.linuvlm.Kzeta]
print('\t\tdone in %.2f sec' %(time.time()-t0))
# project
print('projection of UVLM eq.s started...')
t0=time.time()
Kin =libsp.dot(Kas, sc.linalg.block_diag(gebm.U[:,:gebm.Nmodes],
gebm.U[:,:gebm.Nmodes]))
Kout=libsp.dot(gebm.U[:,:gebm.Nmodes].T,Ksa)
Sol.linuvlm.SS.addGain(Kin, where='in')
Sol.linuvlm.SS.addGain(Kout, where='out')
print('\t\tdone in %.2f sec' %(time.time()-t0))
Kin,Kout=None,None
Kas,Ksa=None,None
import scipy.signal as sig
# Load matrices
A = scio.loadmat('A.mat')
B = scio.loadmat('B.mat')
C = scio.loadmat('C.mat')
A = A['A']
B = B['B']
C = C['C']
D = np.zeros((B.shape[1], C.shape[0]))
# Convert A to dense
As = sc.sparse.csc_matrix(A)
Ad = As.todense()
A = libsp.csc_matrix(As)
# Assemble continuous time system
fom_ss = libss.ss(A, B, C, D)
fom_sc = sig.lti(Ad, B, C, D)
# Compare frequency response
wv = np.logspace(-1, 3, 1000)
wvsc, mag_fom_sc, ph_fom_sc = fom_sc.bode(wv)
Y_fom_ss = fom_ss.freqresp(wv)[0, 0, :]
mag_fom_ss = 20 * np.log10(np.abs(Y_fom_ss))
ph_fom_ss = np.angle(Y_fom_ss) * 180 / np.pi
print(np.max(np.abs(mag_fom_sc - mag_fom_ss)))
# Build rom