def plot_CL(P, filename=None): alphas = np.linspace(ut.rad_of_deg(-10), ut.rad_of_deg(20), 30) dms = np.linspace(ut.rad_of_deg(20), ut.rad_of_deg(-30), 3) figure = ut.prepare_fig(None, u'Coefficient de Portance {}'.format(P.name)) for dm in dms: plt.plot(ut.deg_of_rad(alphas), CL(P, alphas, dm)) ut.decorate(plt.gca(), u'Coefficient de Portance', r'$\alpha$ en degres', '$C_L$') plt.legend(['$\delta _{{PHR}} = ${:.1f}'.format(ut.deg_of_rad(dm)) for dm in dms], loc='best') if filename<> None: plt.savefig(filename, dpi=160)
def plot_dphr_e(P, filename=None): alphas = np.linspace(ut.rad_of_deg(-10), ut.rad_of_deg(20), 30) mss = [-0.1, 0., 0.2, 1.] figure = ut.prepare_fig(None, u'Équilibre {}'.format(P.name)) for ms in mss: P.set_mass_and_static_margin(0.5, ms) dmes = np.array([dphr_e(P, alpha) for alpha in alphas]) plt.plot(ut.deg_of_rad(alphas), ut.deg_of_rad(dmes)) ut.decorate(plt.gca(), r'$\delta_{PHR_e}$', r'$\alpha$ en degres', r'$\delta_{PHR_e}$ en degres', ['$ms = ${: .1f}'.format(ms) for ms in mss])
def dphre_vt( va, q, P, alpha, nb, ms, coeff ): #dphre en fonction de de l'incidence alpha e ,(idem que precedemment, coefficient pour volume d'empennage Vt) angle_alpha = np.linspace(alpha[0], alpha[1], nb) P.set_mass_and_static_margin(P.m_k, ms) dphre = np.array([ -(P.Cm0 - ms * P.CLa * (k - P.a0) + P.Cmq * P.lt / va * q) / (P.Cmd * coeff) for k in angle_alpha ]) return utils.deg_of_rad(angle_alpha), utils.deg_of_rad( dphre) #angle alpha et dphre en degré
def plot(time, X, U=None, figure=None, window_title="Trajectory"): figure = ut.prepare_fig(figure, window_title, (20.48, 10.24)) plots = [("$y$", "m", X[:, s_y], None), ("$h$", "m", X[:, s_h], 2.), ("$v_a$", "m/s", X[:, s_va], 1.), ("$\\alpha$", "deg", ut.deg_of_rad(X[:, s_a]), 2.), ("$\\theta$", "deg", ut.deg_of_rad(X[:, s_th]), 2.), ("$q$", "deg/s", ut.deg_of_rad(X[:, s_q]), 2.)] for i, (title, ylab, data, min_yspan) in enumerate(plots): ax = plt.subplot(3, 2, i + 1) plt.plot(time, data) ut.decorate(ax, title=title, ylab=ylab, min_yspan=min_yspan) return figure
def plot_Cm(P, filename=None): alphas = np.linspace(ut.rad_of_deg(-10), ut.rad_of_deg(20), 30) mss = np.array([-0.1, 0, 0.2, 1]) figure = ut.prepare_fig(None, u'Coefficient du moment de tangage {}'.format(P.name)) for ms1 in mss: plt.plot(ut.deg_of_rad(alphas), Cm(P, alphas, ms1)) ut.decorate(plt.gca(), u'Coefficient du moment de tangage', r'$\alpha$ en degres', '$C_m$') plt.legend(['ms = {}'.format(ms) for ms in mss], loc='best') if filename<> None: plt.savefig(filename, dpi=160)
def plot_all(time, X, U, Yc=None, figure=None, window_title="trajectory"): margins = (0.04, 0.05, 0.98, 0.96, 0.20, 0.34) figure = utils.prepare_fig(figure, window_title, figsize=(0.75 * 20.48, 0.75 * 10.24), margins=margins) plots = [("x", "m", X[:, Plant.s_x]), ("xd", "m/s", X[:, Plant.s_xd]), ("$\\theta$", "deg", utils.deg_of_rad(X[:, Plant.s_theta])), ("$\\theta d$", "deg/s", utils.deg_of_rad(X[:, Plant.s_thetad])), ("$\\tau$", "N.m", U[:, Plant.i_t])] for i, (title, ylab, data) in enumerate(plots): ax = plt.subplot(len(plots), 1, i + 1) plt.plot(time, data, linewidth=2) utils.decorate(ax, title=title, ylab=ylab) if Yc is not None: plt.subplot(len(plots), 1, 1) plt.plot(time, Yc, linewidth=2) return figure
def get_Cm_alpha( va, q, dphr, P, alpha, nb, ms ): # calcule Cm en fonction de l'angle d'incidence alpha, (vitesse m/s, vitesse de tangage rad/sec, angle de braquage de l'empennage horizontal en rad, intervalle d'incidnce alpha rad, nombre de points) angle_alpha = np.linspace(alpha[0], alpha[1], nb) Cm = np.array([ P.Cm0 - ms * P.CLa * (k - P.a0) + P.Cmq * P.lt / va * q + P.Cmd * dphr for k in angle_alpha ]) return utils.deg_of_rad(angle_alpha), Cm #angle alpha en degré
def get_CL_alpha( va, q, dphr, P, alpha, nb ): # calcule CL en fonction de l'angle d'incidence alpha , (vitesse m/s,vitesse de tangage rad/sec, angle de braquage de l'empennage horozontal en rad, intervalle d'incidnce alpha rad, nombre de points) angle_alpha = np.linspace(alpha[0], alpha[1], nb) CL = np.array([ dynamic.get_aero_coefs(va, alpha, q, dphr, P)[0] for alpha in angle_alpha ]) return utils.deg_of_rad(angle_alpha), CL #angle_alpha en degré
def CLE_alpha(va, q, P, alpha, nb, ms): angle_alpha = np.linspace(interv_alpha[0], interv_alpha[1], nb) dphr = np.array([ -(P.Cm0 - ms * P.CLa * (k - P.a0) + P.Cmq * P.lt / va * q) / P.Cmd for k in angle_alpha ]) CLE = np.array([ dynamic.get_aero_coefs(va, alpha, q, dphr[i], P)[0] for i, alpha in enumerate(angle_alpha) ]) return utils.deg_of_rad(angle_alpha), CLE
def plot_CLe(P): alphas = np.linspace(ut.rad_of_deg(-10), ut.rad_of_deg(20), 30) figure = ut.prepare_fig(None, u'Coefficient de portance équilibrée {}'.format(P.name)) sms = [0.2, 1] for sm in sms: P.set_mass_and_static_margin(0.5, sm) dphres = [dphr_e(P, alpha) for alpha in alphas] CLes = [CL(P, alpha, dphr) for alpha, dphr in zip(alphas, dphres)] plt.plot(ut.deg_of_rad(alphas), CLes) ut.decorate(plt.gca(), u'Coefficient de portance équilibrée', r'$\alpha$ en degres', r'$CL_e$', ['$ms = ${: .1f}'.format(sm) for sm in sms])
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 plot_all_trims(aircraft, hs, Mas, sms, kms, trims, filename=None): ''' Affichage graphique des valeurs de trim ''' margins = (0.03, 0.05, 0.98, 0.95, 0.15, 0.46) fig = ut.prepare_fig(window_title='Trims {}'.format(aircraft.name), figsize=(20.48, 10.24), margins=margins) m=0 for k, sm in enumerate(sms): for l,km in enumerate(kms): for i, h in enumerate(hs): for j, Ma in enumerate(Mas): alpha, dphr, dth = trims[i, j, k, l] fmt = 'alt {:5.0f} Ma {:.1f} sm {:.1f} km {:.1f} -> alpha {:5.2f} deg phr {:-5.1f} deg throttle {:.1f} %' print fmt.format(h, Ma, sm, km, ut.deg_of_rad(alpha), ut.deg_of_rad(dphr), 100*dth) legend, params = ['Mach {}'.format(Ma) for Ma in Mas], r'\quad sm={} \quad km={}'.format(sm, km) ax = plt.subplot(4, 3, 3*m+1) plt.plot(hs, ut.deg_of_rad(trims[:, 0, k, l, 0])) plt.plot(hs, ut.deg_of_rad(trims[:, 1, k, l, 0])) ut.decorate(ax, r'$\alpha {}$'.format(params), r'altitude', '$deg$', legend=legend) ax = plt.subplot(4, 3, 3*m+2) plt.plot(hs, ut.deg_of_rad(trims[:, 0, k, l, 1])) plt.plot(hs, ut.deg_of_rad(trims[:, 1, k, l, 1])) ut.decorate(ax, r'$\delta_{{PHR}} {}$'.format(params), r'altitude', '$deg$', legend=legend) ax = plt.subplot(4, 3, 3*m+3) plt.plot(hs, trims[:, 0, k, l, 2]*100) plt.plot(hs, trims[:, 1, k, l, 2]*100) ut.decorate(ax, r'$\delta_{{th}} {}$'.format(params), r'altitude', '$\%$', legend=legend) m = m+1 if filename<> None: plt.savefig(filename, dpi=160)
def affiche(): for i in range(len(ms)): for j in range(len(km)): for k in range(len(Ma)): plt.suptitle('ms=' + str(ms[i]) + ', km=' + str((km[j]))) plt.subplot(1, 4, 1) plt.title("alpha") plt.plot(h1, utils.deg_of_rad(alphatrim[i, j, k, :]), label="Mach = " + str(Ma[k]) + "") plt.ylabel('alpha en degre') plt.xlabel('altitude en m') plt.legend() plt.subplot(1, 4, 2) plt.title("dphr") plt.plot(h1, utils.deg_of_rad(dphrtrim[i, j, k, :]), label="Mach = " + str(Ma[k]) + "") plt.ylabel('dphr en degre') plt.xlabel('altitude en m') plt.legend() plt.subplot(1, 4, 3) plt.title("dth") plt.plot(h1, dthtrim[i, j, k, :], label="Mach = " + str(Ma[k]) + "") plt.ylabel('dth') plt.xlabel('altitude en m') plt.legend() for l in range(len(h)): plt.subplot(1, 4, 4) plt.title("poussee") plt.plot(Ma1, prop[i, j, :, l], label="altitude = " + str(h[l]) + "") plt.ylabel('poussee en N') plt.xlabel('Mach') plt.legend() plt.show()
def CLE_alpha( va, q, P, alpha, nb, ms ): #coefficident de portance equilibrée Cle lorsque dphr=dphre, (idem) angle_alpha = np.linspace(alpha[0], alpha[1], nb) dphr = np.array([ -(P.Cm0 - ms * P.CLa * (k - P.a0) + P.Cmq * P.lt / va * q) / P.Cmd for k in angle_alpha ]) CLE = np.array([ dynamic.get_aero_coefs(va, alpha, q, dphr[i], P)[0] for i, alpha in enumerate(angle_alpha) ]) return utils.deg_of_rad(angle_alpha), CLE
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 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 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
dynamic.get_aero_coefs(va, alpha, q, dphr, P)[0] for alpha in angle_alpha ]) return utils.deg_of_rad(angle_alpha), CL #angle_alpha en degré interv_alpha = [-10 * math.pi / 180, 20 * math.pi / 180] #intervalle d'incidence alpha en rad dphr = [-30 * math.pi / 180, +20 * math.pi / 180] #valeurs de dphr en rad cl = plt.figure() for i in dphr: alpha, CL = get_CL_alpha(va, q, i, avion, interv_alpha, nb_points) plt.plot(alpha, CL, label="dphr=" + str(utils.deg_of_rad(i)) + " degre", figure=cl) plt.xlabel("Angle d'incidence alpha en degre") plt.ylabel("Coefficient de portance CL") plt.title("CL en fonction \n d'alpha ") plt.legend() plt.show() '''''' '' def get_Cm_alpha( va, q, dphr, P, alpha, nb, ms ): # calcule Cm en fonction de l'angle d'incidence alpha, (vitesse m/s, vitesse de tangage rad/sec, angle de braquage de l'empennage horizontal en rad, intervalle d'incidnce alpha rad, nombre de points) angle_alpha = np.linspace(alpha[0], alpha[1], nb) Cm = np.array([ P.Cm0 - ms * P.CLa * (k - P.a0) + P.Cmq * P.lt / va * q + P.Cmd * dphr
ut.decorate(plt.gca(), u'Coefficient de portance équilibrée', r'$\alpha$ en degres', r'$CL_e$', ['$ms = ${: .1f}'.format(sm) for sm in sms]) def plot_polar(P): alphas = np.linspace(ut.rad_of_deg(-10), ut.rad_of_deg(20), 30) figure = ut.prepare_fig(None, u'Polaire équilibrée{}'.format(P.name)) sms = [0.2, 1] for sm in sms: P.set_mass_and_static_margin(0.5, sm) dphres = [dphr_e(P, alpha) for alpha in alphas] CLes = [CL(P, alpha, dphr) for alpha, dphr in zip(alphas, dphres)] CDes = [P.CD0 + P.ki * CL1**2 for CL1 in CLes] plt.plot(CDes, CLes) ut.decorate(plt.gca(), u'Polaire équilibrée', r'$CD_e$', r'$CL_e$', ['$ms = ${: .1f}'.format(sm) for sm in sms]) aircraft = dyn.Param_737_300() # use assigned aircraft # plot_thrust(aircraft) # plot_CL(aircraft) # plot_Cm(aircraft) #plot_dphr_e(aircraft) #plot_CLe(aircraft) #plot_polar(aircraft) #plt.show() print(dphr_e(aircraft, 0)) print(CL(aircraft,0.06, dphr_e(aircraft,0))) print(ut.deg_of_rad(0.06))
valeur_trim = alphatrim[0, 0, 0, 0], dphrtrim[0, 0, 0, 0], dthtrim[0, 0, 0, 0] point_trim = [3000.0, 0.4, -0.2, 0.1] h_trim, Ma_trim, ms_trim, km_trim = point_trim p_trim, rho_trim, T_trim = utils.isa(h_trim) avion.set_mass_and_static_margin(km_trim, ms_trim) va_trim = dynamic.va_of_mach(Ma_trim, h_trim, k=1.4, Rs=287.05) Cl = 2 * avion.m * avion.g / (rho_trim * avion.S * va_trim**2) interv_alpha = [-10 * math.pi / 180, 20 * math.pi / 180] alpha, CLE = CLE_alpha(va_trim, 0, avion, interv_alpha, 100, ms_trim) alphatrim_0 = valeur_trim[0] alphatrim_0 = float(int(utils.deg_of_rad(alphatrim_0 * 1000 + 0.5)) / 1000) Cl = float(int(Cl * 1000 + 0.5)) / 1000 alpha, dphr = dpha_alpha(va_trim, 0, avion, interv_alpha, 100, ms_trim) dphrtrim_1 = valeur_trim[1] dphrtrim_1 = float(int(utils.deg_of_rad(dphrtrim_1 * 1000 + 0.5))) / 1000 # CLE function of alpha plt = plot( alpha, CLE, "CLE en fonction \n d'alphae", "ms = " + str(ms_trim) + ", km = " + str(km_trim) + ", Ma = " + str(Ma_trim), "Alphae (deg)", "CLE", (alpha[0], alpha[nb - 1]), (CLE[0], CLE[nb - 1])) row_cl = [Cl] * nb idx = np.argwhere(np.diff(np.sign(CLE - row_cl)) != 0).reshape(-1)
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()