def polaire_equi(P): q = 0 mss = [0.2, 1] alphas = np.arange(ut.rad_of_deg(-10), ut.rad_of_deg(20), ut.rad_of_deg(1)) km = 0.1 for ms in mss: P.set_mass_and_static_margin(km, ms) dphrs = [] dphrs = np.array([(P.ms * P.CLa * (alpha - P.a0) - P.Cm0) / P.Cmd for alpha in alphas]) CLe = [] CLe = [ dyn.get_aero_coefs(dyn.va_of_mach(0.7, 7000), alpha, q, dphr, P)[0] for alpha, dphr in zip(alphas, dphrs) ] Cxe = [ dyn.get_aero_coefs(dyn.va_of_mach(0.7, 7000), alpha, q, dphr, P)[1] for alpha, dphr in zip(alphas, dphrs) ] finesse = [CL / Cx for Cx, CL in zip(Cxe, CLe)] fmax = np.max(finesse) idmax = np.argmax(finesse) print(fmax) plt.plot([0, Cxe[idmax]], [0, CLe[idmax]]) plt.plot(Cxe, CLe) label1 = patches.Patch(color='blue', label='fmax (ms = 0.2)') label2 = patches.Patch(color='green', label='Polaire (ms = 0.2)') label3 = patches.Patch(color='red', label='fmax (ms = 1)') label4 = patches.Patch(color='cyan', label='Polaire (ms = 1)') plt.legend(loc='upper left', handles=[label1, label2, label3, label4]) ut.decorate(plt.gca(), "Evolution de la polaire équilibrée", 'Coefficient de trainée équilibrée', 'Coefficient de portance équilibrée') plt.show
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 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 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 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 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 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 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 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 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 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 evol_Cm(P): ms = [-0.1, 0, 0.2, 1] dphr = 0 alphas = np.arange(ut.rad_of_deg(-10), ut.rad_of_deg(20), ut.rad_of_deg(1)) Cm_tab1 = [] Cm_tab2 = [] Cm_tab3 = [] Cm_tab4 = [] q = 0 for alpha in alphas: Cm1 = P.Cm0 - ms[0] * P.CLa * (alpha - P.a0) + P.Cmq * P.lt / dyn.va_of_mach( 0.7, 7000) * q + P.Cmd * dphr Cm_tab1.append(Cm1) Cm2 = P.Cm0 - ms[1] * P.CLa * (alpha - P.a0) + P.Cmq * P.lt / dyn.va_of_mach( 0.7, 7000) * q + P.Cmd * dphr Cm_tab2.append(Cm2) Cm3 = P.Cm0 - ms[2] * P.CLa * (alpha - P.a0) + P.Cmq * P.lt / dyn.va_of_mach( 0.7, 7000) * q + P.Cmd * dphr Cm_tab3.append(Cm3) Cm4 = P.Cm0 - ms[3] * P.CLa * (alpha - P.a0) + P.Cmq * P.lt / dyn.va_of_mach( 0.7, 7000) * q + P.Cmd * dphr Cm_tab4.append(Cm4) plt.plot(ut.deg_of_rad(alphas), Cm_tab1) plt.plot(ut.deg_of_rad(alphas), Cm_tab2) plt.plot(ut.deg_of_rad(alphas), Cm_tab3) plt.plot(ut.deg_of_rad(alphas), Cm_tab4) label1 = patches.Patch(color='blue', label='ms = -0.1') label2 = patches.Patch(color='green', label='ms = 0') label3 = patches.Patch(color='red', label='ms = 0.2') label4 = patches.Patch(color='cyan', label='ms = 1') plt.legend(loc='upper right', handles=[label1, label2, label3, label4]) ut.decorate(plt.gca(), title="Evolution du Cm en fonction de l'incidence", xlab='Incidence', ylab='Cm') plt.show()
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 plot_thrust(P, filename=None): figure = ut.prepare_fig(None, u'Poussée {}'.format(P.name)) hs = np.linspace(3000, 11000, 5) for h in hs: Machs = np.linspace(0.5, 0.8, 30) thrusts = np.zeros(len(Machs)) for i in range(0, len(Machs)): thrusts[i] = dyn.propulsion_model([0, h, dyn.va_of_mach(Machs[i], h), 0, 0, 0], [0, 1., 0, 0], P) plt.plot(Machs, thrusts) ut.decorate(plt.gca(), u'Poussée maximum {}'.format(P.name), r'Mach', '$N$', ['{} m'.format(h) for h in hs]) if filename<> None: plt.savefig(filename, dpi=160) return figure
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 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 evol_coeff_portance(P): alphas = np.arange(ut.rad_of_deg(-10), ut.rad_of_deg(20), ut.rad_of_deg(1)) dphrs = [ut.rad_of_deg(-30), ut.rad_of_deg(20)] q = 0 Cz_tab1 = [] Cz_tab2 = [] for alpha in alphas: coeff_portance1 = dyn.get_aero_coefs(dyn.va_of_mach(0.7, 7000), alpha, q, dphrs[0], P) Cz_tab1.append(coeff_portance1[0]) coeff_portance2 = dyn.get_aero_coefs(dyn.va_of_mach(0.7, 7000), alpha, q, dphrs[1], P) Cz_tab2.append(coeff_portance2[0]) plt.plot(ut.deg_of_rad(alphas), Cz_tab1, 'r') plt.plot(ut.deg_of_rad(alphas), Cz_tab2, 'b') label1 = patches.Patch(color='red', label='dPHR1 = -30°') label2 = patches.Patch(color='blue', label='dPHR2 = 20°') plt.legend(loc='upper left', handles=[label1, label2]) ut.decorate(plt.gca(), title="Evolution du Cz en fonction de l'incidence", xlab='Incidence', ylab='Cz') plt.show()
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 evol_poussee(P): U = [0, 1, 0, 0] hs = np.linspace(3000, 11000, 5) machs = np.linspace(0.5, 0.8, 30) for h in hs: Poussee = [ dyn.propulsion_model([0, h, dyn.va_of_mach(mach, h), 0, 0, 0], U, P) for mach in machs ] plt.plot(machs, Poussee) ut.decorate(plt.gca(), title='Poussée maximale en fonction du Mach', xlab='Mach', ylab='Poussee (N)', legend=['{} m'.format(h) for h in hs]) plt.show()
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 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 evol_CLe(P): q = 0 mss = [0.2, 1] alphas = np.arange(ut.rad_of_deg(-10), ut.rad_of_deg(20), ut.rad_of_deg(1)) km = 0.1 for ms in mss: P.set_mass_and_static_margin(km, ms) dphrs = [] dphrs = np.array([(P.ms * P.CLa * (alpha - P.a0) - P.Cm0) / P.Cmd for alpha in alphas]) CLe = [] CLe = [ dyn.get_aero_coefs(dyn.va_of_mach(0.7, 7000), alpha, q, dphr, P)[0] for alpha, dphr in zip(alphas, dphrs) ] plt.plot(ut.deg_of_rad(alphas), CLe) label1 = patches.Patch(color='blue', label='ms = 0.2') label2 = patches.Patch(color='green', label='ms = 1') plt.legend(loc='upper left', handles=[label1, label2]) ut.decorate(plt.gca(), "Evolution de CLe en fonction de l'incidence", 'Incidence', 'Coefficient de portance équilibrée') plt.show
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()
def get_CL_Fmax_trim(aircraft, h, Ma): p, rho, T = ut.isa(h) va = dyn.va_of_mach(Ma, h) pdyn = 0.5*rho*va**2 return P.m*P.g/(pdyn*P.S), propulsion_model([0, h, va, 0, 0, 0], [0, 1, 0, 0], aircraft)
abs_min = 3 abs_max = 11 nb_ligne = len(km_tuple) * len(ms_tuple) # on choisit le point de trim numéro 16 pour lequel on a : h = 3000. mac = 0.8 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()
def get_Cl(): Va = dynamic.va_of_mach(Ma[1], h[1]) PLANE.set_mass_and_static_margin(km[1], ms[1]) rho = utils.isa(h[1])[1] Cl = (PLANE.m * PLANE.g) / (0.5 * rho * PLANE.S * Va**2) return Cl
def main(): PLANE = dynamic.Param_737_800() Vt = PLANE.lt*PLANE.St/PLANE.cbar/PLANE.S va = dynamic.va_of_mach(0.9, 0) km = 1 ###q1 def pousse_max(h, mach): M = np.linspace(mach[0], mach[1], 100) rho0 = utils.isa(0)[1] F0 = PLANE.F0 plt.figure(0) for h_i in h : F = F0*(utils.isa(h_i)[1]/rho0)**(0.6)*(0.568+0.25*(1.2-M)**3) plt.plot(M, F, label='$h={:.0f}$'.format(h_i)) plt.xlabel("$M_a$") plt.ylabel("$F$") plt.title("Evolution de la poussée maximale avec l'altitude et le nombre de Mach") plt.legend() plt.savefig(file+"q1"+format) plt.show() ###q2 def coeff_Cl(a, delta_PHR): """ :param a: a list of two angles (min an max) in degree ! :param delta_PHR: degree ! :return: """ alpha = np.linspace(a[0], a[1], 100) plt.figure(1) for d in delta_PHR: Cl = dynamic.get_aero_coefs(va, alpha*pi/180, 0, d*pi/180, PLANE)[0] plt.plot(alpha, Cl, label="$\delta_{{PHR}}={:.0f}$".format(d)) plt.xlabel("$\\alpha$") plt.ylabel("$C_L$") plt.title("$\\alpha\\mapsto C_l$") plt.legend() plt.savefig(file + "q2" + format) plt.show() ###q3 def coeff_Cm(a, m_s): dphr = 0 alpha = np.linspace(a[0], a[1], 100) m_s_original = PLANE.ms plt.figure(2) for m in m_s: PLANE.set_mass_and_static_margin(km, m) Cm = dynamic.get_aero_coefs(va, alpha*pi/180, 0, dphr, PLANE)[2] plt.plot(alpha, Cm, label="$m_s={}$".format(m)) plt.xlabel("$\\alpha$") plt.ylabel("$C_m$") plt.title("$\\alpha \\mapsto C_m$") plt.legend() plt.savefig(file + "q3" + format) plt.show() PLANE.set_mass_and_static_margin(km, m_s_original) ###q4 def dphre(a, m_s, vt): """ :param a:couple of alpha angle (min and max) in degrees! :param m_s: :param vt: :return: """ ms_original = PLANE.ms alpha = np.linspace(a[0], a[1], 100) alpha0 = PLANE.a0*180/pi plt.figure(3) for m in m_s: PLANE.set_mass_and_static_margin(km, m) dphre = (PLANE.Cm0 - PLANE.ms * PLANE.CLa * ((alpha - alpha0)*pi/180)) / (Vt * PLANE.CLat) plt.plot(alpha, dphre*180/pi, label='$m_s = {}$'.format(m)) plt.xlabel('$\\alpha_e$') plt.ylabel('$\\delta_{{PHRe}}$') plt.title("$\\alpha \\mapsto \\delta_{{PHRe}}$") plt.legend() plt.savefig(file + "q4_ms" + format) plt.show() PLANE.set_mass_and_static_margin(km, ms_original) plt.figure(4) for v in vt: dphre = (PLANE.Cm0 - PLANE.ms * PLANE.CLa * ((alpha - alpha0) * pi / 180)) / (v * PLANE.CLat) plt.plot(alpha, dphre*180/pi, label='$V_t = {:.3f}$'.format(v)) plt.title("$\\alpha_e \\mapsto \\delta_{{PHRe}}$") plt.xlabel('$\\alpha_e$') plt.ylabel('$\\delta_{{PHRe}}$') plt.legend() plt.savefig(file + "q4_Vt" + format) plt.show() ### q5 def coeff_CLe(a, m_s): alpha = np.linspace(a[0], a[1], 100) alpha0 = PLANE.a0 * 180 / pi plt.figure(5) for m in m_s: PLANE.set_mass_and_static_margin(km, m) dphre = (PLANE.Cm0 - PLANE.ms * PLANE.CLa * ((alpha - alpha0)*pi/180)) / (Vt * PLANE.CLat) CL = dynamic.get_aero_coefs(va, alpha*pi/180, 0, dphre, PLANE)[0] plt.plot(alpha, CL, label='$m_s={}$'.format(m)) plt.xlabel("$\\alpha_{eq}$") plt.ylabel("$C_{L_e}$") plt.title('$\\alpha_e\\mapsto C_L$') plt.legend() plt.savefig(file + "q5" + format) plt.show() ###q6 def polaire(a, m_s): alpha = np.linspace(a[0], a[1], 100) plt.figure(6) fmax = np.zeros(len(m_s)) for i, m in enumerate(m_s): PLANE.set_mass_and_static_margin(km, m) dphre = (PLANE.Cm0 - PLANE.ms * PLANE.CLa * (alpha*pi/180)) / (Vt * PLANE.CLat) CL, CD = dynamic.get_aero_coefs(va, alpha*pi/180, 0,dphre, PLANE)[0:2] plt.plot(CD, CL, label='$m_s={}$'.format(m)) fmax[i] = max(CL / CD) plt.title('Polaire équilibrée') plt.xlabel('$C_D$') plt.ylabel('$C_L$') plt.legend() plt.savefig(file + "polaire" + format) plt.show() return fmax alpha = [-10, 20] pousse_max([3000, 10000], [0.4, 0.9]) coeff_Cl(alpha, [-30, 20]) coeff_Cm(alpha, [-0.1, 0, 0.2, 1]) dphre(alpha, [-0.1, 0, 0.2, 1], [0.9 * Vt, Vt, 1.1 * Vt]) coeff_CLe(alpha, [0.2, 1]) polaire(alpha, [0.2, 1]) print(polaire(alpha, [0.2, 1]))
# Pour une masse donnée, à chaque vitesse de vol correspond une incidence de vol et donc une position # de la gouverne de profondeur. À chaque changement de vitesse, l'incidence change, # ainsi il faut compenser à nouveau (ou trimer) pour garder cette nouvelle incidence. # Le trim correspond à une incidence et donc une vitesse, pour une masse donnée de l'avion. # on choisit le point de trim numéro 16 pour lequel on a : h = 11000. mac = 0.8 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)
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()
'''''' '''''' # questions 1-2 # 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
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()
def main(): PLANE = dynamic.Param_737_800() Wh = 2 #m/s wind velocity h1, h2 = 10000, 3000 Ma1, Ma2 = 0.9, 0.4 ms1, ms2 = 0.5, 0.5 km1, km2 = 1, 0.1 va = dynamic.va_of_mach(Ma1, h1) pt_trim1 = [h1, Ma1, ms1, km1] pt_trim2 = [h2, Ma2, ms2, km2] def compare_lin(T, pt_trim): X, U, A, B = state(PLANE, pt_trim) time = np.arange(0, T, 0.1) val_p = np.linalg.eigvals(A[2:, 2:]) add_wind = np.array([0, 0, 0, atan2(Wh, X[2]), 0, 0]) x = integrate.odeint(dynamic.dyn, X + add_wind, time, args=(U, PLANE)) dynamic.plot(time, x) plt.savefig(file + "nolin" + str(T) + format) plt.show() dU = np.zeros((4, )) dx = integrate.odeint(dynlin, add_wind, time, args=(dU, A, B)) out = np.array([dxi + X for dxi in dx]) for j, Xj in enumerate(out): out[j][0] += out[j][2] * time[j] dynamic.plot(time, out) plt.savefig(file + "lin" + str(T) + format) plt.show() dynamic.plot(time, abs(out - x)) plt.savefig(file + "dif" + str(T) + format) plt.show() print([mode(val_p[i]) for i in range(len(val_p))]) def q3(T, pt_trim1, pt_trim2): _, _, A, B = state(PLANE, pt_trim1) X, U, _, _ = state(PLANE, pt_trim2) add_wind = np.array([0, 0, 0, atan2(Wh, X[2]), 0, 0]) time = np.arange(0, T, 0.1) x = integrate.odeint(dynamic.dyn, X + add_wind, time, args=(U, PLANE)) dynamic.plot(time, x) plt.savefig(file + "otherpoint" + format) plt.show() dU = np.zeros((4, )) dx = integrate.odeint(dynlin, add_wind, time, args=(dU, A, B)) out = np.array([dxi + X for dxi in dx]) for j, Xj in enumerate(out): out[j][0] += out[j][2] * time[j] dynamic.plot(time, out) plt.savefig(file + "badlin" + format) plt.show() dynamic.plot(time, abs(out - x)) plt.savefig(file + "badlindif" + format) plt.show() def modal_form(pt_trim): _, _, A, B = state(PLANE, pt_trim) A_4, B_4 = A[2:, 2:], B[2:, :2] val_p, M = np.linalg.eig(A_4) M_inv = np.linalg.inv(M) Am_4 = np.diag(val_p) Bm_4 = np.dot(M_inv, B_4) return Am_4, Bm_4 def stability(pt_trim): _, _, A, B = state(PLANE, pt_trim) return np.linalg.eigvals(A[2:, 2:]) def controllability(pt_trim): Am_4, Bm_4 = modal_form(pt_trim1) Q = np.zeros((4, 4 * 2)) for i in range(3): Q[:, 2 * i:2 * (i + 1)] = np.dot(np.linalg.matrix_power(Am_4, i), Bm_4) return Q def transfer_function(pt_trim): _, _, A, B = state(PLANE, pt_trim) A_4, B_4 = A[2:, 2:], B[2:, :2][:, 0].reshape((4, 1)) C_4 = np.array([0, 0, 1, 0]) Acc_4 = np.zeros((4, 4)) Bcc_4 = np.array([[0], [0], [0], [1]]) val_p = np.linalg.eigvals(A_4) coef = np.poly(val_p) N = 4 for i in range(3): Acc_4[3, N - 1 - i] = -coef[i + 1] Acc_4[i, i + 1] = 1 Acc_4[3, 0] = -coef[N] 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, val_p def Pade_reduction(pt_trim): num, den, val_p = transfer_function(pt_trim) p = num[-1] / den[-1] q = (num[-2] - (num[-1] / den[-1]) * den[-2]) / den[-1] poles = sorted(val_p, key=lambda x: abs(x)) pade_poles = poles[0:2] den_pade = np.poly(pade_poles) b_0 = den_pade[-1] * p b_1 = q * den_pade[-1] + b_0 * den_pade[-2] / den_pade[-1] num_pade = [b_1, b_0] return num_pade, den_pade compare_lin(240, pt_trim1) compare_lin(10, pt_trim1) q3(240, pt_trim1, pt_trim2) print("A_m = ", modal_form(pt_trim1)[0]) print("B_m = ", modal_form(pt_trim1)[1]) print("Les valeurs propres sont : ", stability(pt_trim1)) print("La matrice de commandabilité est Q= ", controllability(pt_trim1)) num, den, _ = transfer_function(pt_trim1) print("Les coefficients de la fonction de transfert sont : ") print("numérateur : ", num) print("dénominateur : ", den) num_pade, den_pade = Pade_reduction(pt_trim1) print("Les coefficients de la fonction de transfert réduite sont : ") print("numérateur : ", num_pade) print("dénominateur : ", den_pade) time = np.arange(0, 240, 0.2) plt.figure() step(num, den, time, "$F$") step(num_pade, den_pade, time, "$F_r$") plt.title("Réponse indicielle") plt.legend() plt.xlabel("time ($s$)") plt.ylabel("$\\theta$") plt.savefig(file + "reponse_indicielle" + format) plt.show() plt.figure() Bode([num, num_pade], [den, den_pade], ["$F$", "$F_r$"]) plt.savefig(file + "Bode" + format) plt.show()
def main(): PLANE = dynamic.Param_737_800() h = [3000, 10000] Ma = [0.4, 0.9] ms = [-0.2, 0.5] km = [0.1, 1] va0 = dynamic.va_of_mach(Ma[0], 0) va1 = dynamic.va_of_mach(Ma[1], 0) 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() 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 get_Cl(): Va = dynamic.va_of_mach(Ma[1], h[1]) PLANE.set_mass_and_static_margin(km[1], ms[1]) rho = utils.isa(h[1])[1] Cl = (PLANE.m * PLANE.g) / (0.5 * rho * PLANE.S * Va**2) return Cl def get_dth(): Cd = 0.030 # obtenu par lecture graphique à partir de la courbe polaire séance1 # Cl = 0.3706 : fct get_Cl() # alpha_eq = 3.66° : courbe q5 séance 1 # delat_THR_eq = -8.77° : courbe q4 séance1 f = get_Cl() / Cd F = PLANE.m * PLANE.g / f rho0 = utils.isa(h[1])[1] rho = utils.isa(h[1])[1] dth = F / (PLANE.F0 * (rho / rho0)**(0.6) * (0.568 + 0.25 * (1.2 - Ma[1])**3)) return dth def get_dPHR_alpha_num(): St_over_S = PLANE.St / PLANE.S CLta = PLANE.CLat CLwba = PLANE.CLa a0 = PLANE.a0 CL0 = (St_over_S * 0.25 * CLta - CLwba) * a0 CLa = CLwba + St_over_S * CLta * (1 - 0.25) #CLq = PLANE.lt*St_over_S*PLANE.CLat*PLANE.CLq CLdphr = St_over_S * CLta Cm0 = PLANE.Cm0 Cma = -PLANE.ms * CLwba Cmdphr = PLANE.Cmd CL = get_Cl() alpha_eq = (Cm0 - Cma * a0 + Cmdphr * (CL - CL0) / CLdphr) / (-Cma + Cmdphr * CLa / CLdphr) dphr_eq = (CL - CL0 - CLa * alpha_eq) / CLdphr return alpha_eq * 180 / pi, dphr_eq * 180 / pi 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 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 plot_h(n, vp): for j, Ma_j in enumerate(Ma): for k, ms_k in enumerate(ms): for l, km_l in enumerate(km): vp_Va = vp[:, j * (n - 1), k * (n - 1), l * (n - 1), 0] vp_a = vp[:, j * (n - 1), k * (n - 1), l * (n - 1), 1] vp_theta = vp[:, j * (n - 1), k * (n - 1), l * (n - 1), 2] vp_q = vp[:, j * (n - 1), k * (n - 1), l * (n - 1), 3] plt.figure() plt.title("$M_a={}, m_s={}, k_m={}, h\in [{},{}]$".format( Ma_j, ms_k, km_l, h[0], h[1])) decorate(vp_Va, vp_a, vp_theta, vp_q) if j == 0 and k == 1 and l == 1: plt.savefig(file + "vp_h" + format) plt.show() def plot_Ma(n, vp): for i, h_i in enumerate(h): for k, ms_k in enumerate(ms): for l, km_l in enumerate(km): vp_Va = vp[i * (n - 1), :, k * (n - 1), l * (n - 1), 0] vp_a = vp[i * (n - 1), :, k * (n - 1), l * (n - 1), 1] vp_theta = vp[i * (n - 1), :, k * (n - 1), l * (n - 1), 2] vp_q = vp[i * (n - 1), :, k * (n - 1), l * (n - 1), 3] plt.figure() plt.title("$h={}, m_s={}, k_m={}, M_a\in [{},{}]$".format( h_i, ms_k, km_l, Ma[0], Ma[1])) decorate(vp_Va, vp_a, vp_theta, vp_q) if i == 1 and k == 1 and l == 1: plt.savefig(file + "vp_Ma" + format) plt.show() def plot_ms(n, vp): for i, h_i in enumerate(h): for j, Ma_j in enumerate(Ma): for l, km_l in enumerate(km): vp_Va = vp[i * (n - 1), j * (n - 1), :, l * (n - 1), 0] vp_a = vp[i * (n - 1), j * (n - 1), :, l * (n - 1), 1] vp_theta = vp[i * (n - 1), j * (n - 1), :, l * (n - 1), 2] vp_q = vp[i * (n - 1), j * (n - 1), :, l * (n - 1), 3] plt.figure() plt.title("$h={}, M_a={}, k_m={}, m_s\in [{},{}]$".format( h_i, Ma_j, km_l, ms[0], ms[1])) decorate(vp_Va, vp_a, vp_theta, vp_q) if i == 1 and j == 0 and l == 1: plt.savefig(file + "vp_ms" + format) plt.show() def plot_km(n, vp): for i, h_i in enumerate(h): for j, Ma_j in enumerate(Ma): for k, ms_k in enumerate(ms): vp_Va = vp[i * (n - 1), j * (n - 1), k * (n - 1), :, 0] vp_a = vp[i * (n - 1), j * (n - 1), k * (n - 1), :, 1] vp_theta = vp[i * (n - 1), j * (n - 1), k * (n - 1), :, 2] vp_q = vp[i * (n - 1), j * (n - 1), k * (n - 1), :, 3] plt.figure() plt.title("$h={}, M_a={}, m_s={}, k_m\in [{},{}]$".format( h_i, Ma_j, ms_k, km[0], km[1])) decorate(vp_Va, vp_a, vp_theta, vp_q) if i == 1 and j == 0 and k == 1: plt.savefig(file + "vp_km" + format) plt.show() #q1() #q2() print("Au point de trim (h, Ma, ms, km)=(10000, 0.9, 0.5, 1), Cl = " + str(get_Cl())) print("Lecture graphique") print( "Cd = 0.030 obtenu par lecture graphique à partir de la courbe polaire séance1" ) print("alpha_eq = 3.66° : courbe q5 séance 1") print("delat_PHR_eq = -8.77° : courbe q4 séance1") print("on calcule dth : dth=" + str(get_dth())) print("Calcul numérique : ") print("dPHR = " + str(get_dPHR_alpha_num()[1])) print("alpha = " + str(get_dPHR_alpha_num()[0])) #simu() n = 10 vp = val_propre(n) plot_h(n, vp) plot_Ma(n, vp) plot_ms(n, vp) plot_km(n, vp)