def corde_de_melde(base_name,w=1,k=1,L=1,A=0.1,tmax=10,N=1000,ylim=None):
"""
Produit un film (base_name + '_film.mpeg') d'une corde de Melde de
longueur L, fixée à droite et excitée à gauche par un moteur de pulsation
w imposant la propagation d'une onde d'amplitude de nombre d'onde k en
observant les réflexions régulière de l'onde jusqu'au temps tmax sur un
total de N images. Si ylim est précisé, il contiendra les limites
verticales, sinon c'est matplotlib qui décidera, ce qui déclenchera une
adaptation progressive de l'amplitude.
"""
t = np.linspace(0,tmax,N) # Échantillonnage en temps
for i,ti in enumerate(t): # On les prends l'un après l'autre
print(ti) # Un peu de feedback
fichier = base_name + '{:04d}'.format(i) # Nom du fichier
fait_corde(ti,file=fichier,w=w,k=k,L=L,A=A,ylim=ylim) # Dessin de la corde
film.make_film(base_name) # Fabrication du film à la fin
def corde_de_melde(base_name,
w=1,
k=1,
L=1,
A=0.1,
tmax=10,
N=1000,
ylim=None):
"""
Produit un film (base_name + '_film.mpeg') d'une corde de Melde de
longueur L, fixée à droite et excitée à gauche par un moteur de pulsation
w imposant la propagation d'une onde d'amplitude de nombre d'onde k en
observant les réflexions régulière de l'onde jusqu'au temps tmax sur un
total de N images. Si ylim est précisé, il contiendra les limites
verticales, sinon c'est matplotlib qui décidera, ce qui déclenchera une
adaptation progressive de l'amplitude.
"""
t = np.linspace(0, tmax, N) # Échantillonnage en temps
for i, ti in enumerate(t): # On les prends l'un après l'autre
print(ti) # Un peu de feedback
fichier = base_name + '{:04d}'.format(i) # Nom du fichier
fait_corde(ti, file=fichier, w=w, k=k, L=L, A=A,
ylim=ylim) # Dessin de la corde
film.make_film(base_name) # Fabrication du film à la fin
for xi,vi in zip(x0,v0): # Itération sur les conditions initiales
print(xi,vi) # Un peu de feedback
sol = sp.integrate.odeint(landau,[xi,vi],t) # On intègre
x.append(sol[:,0]) # et on stocke à la fois les positions
v.append(sol[:,1]) # et les vitesses
fig = plt.figure(figsize=(10,10)) # Création de la figure
vlim = (np.min(v),np.max(v)) # Limites verticales (horizontales imposées par les CI)
base_name='PNG/M4_oscillateur_de_landau_tilte_portrait_de_phase'
for i,ti in enumerate(t): # On regarde à chaque instant d'intégration
print(ti) # Un peu de feedback
xi = [xp[:i+1] for xp in x] # On stocke l'avancement
vi = [vp[:i+1] for vp in v] # jusqu'à l'instant présent
plt.suptitle('Oscillateur de Landau tilte, $t={}$'.format(round(ti,2)))
plt.subplot(2,1,1) # Première sous-figure
portrait_de_phase(xi,vi,fantome=50,clearfig=False,color=colors,ylim=vlim)
plt.xlabel('')
plt.subplot(2,1,2) # Seconde sous-figure
diagramme_energetique(xi,vi,Em,color=colors,clearfig=False,fantome=50)
plt.savefig('{}_{:04d}.png'.format(base_name,i))
plt.clf()
from film import make_film # Boîte à outil visuelle
make_film(base_name) # et fabrication du film correspondant
x = np.linspace(0, 1, 100)
plt.plot(x, f(x, k), 'k', linewidth=2)
plt.plot(x, x, 'k', linewidth=2)
plt.plot(double[1:-1], double[2:])
plt.title('$k={:.4f}$'.format(k))
araignee.savefig(base_name + '_{}_{:04d}'.format(suffix, i))
plt.close(araignee)
fig = plt.figure() # Initialisation de la figure principale
feigenbaum = fig.gca() # Récupération de "l'axe"
k_list = np.linspace(kmin, kmax, nb_points)
for i, k in enumerate(k_list): # Pour toutes les valeurs de la liste des k
avant, dans = get_cycle(k, u0) # on récupère le cycle et on l'affiche
feigenbaum.plot([k] * len(dans), dans, '.k', markersize=1)
graphique_araignee(avant, k, i) # Fabrication du graphique "en araignée"
graphique_araignee(dans, k, i, 'apres')
if ylim: feigenbaum.set_ylim(ylim) # Rajout des limites verticales
feigenbaum.set_xlim(kmin, kmax) # et horizontales de la figure principale
feigenbaum.set_title('Figuier de Feigenbaum')
feigenbaum.set_xlabel('$k$')
feigenbaum.set_ylabel('$x$ limite')
fig.savefig('PNG/misc_feigenbaum.png') # Sauvegarde
# Reste à faire les petits films correspondants aux graphes en araignées
film.make_film(base_name + '_avant')
film.make_film(base_name + '_apres', PNM='PPM')
base_name = 'PNG/M4_pendule_simple_portrait_de_phase_zoom'
for i, ti in enumerate(t): # Affichage progressif
print(ti) # Un peu de feed back
thi = [th_p[:i + 1] for th_p in th] # On ne prend que jusqu'�
thpi = [thp_p[:i + 1] for thp_p in thp] # l'instant présent
plt.suptitle('Pendule simple, $t={}$'.format(round(ti, 2)))
plt.subplot(2, 1, 1) # Sous-figure du haut
portrait_de_phase(thi,
thpi,
fantome=20,
clearfig=False,
color=colors,
xlim=th_lim,
ylim=thp_lim)
plt.xlabel('')
plt.subplot(2, 1, 2) # Sous-figure du bas
diagramme_energetique(thi,
thpi,
Em,
color=colors,
clearfig=False,
fantome=20,
xlim=th_lim)
plt.savefig('{}_{:04d}.png'.format(base_name, i))
plt.clf() # Nettoyage
from film import make_film # Boîte à outil pour faire un film
make_film(base_name) # et appel effectif
x2 = 5 # Position de la deuxième source (première en 0)
xmin,xmax = 0,x2 # Limites de la fenêtre d'échantillonnage
nb_points = 1000 # Nombre de points d'échantillonnage
phi = np.pi/2 # Déphasage de la deuxième source
tmin,tmax = 0,60 # L'intervalle de temps d'étude
dt = 0.1 # Incrément de temps
base_name = 'PNG/S03_ondes_stationnaires'
t = tmin
i = 0
while t < tmax: # On commence la boucle temporelle
print(t) # Un peu de feedback
x = np.linspace(xmin,xmax,nb_points) # Échantillonnage horizontal
S1= source(x,t,0) # Effet de la première source
S2= source(x,t,x2,phi) # Effet de la seconde source
S = S1+S2 # Effet résultant
plt.plot(x,S1,alpha=0.5) # Affichage première source (bleu)
plt.plot(x,S2,alpha=0.5) # Affichage seconde source (vert)
plt.plot(x,S,'k',linewidth=2) # Affichage résultante (noir)
plt.ylim(-2,2) # On contraint l'échelle verticale
plt.savefig(base_name + '_{:04d}.png'.format(i)) # Sauvegarde
plt.clf() # Nettoyage
i+= 1 # et incrémentation
t+=dt # des compteurs
film.make_film(base_name) # Fabrication du film à la fin
fig = plt.figure(figsize=(10, 10)) # Création de la figure
# Limites verticales (horizontales imposées par les CI)
vlim = (np.min(v), np.max(v))
base_name = 'PNG/M4_oscillateur_de_landau_portrait_de_phase'
for i, ti in enumerate(t): # On regarde à chaque instant d'intégration
print(ti) # Un peu de feedback
xi = [xp[:i + 1] for xp in x] # On stocke l'avancement
vi = [vp[:i + 1] for vp in v] # jusqu'à l'instant présent
plt.suptitle('Oscillateur de Landau, $t={}$'.format(round(ti, 2)))
plt.subplot(2, 1, 1) # Première sous-figure
portrait_de_phase(xi,
vi,
fantome=50,
clearfig=False,
color=colors,
ylim=vlim)
plt.xlabel('')
plt.subplot(2, 1, 2) # Seconde sous-figure
diagramme_energetique(xi, vi, Em, color=colors, clearfig=False, fantome=50)
plt.savefig('{}_{:04d}.png'.format(base_name, i))
plt.clf()
from film import make_film # Boîte à outil visuelle
make_film(base_name) # et fabrication du film correspondant
os.system("pause")
plt.plot(double[1:-1],double[2:])
plt.title('$k={:.4f}$'.format(k))
araignee.savefig(base_name + '_{}_{:04d}'.format(suffix,i))
plt.close(araignee)
fig = plt.figure() # Initialisation de la figure principale
feigenbaum = fig.gca() # Récupération de "l'axe"
k_list = np.linspace(kmin,kmax,nb_points)
for i,k in enumerate(k_list): # Pour toutes les valeurs de la liste des k
avant,dans = get_cycle(k,u0) # on récupère le cycle et on l'affiche
feigenbaum.plot([k]*len(dans),dans,'.k',markersize=1)
graphique_araignee(avant,k,i) # Fabrication du graphique "en araignée"
graphique_araignee(dans,k,i,'apres')
if ylim: feigenbaum.set_ylim(ylim)# Rajout des limites verticales
feigenbaum.set_xlim(kmin,kmax) # et horizontales de la figure principale
feigenbaum.set_title('Figuier de Feigenbaum')
feigenbaum.set_xlabel('$k$')
feigenbaum.set_ylabel('$x$ limite')
fig.savefig('PNG/misc_feigenbaum.png') # Sauvegarde
# Reste à faire les petits films correspondants aux graphes en araignées
film.make_film(base_name + '_avant')
film.make_film(base_name + '_apres',PNM='PPM')
xlim=th_lim)
plt.xlabel('')
plt.subplot(2, 1, 2) # Sous-figure du bas
diagramme_energetique(thi,
thpi,
Em,
color=colors,
clearfig=False,
fantome=20,
xlim=th_lim)
plt.savefig('{}_{:04d}.png'.format(base_name, i))
plt.clf() # Nettoyage
from film import make_film # Boîte à outil pour faire un film
make_film(base_name) # et appel effectif
# On peut aussi regarder juste sur juste 2pi d'intervalle, avec les mêmes
# résultats
for theta in th: # On sait que theta est déjà entre -3pi et 3pi
theta[theta > np.pi] = theta[theta > np.pi] - 2 * np.pi
theta[theta < -np.pi] = theta[theta < -np.pi] + 2 * np.pi
fig = plt.figure(figsize=(10, 10)) # Définition de la figure
th_lim = (np.min(th), np.max(th)) # Nouvelles limites en theta
base_name = 'PNG/M4_pendule_simple_portrait_de_phase_2pi'
for i, ti in enumerate(t): # On regarde à chaque instant
print(ti) # Un peu de feedback
sol = sp.integrate.odeint(pendule, [thi, thpi], t) # Intégration
th.append(sol[:, 0]) # Ajout des positions
thp.append(sol[:, 1]) # et vitesses correspondantes
fig = plt.figure(figsize=(10, 10)) # Création de la figure
th_lim = (np.min(th), np.max(th)) # Limites en theta
thp_lim = (np.min(thp), np.max(thp)) # Limites en theta point
base_name = 'PNG/M4_pendule_simple_portrait_de_phase_zoom'
for i, ti in enumerate(t): # Affichage progressif
print(ti) # Un peu de feed back
thi = [th_p[:i + 1] for th_p in th] # On ne prend que jusqu'à
thpi = [thp_p[:i + 1] for thp_p in thp] # l'instant présent
plt.suptitle('Pendule simple, $t={}$'.format(round(ti, 2)))
plt.subplot(2, 1, 1) # Sous-figure du haut
portrait_de_phase(thi, thpi, fantome=20, clearfig=False,
color=colors, xlim=th_lim, ylim=thp_lim)
plt.xlabel('')
plt.subplot(2, 1, 2) # Sous-figure du bas
diagramme_energetique(thi, thpi, Em, color=colors,
clearfig=False, fantome=20, xlim=th_lim)
plt.savefig('{}_{:04d}.png'.format(base_name, i))
plt.clf() # Nettoyage
from film import make_film # Boîte à outil pour faire un film
make_film(base_name) # et appel effectif
os.system("pause")
return res
x2 = 5 # Position de la deuxième source (première en 0)
xmin, xmax = 0, x2 # Limites de la fenêtre d'échantillonnage
nb_points = 1000 # Nombre de points d'échantillonnage
phi = np.pi / 2 # Déphasage de la deuxième source
tmin, tmax = 0, 60 # L'intervalle de temps d'étude
dt = 0.1 # Incrément de temps
base_name = 'PNG/S03_ondes_stationnaires'
t = tmin
i = 0
while t < tmax: # On commence la boucle temporelle
print(t) # Un peu de feedback
x = np.linspace(xmin, xmax, nb_points) # Échantillonnage horizontal
S1 = source(x, t, 0) # Effet de la première source
S2 = source(x, t, x2, phi) # Effet de la seconde source
S = S1 + S2 # Effet résultant
plt.plot(x, S1, alpha=0.5) # Affichage première source (bleu)
plt.plot(x, S2, alpha=0.5) # Affichage seconde source (vert)
plt.plot(x, S, 'k', linewidth=2) # Affichage résultante (noir)
plt.ylim(-2, 2) # On contraint l'échelle verticale
plt.savefig(base_name + '_{:04d}.png'.format(i)) # Sauvegarde
plt.clf() # Nettoyage
i += 1 # et incrémentation
t += dt # des compteurs
film.make_film(base_name) # Fabrication du film à la fin
thi = [th_p[:i + 1] for th_p in th] # On ne prend que jusqu'à
thpi = [thp_p[:i + 1] for thp_p in thp] # l'instant présent
plt.suptitle('Pendule simple, $t={}$'.format(round(ti, 2)))
plt.subplot(2, 1, 1) # Sous-figure du haut
portrait_de_phase(thi, thpi, fantome=20, clearfig=False,
color=colors, xlim=th_lim)
plt.xlabel('')
plt.subplot(2, 1, 2) # Sous-figure du bas
diagramme_energetique(thi, thpi, Em, color=colors,
clearfig=False, fantome=20, xlim=th_lim)
plt.savefig('{}_{:04d}.png'.format(base_name, i))
plt.clf() # Nettoyage
from film import make_film # Boîte à outil pour faire un film
make_film(base_name) # et appel effectif
# On peut aussi regarder juste sur juste 2pi d'intervalle, avec les mêmes
# résultats
for theta in th: # On sait que theta est déjà entre -3pi et 3pi
theta[theta > np.pi] = theta[theta > np.pi] - 2 * np.pi
theta[theta < -np.pi] = theta[theta < -np.pi] + 2 * np.pi
fig = plt.figure(figsize=(10, 10)) # Définition de la figure
th_lim = (np.min(th), np.max(th)) # Nouvelles limites en theta
base_name = 'PNG/M4_pendule_simple_portrait_de_phase_2pi'
for i, ti in enumerate(t): # On regarde à chaque instant
# et celle de la droite
ax3= plt.subplot2grid((3,3),(0,2),rowspan=2,sharey=ax1)
plt.xlabel('Intensite')
plt.xlim((0,vmax**2))
plt.title('Section $x={}$'.format(xcut))
plt.plot((source(xcut,y,t,-pos,0)+source(xcut,y,t,pos,0,phi))**2,y)
plt.savefig(base_name + '_{:04d}.png'.format(i))
plt.close()
# Ne reste plus qu'à rassembler en un fichier mpeg à l'aide de convert puis de
# ppmtoy4m et mpeg2enc (paquet mjpegtools à installer sur la machine)
from film import make_film
make_film(base_name,resize="700x500")
#import os
#
#cmd = '(for f in ' + base_name + '*png ; '
#cmd+= 'do convert -density 100x100 $f -depth 8 -resize 700x500 PNM:- ; done)'
#cmd+= ' | ppmtoy4m -S 420mpeg2'
#cmd+= ' | mpeg2enc -f1 -b 12000 -q7 -G 30 -o {}film.mpeg'.format(base_name)
#
#print("Execution de la commande de conversion")
#print(cmd)
#os.system(cmd)
#print("Fin de la commande de conversion")
# et celle de la droite
ax3= plt.subplot2grid((3,3),(0,2),rowspan=2,sharey=ax1)
plt.xlabel('Intensite')
plt.xlim((0,vmax**2))
plt.title('Section $x={}$'.format(xcut))
plt.plot((source(xcut,y,t,-pos,0)+source(xcut,y,t,pos,0,phi))**2,y)
plt.savefig(base_name + '_{:04d}.png'.format(i))
plt.close()
# Ne reste plus qu'à rassembler en un fichier mpeg à l'aide de convert puis de
# ppmtoy4m et mpeg2enc (paquet mjpegtools à installer sur la machine)
from film import make_film
make_film(base_name,resize="700x500")
#import os
#
#cmd = '(for f in ' + base_name + '*png ; '
#cmd+= 'do convert -density 100x100 $f -depth 8 -resize 700x500 PNM:- ; done)'
#cmd+= ' | ppmtoy4m -S 420mpeg2'
#cmd+= ' | mpeg2enc -f1 -b 12000 -q7 -G 30 -o {}film.mpeg'.format(base_name)
#
#print("Execution de la commande de conversion")
#print(cmd)
#os.system(cmd)
#print("Fin de la commande de conversion")
