def q2():
lm = np.linspace(Ma[0], Ma[1])
n = len(lm)
for i, ms_i in enumerate(ms):
for j, km_i in enumerate(km):
PLANE.set_mass_and_static_margin(km_i, ms_i)
F0 = np.zeros(n)
F1 = np.zeros(n)
for k, m_i in enumerate(lm):
va0 = dynamic.va_of_mach(m_i, h[0])
va1 = dynamic.va_of_mach(m_i, h[1])
X0, U0 = dynamic.trim(PLANE, {'va': va0, 'h': h[0]})
X1, U1 = dynamic.trim(PLANE, {'va': va1, 'h': h[1]})
F0[k] = dynamic.propulsion_model(X0, U0, PLANE)
F1[k] = dynamic.propulsion_model(X1, U1, PLANE)
plt.subplot(2, 2, i + 2 * j + 1)
plt.plot(lm, F0, label="$h={}$".format(h[0]))
plt.plot(lm, F1, label="$h={}$".format(h[1]))
plt.legend()
plt.title("$m_s={}, k_m={}$".format(ms_i, km_i))
plt.xlabel("$M_a$")
plt.ylabel("$F$")
plt.tight_layout(.5)
plt.savefig(file + "q2" + format)
plt.show()
def etat_lin4(h_tuple, mac_tuple, km_tuple, ms_tuple):
'''
calcule les repr d'état linéarisées A et B
:param h_tuple: tuple contenant le altitudes
:param mac_tuple:
:param km_tuple:
:param ms_tuple:
:return:
'''
dico_etat = {} # dico pour stocker les 16 états associés au 16 pts de trim
dico_etat_lin = {}
dico_etat_lin4 = {}
for i, km in enumerate(km_tuple):
for j, ms in enumerate(ms_tuple):
P.set_mass_and_static_margin(km, ms)
for idx, mac in enumerate(mac_tuple):
dico = {} # dico = args dans la fonction trim
for h in h_tuple:
dico['h'] = h
dico['va'] = dy.va_of_mach(mac, h) # conv mach en m/s
# calcul des points de trim associés aux 4 valeurs h, mac, km et ms
# et ajout dans le tuple etat
etat = (X, U) = dy.trim(P, dico)
etat_lin = (A, B) = ut.num_jacobian(X, U, P, dy.dyn)
A4 = np.copy(A[2:, 2:])
B4 = np.copy(B[2:])
etat_lin4 = (A4, B4)
# construction du tuple (h,mac,km,ms) qui jouera le role de clé du dico states
pt_trim = (h, mac, km, ms)
dico_etat[pt_trim] = etat
dico_etat_lin[pt_trim] = etat_lin
dico_etat_lin4[pt_trim] = etat_lin4
return dico_etat_lin4
def get_linearized_model(aicraft, h, Ma, sm, km):
aircraft.set_mass_and_static_margin(km, sm)
va = dyn.va_of_mach(Ma, h)
Xe, Ue = dyn.trim(aircraft, {'va':va, 'h':h, 'gamma':0})
A, B = ut.num_jacobian(Xe, Ue, aicraft, dyn.dyn)
poles, vect_p = np.linalg.eig(A[dyn.s_va:, dyn.s_va:])
return A, B, poles, vect_p
def function_transfere(aircraft, point_trim):
alt, Ma, sm, km = point_trim
aircraft.set_mass_and_static_margin(km, sm)
va = dyn.va_of_mach(Ma, alt)
xtrim, utrim = dyn.trim(aircraft, {'va': va, 'gamm': 0, 'h': alt})
A, B = utils.num_jacobian(xtrim, utrim, aircraft, dyn.dyn)
A_4, B_4 = A[2:,2:], B[2:,:2][:,0].reshape((4,1))
C_4 = np.zeros((1,4))
C_4[0][2] = 1
Acc_4 = np.zeros((4, 4))
Bcc_4 = np.zeros((4, 1))
Bcc_4[3,0] = 1
valeursp, M = np.linalg.eig(A_4)
coeff = np.poly(valeursp)
for i in range(3):
Acc_4[i,i+1] = 1
Acc_4[3,3-i] = -coeff[i+1]
Acc_4[3,0] = -coeff[4]
Qccc = np.zeros((4, 4))
Q = np.zeros((4, 4))
for i in range(4):
Qccc[:,i:i+1] = np.dot(np.linalg.matrix_power(Acc_4, i), Bcc_4)
Q[:,i:i+1] = np.dot(np.linalg.matrix_power(A_4, i), B_4)
Mcc = np.dot(Q, np.linalg.inv(Qccc))
Ccc_4 = np.dot(C_4, Mcc)
num = list(Ccc_4)
num.reverse()
den = list(-Acc_4[3, :])
den.append(1.)
den.reverse()
return num, den, valeursp
def val_propre(n):
vp = np.zeros((n, n, n, n, 4), dtype=complex)
lh = np.linspace(h[0], h[1], n)
lMa = np.linspace(Ma[0], Ma[1], n)
lms = np.linspace(ms[0], ms[1], n)
lkm = np.linspace(km[0], km[1], n)
for i, h_i in enumerate(lh):
for j, Ma_j in enumerate(lMa):
for k, ms_k in enumerate(lms):
for l, km_l in enumerate(lkm):
PLANE.set_mass_and_static_margin(km_l, ms_k)
params = {
'va': dynamic.va_of_mach(Ma_j, h_i),
'h': h_i,
'gamma': 0
}
X, U = dynamic.trim(PLANE, params)
A, B = dynamic.ut.num_jacobian(X, U, PLANE,
dynamic.dyn)
A_4 = A[2:, 2:]
liste_vp = np.linalg.eigvals(A_4)
for m, ev in enumerate(liste_vp):
vp[i][j][k][l][m] = ev
#print(A_4)
#print(np.linalg.eigvals(A_4))
return vp
def get_trim(aircraft, h, Ma, sm, km):
'''
Calcul du trim pour un point de vol
'''
aircraft.set_mass_and_static_margin(km, sm)
va = dyn.va_of_mach(Ma, h)
Xe, Ue = dyn.trim(aircraft, {'va':va, 'h':h, 'gamma':0})
return Xe, Ue
def trace(km, ms):
P.set_mass_and_static_margin(km, ms) # km masse avion, ms : marge statique
for idx, mac in enumerate(mac_tuple):
dico = {} # dico = args dans la fonction trim
alphas = [
] # liste avec alpha1 obtenu avec h1=3000m et alpha2 associé à h2
dphrs = []
dths = []
for h in h_tuple:
dico['h'] = h
dico['va'] = dy.va_of_mach(mac, h) # conv mach en m/s
X, U = dy.trim(P, dico)
# alphas += [ut.deg_of_rad(X[3])] # alpha en degrés
# dphrs += [ut.deg_of_rad(U[0])] # delta PHR en degrés
alphas += [X[3]] # alpha en radians
dphrs += [U[0]] # delta PHR en radians
dths += [U[1]] # thrust de 0 à 1
plt.title("ms = " + str(ms_tuple[0]) + " km = " + str(km_tuple[0]) +
" - " + P.name)
# plt.title(r"$\alpha$")
# grille 1x3 1 ligne 3 colonnes figure 1 : numérotation par ligne de gauche à droite
plt.subplot(1, 3, 1)
plt.plot(h_kilometre,
alphas,
marker=markeur[idx],
label="Mac = " + str(mac))
plt.plot(h_kilometre,
alphas,
marker=markeur[idx],
label="Mac = " + str(mac))
# plt.axis([abs_min, abs_max, 0., 20])
plt.title(r"$\alpha$")
# grille 1x3 figure 2
plt.subplot(1, 3, 2)
plt.subplots_adjust(wspace=0.4)
plt.title(r"$\delta$phr")
plt.plot(h_kilometre,
dphrs,
marker=markeur[idx],
label="Mac = " + str(mac))
# plt.axis([abs_min, abs_max, 0., 10])
# plt.legend(loc=3,prop={'size':7})
# plt.yticks(color='red')
plt.xlabel('Altitude en km - ms = ' + str(ms) +
" - coef. de masse km = " + str(km)) # , color='red')
# grille 1x3 figure 3
plt.subplot(1, 3, 3)
plt.title(r"$\delta$th")
plt.plot(h_kilometre,
dths,
marker=markeur[idx],
label="Mac = " + str(mac))
plt.legend(loc=1, prop={'size': 7})
plt.axis([abs_min, abs_max, 0., ord_max])
def get_linearized_model(aicraft, h, Ma, sm, km):
'''
Calcul numérique du modèle tangeant linéarisé pour un point de trim
'''
aircraft.set_mass_and_static_margin(km, sm)
Xe, Ue = dyn.trim(aircraft, {'va':dyn.va_of_mach(Ma, h), 'h':h, 'gamma':0})
A, B = ut.num_jacobian(Xe, Ue, aicraft, dyn.dyn)
poles, vect_p = np.linalg.eig(A[dyn.s_va:, dyn.s_va:])
return A, B, poles, vect_p
def nonLinearModel(aircraft, point_trim, wh, time):
alt, Ma, sm, km = point_trim
aircraft.set_mass_and_static_margin(km, sm)
va = dyn.va_of_mach(Ma, alt)
xtrim, uTrim = dyn.trim(aircraft, {'va':va, 'h':alt})
xtrim[dyn.s_a] = xtrim[dyn.s_a] + np.arctan(wh/xtrim[dyn.s_va])
X = scipy.integrate.odeint(dyn.dyn, xtrim, time, args=(uTrim, aircraft))
return X
def simu():
time = np.arange(0, 100, 0.1)
PLANE.set_mass_and_static_margin(km[1], Ma[1])
va = dynamic.va_of_mach(Ma[1], h[1])
Xtrim, Utrim = dynamic.trim(PLANE, {'va': va, 'h': h[1]})
x = integrate.odeint(dynamic.dyn, Xtrim, time, args=(Utrim, PLANE))
dynamic.plot(time, x)
plt.savefig(file + "simu" + format)
plt.show()
def plot_traj_trim(aircraft, h, Ma, sm, km):
'''
Affichage d'une trajectoire avec un point de trim comme condition initiale
'''
aircraft.set_mass_and_static_margin(km, sm)
va = dyn.va_of_mach(Ma, h)
Xe, Ue = dyn.trim(aircraft, {'va':va, 'h':h, 'gamma':0})
time = np.arange(0., 100, 0.5)
X = scipy.integrate.odeint(dyn.dyn, Xe, time, args=(Ue, aircraft))
dyn.plot(time, X)
def trajectoire(M, h, ms, km, P):
t = np.arange(0, 100, 0.5)
P.set_mass_and_static_margin(km, ms)
va = dyn.va_of_mach(M, h, k=1.4, Rs=287.05)
param = {'va': va, 'h': h, 'gamma': 0}
Xe, Ue = dyn.trim(P, param)
X = scipy.integrate.odeint(dyn.dyn, Xe, t, args=(Ue, P))
trace = dyn.plot(t, X)
plt.suptitle("Trajectoire de l'avion", fontsize=22)
plt.show()
def obtain_matrices(km, ms, M, h, P):
P.set_mass_and_static_margin(km, ms)
va = dyn.va_of_mach(M, h)
param = {'va': va, 'gamma': 0, 'h': h}
X, U = dyn.trim(P, param)
A, B = ut.num_jacobian(X, U, P, dyn.dyn)
print('\n \n A et B pour M={}, h={}, ms={} et km={}'.format(M, h, ms, km))
A2 = reduire(A)
print(np.linalg.eig(A2))
liste = np.linalg.eig(A2)[0]
trace_vpropres(liste, km, ms, M, h)
def controllability(aircraf, point_trim):
alt, Ma, sm, km = point_trim
aircraft.set_mass_and_static_margin(km, sm)
va = dyn.va_of_mach(Ma, alt)
xtrim, utrim = dyn.trim(aircraft, {'va': va, 'gamm': 0, 'h': alt})
xtrim_4 = xtrim[2:]
A, B = utils.num_jacobian(xtrim, utrim, aircraft, dyn.dyn)
A_4, B_4 = A[2:, 2:], B[2:, :2]
Q = np.zeros((4, 4*2))
for i in range(3):
Q[:,2*i:2*(i+1)] = np.dot(np.linalg.matrix_power(A_4, i),B_4)
return Q
def stability(aircraf, point_trim):
alt, Ma, sm, km = point_trim
aircraft.set_mass_and_static_margin(km, sm)
va = dyn.va_of_mach(Ma, alt)
xtrim, utrim = dyn.trim(aircraft, {'va': va, 'gamm': 0, 'h': alt})
A, B = utils.num_jacobian(xtrim, utrim, aircraft, dyn.dyn)
A_4 = A[2:,2:]
valeursp, M = np.linalg.eig(A_4)
V_reals = []
for V in valeursp:
V_reals.append(V.real)
return V_reals
def LinearTraj(aircraft, h, Ma, sm, km, Wh, time):
'''
Calcul d'une trajectoire avec un point de trim comme condition initiale
'''
aircraft.set_mass_and_static_margin(km, sm)
va = dyn.va_of_mach(Ma, h)
Xe, Ue = dyn.trim(aircraft, {'va':va, 'h':h, 'gamma':0})
A, B = ut.num_jacobian(Xe, Ue, aircraft, dyn.dyn)
dX0 = np.zeros(dyn.s_size)
dU = np.zeros(dyn.i_size)
dX0[dyn.s_a] = math.atan(Wh/Xe[dyn.s_va]) #perturbation
dX = scipy.integrate.odeint(LinearDyn, dX0, time, args=(dU, A, B))
Xlin = np.array([dXi+Xe for dXi in dX])
return Xlin
def modal_form(aircraft, point_trim):
alt, Ma, sm, km = point_trim
aircraft.set_mass_and_static_margin(km, sm)
va = dyn.va_of_mach(Ma, alt)
xtrim, utrim = dyn.trim(aircraft, {'va': va, 'gamm': 0, 'h': alt})
xtrim_4 = xtrim[2:]
A, B = utils.num_jacobian(xtrim, utrim, aircraft, dyn.dyn)
A_4, B_4 = A[2:,2:], B[2:,:2]
valeursp, M = np.linalg.eig(A_4)
M_inv = np.linalg.inv(M)
Am_4 = np.diag(valeursp)
Bm_4 = np.dot(M_inv, B_4)
return '{} = {}\n\n{} = {}'.format('Am', Am_4,'Bm', Bm_4)
def get_all_trims(aircraft, hs, Mas, sms, kms):
'''
Calcul de trims pour une serie de points de vol
'''
trims = []
for h in hs:
for Ma in Mas:
va = dyn.va_of_mach(Ma,h)
arg = {'va':va, 'h':h, 'gamma':0}
trim = dyn.trim(dyn.Param_737_300(), arg)
trims.append(trim)
print trim
return trims
def LinearModel(aircraft, point_trim, wh, time):
alt, Ma, sm, km = point_trim
aircraft.set_mass_and_static_margin(km, sm)
va = dyn.va_of_mach(Ma, alt)
xtrim, utrim = dyn.trim(aircraft, {'va':va,'gamm':0, 'h':alt})
xtrim[dyn.s_a] = xtrim[dyn.s_a] + np.arctan(wh / xtrim[dyn.s_va])
wing = [0] * 6
A, B = utils.num_jacobian(xtrim, utrim, aircraft, dyn.dyn)
du = np.zeros((4,))
wing[dyn.s_a] += np.arctan(wh / xtrim[dyn.s_va])
dX = scipy.integrate.odeint(dynlin, wing, time, args=(A, B, du))
X = dX+xtrim
for i in range(len(X)):
X[i][dyn.s_y] = X[i][dyn.s_va]*time[i]
return X
def state(PLANE, pt_trim):
"""
Computes model of a trim condition
:param PLANE:
:param pt_trim: list of [h, Ma, ms, km]
:return:
"""
PLANE.set_mass_and_static_margin(pt_trim[3], pt_trim[2])
params = {
'va': dynamic.va_of_mach(pt_trim[1], pt_trim[0]),
'h': pt_trim[0],
'gamma': 0
}
X, U = dynamic.trim(PLANE, params)
A, B = dynamic.ut.num_jacobian(X, U, PLANE, dynamic.dyn)
return X, U, A, B
def plot_trims(aircraft, gamma=0., saturate=True):
'''
Affichage de trims sous forme de surfaces colorées
'''
vs = np.linspace(60, 350, 21, endpoint=True)
hs = np.linspace(1000, 14000, 21, endpoint=True)
trims = np.zeros((len(hs), len(vs), 2))
for i,v in enumerate(vs):
for j,h in enumerate(hs):
Xe, Ue = dyn.trim(aircraft, args = {'va': v, 'h': h, 'gamma': gamma})
trims[j, i] = Xe[dyn.s_a], tons_of_newton(dyn.propulsion_model([0, h, v, 0, 0, 0], [0, Ue[dyn.i_dth], 0, 0], aircraft))
if saturate:
alpha_c, T_c = trims[j,i][0], trims[j,i,1]
alpha_max = ut.rad_of_deg(15)
if alpha_c > alpha_max:
trims[j,i][0] = 1e16
trims[j,i][1] = 1e16
Tmax = tons_of_newton(dyn.propulsion_model([0, h, v, 0, 0, 0], [0, 1, 0, 0], aircraft))
if T_c > Tmax:
trims[j,i, 0] = 1e16
trims[j,i, 1] = 1e16
fig = plt.figure(figsize=(0.75*20.48, 0.5*10.24))
ax = plt.subplot(1,2,1)
thetas_deg = ut.deg_of_rad(trims[:, :, 0])
v = np.linspace(0, 15, 16, endpoint=True)
plt.contour(vs, hs, thetas_deg, v, linewidths=0.5, colors='k')
plt.contourf(vs, hs, thetas_deg, v, cmap=plt.cm.jet)
ax.set_title(u'$\\alpha$ (degrés)')
ax.xaxis.set_label_text('vitesse (m/s)')
ax.yaxis.set_label_text('altitude (m)')
plt.colorbar(ticks=v)
ax = plt.subplot(1,2,2)
T_tons = trims[:, :, 1] #/9.81/1000.
v = np.linspace(2, 10, 17, endpoint=True)
plt.contour(vs, hs, T_tons, v, linewidths=0.5, colors='k')
plt.contourf(vs, hs, T_tons, v, cmap=plt.cm.jet)
ax.set_title('thrust (tons)')
ax.xaxis.set_label_text('vitesse (m/s)')
ax.yaxis.set_label_text('altitude (m)')
plt.colorbar(ticks=v)
def v_propre(h_tuple, mac_tuple, km_tuple, ms_tuple):
'''
:param h_tuple: tuple contenant le altitudes
:param mac_tuple:
:param km_tuple:
:param ms_tuple:
:return:
'''
dico_etat = {} # dico pour stocker les 16 états associés au 16 pts de trim
dico_etat_lin = {}
dico_etat_lin4 = {}
dico_vp = {}
dico_vecteur_propre = {}
for i, km in enumerate(km_tuple):
for j, ms in enumerate(ms_tuple):
P.set_mass_and_static_margin(km, ms)
for idx, mac in enumerate(mac_tuple):
dico = {} # dico = args dans la fonction trim
for h in h_tuple:
dico['h'] = h
dico['va'] = dy.va_of_mach(mac, h) # conv mach en m/s
# calcul des points de trim associés aux 4 valeurs h, mac, km et ms
# et ajout dans le tuple etat
etat = (X, U) = dy.trim(P, dico)
etat_lin = (A, B) = ut.num_jacobian(X, U, P, dy.dyn)
A4 = A[2:, 2:].copy()
B4 = B[2:].copy()
etat_lin4 = (A4, B4)
# calcul vp val propre
vp = np.linalg.eig(A4)
# construction du tuple (h,mac,km,ms) qui jouera le role de clé du dico states
pt_trim = (h, mac, km, ms)
dico_etat[pt_trim] = etat
dico_etat_lin[pt_trim] = etat_lin
dico_etat_lin4[pt_trim] = etat_lin4
dico_vp[pt_trim] = vp[0]
dico_vecteur_propre[pt_trim] = vp[1:][
0] # car vp est un tuple ; indice 1 => array des vect propre indice 0 val propres
return dico_vp, dico_vecteur_propre, dico_etat_lin4, dico_etat, dico_etat_lin
def v_propre(h_tuple, mac_tuple, km_tuple, ms_tuple):
'''
:param h_tuple: tuple contenant le altitudes
:param mac_tuple:
:param km_tuple:
:param ms_tuple:
:return:
'''
dico_etat = {} # dico pour stocker les 16 états associés au 16 pts de trim
dico_etat_lin = {}
dico_etat_lin4 = {}
dico_vp = {}
dico_vecteur_propre = {}
for i, km in enumerate(km_tuple):
for j, ms in enumerate(ms_tuple):
P.set_mass_and_static_margin(km, ms)
for idx, mac in enumerate(mac_tuple):
dico = {} # dico = args dans la fonction trim
for h in h_tuple:
dico['h'] = h
dico['va'] = dy.va_of_mach(mac, h) # conv mach en m/s
# calcul des points de trim associés aux 4 valeurs h, mac, km et ms
# et ajout dans le tuple etat
etat = (X, U) = dy.trim(P, dico)
etat_lin = (A, B) = ut.num_jacobian(X, U, P, dy.dyn)
A4 = A[2:, 2:].copy()
B4 = B[2:].copy()
etat_lin4 = (A4, B4)
# calcul vp val propre
vp = np.linalg.eig(A4)
# construction du tuple (h,mac,km,ms) qui jouera le role de clé du dico states
pt_trim = (h, mac, km, ms)
dico_etat[pt_trim] = etat
dico_etat_lin[pt_trim] = etat_lin
dico_etat_lin4[pt_trim] = etat_lin4
dico_vp[pt_trim] = vp[0]
dico_vecteur_propre[pt_trim] = vp[1:][
0] # car vp est un tuple ; indice 1 => array des vect propre indice 0 val propres
return dico_vp, dico_vecteur_propre, dico_etat_lin4, dico_etat, dico_etat_lin
def Trim_dyn(P):
hs = [3000, 11000]
x = np.linspace(3000, 11000, 2)
Ms = [0.5, 0.8]
couples = [[0.2, 0.1], [0.2, 0.9], [1., 0.1], [1., 0.9]]
alphatab1, alphatab2, dphrtab1, dphrtab2, dthtab1, dthtab2 = [], [], [], [], [], []
for couple in couples:
P.set_mass_and_static_margin(couple[1], couple[0])
alpha1, alpha2, dphr1, dphr2, dth1, dth2 = [], [], [], [], [], []
for h in hs:
param1 = {'va': dyn.va_of_mach(Ms[0], h), 'gamma': 0, 'h': h}
alpha1.append(dyn.trim(P, param1)[0][3])
param2 = {'va': dyn.va_of_mach(Ms[1], h), 'gamma': 0, 'h': h}
alpha2.append(dyn.trim(P, param2)[0][3])
alphatab1.append(alpha1)
alphatab2.append(alpha2)
for h in hs:
param1 = {'va': dyn.va_of_mach(Ms[0], h), 'gamma': 0, 'h': h}
dphr1.append(dyn.trim(P, param1)[1][0])
param2 = {'va': dyn.va_of_mach(Ms[1], h), 'gamma': 0, 'h': h}
dphr2.append(dyn.trim(P, param2)[1][0])
dphrtab1.append(dphr1)
dphrtab2.append(dphr2)
for h in hs:
param1 = {'va': dyn.va_of_mach(Ms[0], h), 'gamma': 0, 'h': h}
dth1.append(dyn.trim(P, param1)[1][1])
param2 = {'va': dyn.va_of_mach(Ms[1], h), 'gamma': 0, 'h': h}
dth2.append(dyn.trim(P, param2)[1][1])
dthtab1.append(dth1)
dthtab2.append(dth2)
print('alpha1 :', alphatab1)
print('alpha2 :', alphatab2)
print('dphr1 :', dphrtab1)
print('dphr2 :', dphrtab2)
print('dth1 :', dthtab1)
print('dth2 :', dthtab2)
al1 = np.array(alphatab1)
al2 = np.array(alphatab2)
f, axarr = plt.subplots(4, 3)
axarr[0, 0].plot(x, al1[0])
axarr[0, 0].set_title('Alpha')
axarr[1, 0].plot(x, al1[1])
axarr[2, 0].plot(x, al1[2])
axarr[3, 0].plot(x, al1[3])
axarr[0, 0].plot(x, al2[0])
axarr[1, 0].plot(x, al2[1])
axarr[2, 0].plot(x, al2[2])
axarr[3, 0].plot(x, al2[3])
dp1 = np.array(dphrtab1)
dp2 = np.array(dphrtab2)
axarr[0, 1].plot(x, dp1[0])
axarr[0, 1].set_title('Dphr')
axarr[1, 1].plot(x, dp1[1])
axarr[2, 1].plot(x, dp1[2])
axarr[3, 1].plot(x, dp1[3])
axarr[0, 1].plot(x, dp2[0])
axarr[1, 1].plot(x, dp2[1])
axarr[2, 1].plot(x, dp2[2])
axarr[3, 1].plot(x, dp2[3])
dt1 = np.array(dthtab1)
dt2 = np.array(dthtab2)
axarr[0, 2].plot(x, dt1[0])
axarr[0, 2].set_title('Dth')
axarr[1, 2].plot(x, dt1[1])
axarr[2, 2].plot(x, dt1[2])
axarr[3, 2].plot(x, dt1[3])
axarr[0, 2].plot(x, dt2[0])
axarr[1, 2].plot(x, dt2[1])
axarr[2, 2].plot(x, dt2[2])
axarr[3, 2].plot(x, dt2[3])
f.suptitle(
"Valeur de Alpha, Dphr et Dth pour un vol en palier en fonction de l'Altitude pour les couples \n [ms, km] suivants : [0.2, 0.1], [0.2, 0.9], [1., 0.1], [1., 0.9]"
)
plt.show()
km = 0.9
ms = 1.
# intialisation de l'avion
P.set_mass_and_static_margin(km, ms) # km masse avion, ms : marge statique
# calcul de va en m/s
va = dy.va_of_mach(mac, h)
# calcul de rho
rho = ut.isa(h)[1]
args = {}
args['h'] = h
args['va'] = dy.va_of_mach(mac, h) # conv mach en m/s
X, U = dy.trim(P, args)
(A, B) = ut.num_jacobian(X, U, P, dy.dyn)
val_propre = np.linalg.eig(A)
print(np.real(val_propre[0]))
exit()
#calcul du nouveau vecteur d'état intial on a alpha
#atan(wh/vae)
dalpha = math.atan(2./X[dy.s_va])
Xi=X.copy()
Xi[dy.s_a]+=dalpha
print("*******************")
km = 0.9
ms = 1.
# intialisation de l'avion
P.set_mass_and_static_margin(km, ms) # km masse avion, ms : marge statique
# calcul de va en m/s
va = dy.va_of_mach(mac, h)
# calcul de rho
rho = ut.isa(h)[1]
args = {}
args['h'] = h
args['va'] = dy.va_of_mach(mac, h) # conv mach en m/s
X, U = dy.trim(P, args)
alpha16 = X[3] # alpha en radians
dphr16 = U[0] # delta PHR en radians
dth16 = U[1] # thrust de 0 à 1
# calcul de la poussée pour le point de trim 16
F16 = dy.propulsion_model(X, U, P)
# calcul de CL16, la val du CL au point de trim16
CL16 = 2 * (P.m * P.g - math.sin(alpha16)) / ((rho * np.power(va, 2) * P.S))
print("valeurs obtenues via la fonction trim.")
print("alpha16 = ", alpha16, " rad")
print("angle réglage PHR dphr16 = ", dphr16, " rad")
print("Gaz ou thrust dth16 = ", dth16)
print("CL16 = ", CL16)
def evol_trym(P):
for couple in couples:
P.set_mass_and_static_margin(couple[1], couple[0])
alpha1, alpha2, dphr1, dphr2, dth1, dth2 = [], [], [], [], [], []
for h in hs:
arg1 = {
'va': dyn.va_of_mach(machs[0], h, k=1.4, Rs=287.05),
'h': h
}
alpha1.append(ut.deg_of_rad(dyn.trim(P, arg1)[0][3]))
dphr1.append(ut.deg_of_rad(dyn.trim(P, arg1)[1][0]))
dth1.append(dyn.trim(P, arg1)[1][1] * 100)
arg2 = {
'va': dyn.va_of_mach(machs[1], h, k=1.4, Rs=287.05),
'h': h
}
alpha2.append(ut.deg_of_rad(dyn.trim(P, arg2)[0][3]))
dphr2.append(ut.deg_of_rad(dyn.trim(P, arg2)[1][0]))
dth2.append(dyn.trim(P, arg2)[1][1] * 100)
alphatab1.append(alpha1)
alphatab2.append(alpha2)
dthtab1.append(dth1)
dthtab2.append(dth2)
dphrtab1.append(dphr1)
dphrtab2.append(dphr2)
al1 = np.array(alphatab1)
al2 = np.array(alphatab2)
f, axarr = plt.subplots(4, 3)
axarr[0, 0].plot(x, al1[0], 'b')
axarr[0, 0].set_title('Alpha')
axarr[1, 0].plot(x, al1[1], 'b')
axarr[2, 0].plot(x, al1[2], 'b')
axarr[3, 0].plot(x, al1[3], 'b')
axarr[0, 0].plot(x, al2[0], 'r')
axarr[1, 0].plot(x, al2[1], 'r')
axarr[2, 0].plot(x, al2[2], 'r')
axarr[3, 0].plot(x, al2[3], 'r')
dp1 = np.array(dphrtab1)
dp2 = np.array(dphrtab2)
axarr[0, 1].plot(x, dp1[0], 'b')
axarr[0, 1].set_title('Dphr')
axarr[1, 1].plot(x, dp1[1], 'b')
axarr[2, 1].plot(x, dp1[2], 'b')
axarr[3, 1].plot(x, dp1[3], 'b')
axarr[0, 1].plot(x, dp2[0], 'r')
axarr[1, 1].plot(x, dp2[1], 'r')
axarr[2, 1].plot(x, dp2[2], 'r')
axarr[3, 1].plot(x, dp2[3], 'r')
dt1 = np.array(dthtab1)
dt2 = np.array(dthtab2)
axarr[0, 2].plot(x, dt1[0], 'b')
axarr[0, 2].set_title('Dth')
axarr[1, 2].plot(x, dt1[1], 'b')
axarr[2, 2].plot(x, dt1[2], 'b')
axarr[3, 2].plot(x, dt1[3], 'b')
axarr[0, 2].plot(x, dt2[0], 'r')
axarr[1, 2].plot(x, dt2[1], 'r')
axarr[2, 2].plot(x, dt2[2], 'r')
axarr[3, 2].plot(x, dt2[3], 'r')
f.suptitle(
"Valeur de Alpha, Dphr et Dth pour un vol en palier en fonction de l'Altitude pour les couples \n [ms, km] suivants : [0.2, 0.1], [0.2, 0.9], [1., 0.1], [1., 0.9]. En bleu pour Mach = 0.5 et en rouge pour Mach = 0.8"
)
plt.show()
# calcul des points de Trim
alphatrim = np.zeros((len(ms), len(km), len(Ma), len(h1)))
dphrtrim = np.zeros((len(ms), len(km), len(Ma), len(h1)))
dthtrim = np.zeros((len(ms), len(km), len(Ma), len(h1)))
prop = np.zeros((len(ms), len(km), len(Ma1), len(h)))
for ib, i in enumerate(ms):
for jb, j in enumerate(km):
avion.set_mass_and_static_margin(j, i)
for kb, k in enumerate(Ma):
for lb, l in enumerate(h1):
va_h0 = dynamic.va_of_mach(k, l, k=1.4, Rs=287.05)
X, U = dynamic.trim(avion, {
'va': va_h0,
'gamm': 0.,
'h': l
})
alphatrim[ib, jb, kb, lb] = X[3]
dphrtrim[ib, jb, kb, lb] = U[0]
dthtrim[ib, jb, kb, lb] = U[1]
for kbb, k in enumerate(Ma1):
for lbb, l in enumerate(h):
va_h0b = dynamic.va_of_mach(k, l, k=1.4, Rs=287.05)
Xb, Ub = dynamic.trim(avion, {
'va': va_h0b,
'gamm': 0.,
'h': l
})
prop[ib, jb, kbb,
lbb] = dynamic.propulsion_model(Xb, Ub, avion)
def q1():
lh = np.linspace(h[0], h[1], 100)
n = len(lh)
for i, ms_i in enumerate(ms):
for j, km_i in enumerate(km):
PLANE.set_mass_and_static_margin(km_i, ms_i)
alpha0 = np.zeros(n)
dphr0 = np.zeros(n)
dth0 = np.zeros(n)
alpha1 = np.zeros(n)
dphr1 = np.zeros(n)
dth1 = np.zeros(n)
for k, h_i in enumerate(lh):
va0 = dynamic.va_of_mach(Ma[0], h_i)
va1 = dynamic.va_of_mach(Ma[1], h_i)
alpha0[k] = dynamic.trim(PLANE, {
'va': va0,
'h': h_i
})[0][3]
dphr0[k] = dynamic.trim(PLANE, {'va': va0, 'h': h_i})[1][0]
dth0[k] = dynamic.trim(PLANE, {'va': va0, 'h': h_i})[1][1]
alpha1[k] = dynamic.trim(PLANE, {
'va': va1,
'h': h_i
})[0][3]
dphr1[k] = dynamic.trim(PLANE, {'va': va1, 'h': h_i})[1][0]
dth1[k] = dynamic.trim(PLANE, {'va': va1, 'h': h_i})[1][1]
plt.figure("m_s={}, k_m={}".format(ms_i, km_i))
plt.subplot(1, 3, 1)
plt.title("$h \\mapsto \\alpha$")
#plt.title("$m_s={}, k_m={}$".format(ms_i, km_i))
plt.plot(lh, alpha0, label="$M_a=0.4$")
plt.plot(lh, alpha1, label="$M_a=0.9$")
plt.legend()
#plt.xlabel("$h$")
#plt.ylabel("$\\alpha$")
#plt.show()
#plt.figure()
plt.subplot(1, 3, 2)
#plt.title("$m_s={}, k_m={}$".format(ms_i, km_i))
plt.title("$h \\mapsto \\delta_{{th}}$")
plt.plot(lh, dth0, label="$M_a=0.4$")
plt.plot(lh, dth1, label="$M_a=0.9$")
#plt.legend()
#plt.xlabel("$h$")
#plt.ylabel("$\\delta_{{th}}$")
#plt.show()
#plt.figure()
plt.subplot(1, 3, 3)
#plt.title("$m_s={}, k_m={}$".format(ms_i, km_i))
plt.title("$h \\mapsto \\delta_{{PHR}}$")
plt.plot(lh, dphr0, label="$M_a=0.4$")
plt.plot(lh, dphr1, label="$M_a=0.9$")
#plt.xlabel("$h$")
#plt.ylabel("$\\delta_{{PHR}}$")
#plt.legend()
plt.tight_layout(.5)
plt.savefig(file + "q1_" + str(i) + str(j) + format)
#plt.show()
plt.show()
