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()