Projet Are de Charlotte, Mehdi et Maxence

Pour conclure, nous avons pu voir a travers cette séquence d'ARE que mené a bien un projet d'une ampleur assez importante comme créer un programme informatique comme cela nous a été demandé , cela fu assez compliqué …

La première difficulté étant de réussir a s'adapter a un langage que nous ne maîtrisions pas et donc l'initiation ne traitez pas de manière concrète du sujet recherché (modélisation en 2D).

Néanmoins, le sujet était intéressant et le résultat était au rendez-vous car nous avons réussi a avoir un programme nous offrant une modélisation en 2D réussi du système solaire. De plus nous avons essayé de construire un programme structuré qui peut s'adapter a d'autre simulation d'environnement que notre système solaire comme cela a été crée dans notre version actuelle du programme... Enfin le programme offre des possibilités d'amélioration très intéressante bien que nous ne pouvions les exploiter par manque de temps comme la représentation des satellites des planète, la vitesse des planète en fonction de leur trajectoire elliptique (et non circulaire comme dans l'exemple) ou enfin avec des compétences plus poussé en Python nous aurions pu envisager de passer d'une modélisation en 2D a une modélisation en 3D .

import numpy as np

from matplotlib import pyplot as plt

from matplotlib import animation

from math import *

#ax = plt.axes(xlim=(0, 20), ylim=(0, 20))

#ax.set_title("Gravité", va='bottom')

# [distance au soleil en en million de km, période de révolution en jour terrestre,vitesse des planètes en million de km par jour terrestre : distance au soleil diviser par période de révolution donner par le tableau planete]

# on entre dans le tableau les données suivant les planète que l'on veu ici pour l'exemple nous avons pris les planète du système solaire

planete=[[57.9,87.97,'red',57.9/87.97], #Mercure

[108.2,224.701,'yellow',108.2/224.701], #Venus

[149.6,365.26,'green',149.6/365.26], #Terre

[227.9,686.98,'blue',227.9/686.98], #Mars

[778.3,4272.59,'red',778.3/4272.59], #Jupiter

[1427,10746.93,'yellow',1427/10746.93], #Saturne

[2877.38,30686.25,'green',2877.38/30686.25],#Uranus

[4497.07,60190,'blue',4497.07/60190], #Neptune

[5914.65,90583.49,'red',5914.65/90583.49] #Pluton

]

orbites =[]

nb_planete = 6

fig=plt.figure()

# bornes de la figure permettant de montrer les trajectoires des planètes voulu

ax = plt.axes(xlim=(-planete[nb_planete-1][0], planete[nb_planete-1][0]),ylim=(-planete[nb_planete-1][0], planete[nb_planete-1][0]))

#création d'un tableau avec l'orbite des planètes

def init_dessin_planetes():

for i in range(0, nb_planete):

plot_planete, = plot([],[],'o', color=planete[i][2])

orbites.append(plot_planete)

def init():

#dessin du soleil

plt.plot(0,0, 'o', color='yellow')

for i in range(0, nb_planete):

orbite = Circle((0,0), planete[i][0], color=planete[i][2], fill=False)

fig.gca().add_artist(orbite)

#calcul des positions des planètes au cours du temps

def position(t,r):

x = r*cos(2*pi*t)

y = r*sin(2*pi*t)

return [x,y]

def animate(i):

#faire varier la position des planète en fonction du temps

for j in range(0, nb_planete):

#faire varier la vitesse en fonstion des planètes

t=i*planete[j][3]/10

p = position(t, planete[j][0])

orbites[j].set_data(p[0], p[1])

return orbites

#appel de la fonstion pour dessiner les orbites

init_dessin_planetes()

ani = animation.FuncAnimation(fig, animate, init_func=init,interval=25, blit=True)

import numpy as np

from matplotlib import pyplot as plt

from matplotlib import animation

from math import *

#ax = plt.axes(xlim=(0, 20), ylim=(0, 20))

#ax.set_title("Gravité", va='bottom')

# [distance au soleil en en million de km, période de révolution en jour terrestre]

planete=[[57.9,87.97], #Mercure

[108.2,224.701], #Venus

[149.6,365.26], #Terre

[227.9,686.98], #Mars

[778.3,4272.59], #Jupiter

[1427,10746.93], #Saturne

[2877.38,30686.25],#Uranus

[4497.07,60190], #Neptune

[5914.65,90583.49] #Pluton

]

orbites =[]

#vitesse des planètes en million de km par jour terrestre : distance au soleil diviser par période de révolution donner par le tableau planete

dt=[[57.9/87.97],

[108.2/224.701],

[149.6/365.26],

[227.9/686.98],

[778.3/4272.59],

[1427/10746.93],

[2877.38/30686.25],

[4497.07/60190],

[5914.65/90583.49]

]

nb_planete = 9

fig=plt.figure()

# bornes de la figure permettant de montrer les trajectoires des planètes voulu

ax = plt.axes(xlim=(-planete[nb_planete-1][0], planete[nb_planete-1][0]),ylim=(-planete[nb_planete-1][0], planete[nb_planete-1][0]))

#création d'un tableau avec l'orbite des planètes

def init_dessin_planetes():

for i in range(0, nb_planete):

plot_planete, = plot([],[],'o', color='blue')

orbites.append(plot_planete)

def init():

#dessin du soleil

plt.plot(0,0, 'o', color='yellow')

for i in range(0, nb_planete):

orbite = Circle((0,0), planete[i][0], color="blue", fill=False)

fig.gca().add_artist(orbite)

#calcul des positions des planètes au cours du temps

def position(t,r):

x = r*cos(2*pi*t)

y = r*sin(2*pi*t)

return [x,y]

def animate(i):

#faire varier la position des planète en fonction du temps

for j in range(0, nb_planete):

#faire varier la vitesse en fonstion des planètes

t=i*dt[j][0]/10

p = position(t, planete[j][0])

orbites[j].set_data(p[0], p[1])

return orbites

#appel de la fonstion pour dessiner les orbites

init_dessin_planetes()

ani = animation.FuncAnimation(fig, animate, init_func=init,interval=25, blit=True)

Lors de la derniere séance nous avons mis nos différnetes recherches en commun: nous avons réussi a faire tourner un point autour d'un autre, selon un cercle apparraissant sur la figure.

Avec Maxence nous avons ensuite réussi a trouver ce qui faisait varier la vitesse dans ce programme: la valeur de i (voir ci-dessous. En effet plus i sera grand, plus la vitesse de rotation sera élevée.  

Pour la prochaine séance j'ai donc réfléchi a comment faire pour que la vitesse varie au cours du temps. j'ai alors pensé à jouer sur les coordonnées du point qui se déplace et à affecter une certaine valeur a i pour une certaine plage de coordonnées.

N'ayant pas encore vraiment trouvé de solution, nous allons travailler la dessus cette séance, ainsi que sur l'ajout d'un autre point en mouvement a une vitesse differente.

Cette semaine j'ai travailler sur le fait de pouvoir insérer le nombre de cercle à différents rayon :

import numpy as np
from matplotlib import pyplot as plt
from matplotlib import animation

ax = plt.axes(xlim=(0, 20), ylim=(0, 20))
ax.set_title("Gravité", va='bottom')

def crcle(rayon):
crcle = plt.Circle((10, 10), rayon, fc='white')
return plt.gca().add_patch(crcle)

crcle(5)
crcle(3)
crcle(2)

fig=plt.figure()
fig.set_dpi(100)
fig.set_size_inches(7, 6.5)

circle = plt.Circle((10, 10), 0.2, fc='yellow')

def init():
circle.center=(10, 10)
ax.add_patch(circle)
return circle,

def animate(i):
x, y= circle.center
x = 10+cos(radians(i*3))*3
y = 10+sin(radians(i*3))*3
circle.center=(x, y)
return circle,



ani = animation.FuncAnimation(fig, animate, init_func=init,interval=25, blit=True)

Seulement nous voudrions pouvoir faire tourner plusieurs point sur différents cercles pour l'instant nous avons un point au centre de plusieurs cercle avec un seul point tournant sur le cercle que l'on veut.

Il faudrait faire une fonction permettant de faire plusieurs point tournant en même temps. Peut être plusieurs fois la fonction init et plusieurs fois la fonction animate. comme cela :

import numpy as np
from matplotlib import pyplot as plt
from matplotlib import animation

ax = plt.axes(xlim=(0, 20), ylim=(0, 20))
ax.set_title("Gravité", va='bottom')

def crcle(rayon):
crcle = plt.Circle((10, 10), rayon, fc='white')
return plt.gca().add_patch(crcle)

crcle(5)
crcle(3)
crcle(2)

fig=plt.figure()
fig.set_dpi(100)
fig.set_size_inches(7, 6.5)

circle = plt.Circle((10, 10), 0.2, fc='yellow')

def init():
circle.center=(10, 10)
ax.add_patch(circle)
return circle,

def animate(i):
x, y= circle.center
x = 10+cos(radians(i*3))*3
y = 10+sin(radians(i*3))*3
circle.center=(x, y)
return circle,



ani = animation.FuncAnimation(fig, animate, init_func=init,interval=25, blit=True)

def init1():
circle.center=(10, 10)
ax.add_patch(circle)
return circle,

def animate1(i):
x, y= circle.center
x = 10+cos(radians(i*3))*5
y = 10+sin(radians(i*3))*5
circle.center=(x, y)
return circle,



ani = animation.FuncAnimation(fig, animate1, init_func=init1,interval=25, blit=True)

 Seulement bien que le programme marche cela ne donne pas le résultat voulu.

J'ai aussi réfléchie aux entrées dont nous pourrions avoir besoin :

• le rayon de la planète au centre 
• la vitesse de rotation
• le rayon des planètes satellites et centre 
• l'echelle

En sortie il nous faudra obtenir plusieurs cercles plusieurs points et un point qui tourne autour du centre de masse.

  Cette semaine comme tout les membres de mon groupe je me suis pencher sur la tâche suivante :

• écrire un code faisant tourner un point sur un cercle dont le centre est un autre point.

  Je n'ai pas réussis à faire cela mais j'ai réussis à faire tourner un cercle de couleur autour d'un cercle de même couleur grâce à des recherches que j'ai faites sur internant faisant intervenir deux fonction : init et anim. voici le code :

import numpy as np
from matplotlib import pyplot as plt
from matplotlib import animation

fig=plt.figure()
fig.set_dpi(100)
fig.set_size_inches(7, 6.5)

ax = plt.axes(xlim=(0, 20), ylim=(0, 20))
cercle = plt.Circle((0, 0), 0.2, fc='yellow')

def init():
cercle.center=(10, 10)
ax.add_patch(cercle)
return cercle,

def animate(i):
x, y= cercle.center
x = 10+cos(radians(i))*2
y = 10+sin(radians(i))*2
cercle.center=(x, y)
return cercle,

ani = animation.FuncAnimation(fig, animate, init_func=init,interval=25, blit=True)

plt.show()

  Sachant que medhi à écris un code permettant de faire un cercle nous allons essayer de faire une combinaison de nos deux codes afin d'obtenir le code faisant l'animation que nous voulions faire initialement.

Cette semaine nous avions pour but de réfléchir à comment creer un cercle autour d'un point et de faire tourner un autre point sur ce cercle. Nous étions tout les 4 charger d'essayer d'écrire un code et de mettre nos avancées sur framapad. Ainsi nous nous entraidions. Nous avons reussis à faire un cercle avec un point au milieu correspondant à un premier code. Nous avons réussis un deuxième code nous permettant d'avoir une boule qui tourne autour d'une autre. Dans les prochains nous essayerons de combiner ces deux codes afin d'obtenir une boule tournant autour d'une autre et ce déplaçant sur un cercle qui sera visible.

Mardi 11 Mars, nous avons choisi notre thème :Projet Simulation Mouvement.

Cette semaine, nous nous sommes posés des questions sur que nous faudrait-il. J'ai partagé les tâches en 4 j'avais donc pour but de réfléchir à qui ferait quoi, afin que chaque personne du groupe soit bien au courant du travail qu'il avait à effectuer. J'ai donc dis à Maxence de chercher toutes les données qui nous serait utile. Etant dans la partie a) et ayant choisi pour le cercle : Jupiter tournant autour du soleil les données utiles sont le rayon de jupiter au soleil le centre étant le soleil on l'initialise à (0,0). J'ai ensuite fais un dessin pour réfléchir avec Alexis à la manière dont nous allions procéder afin de modéliser Jupiter tournant autour du soleil et nous nous somme aperçu, que grâce à des formules nous pouvions créer des points en fonction des angles utilisés :  

Au cours de cette première semaine,

Je me suis occupé du blog, et me suis occupé des recherche commune du groupe nottament sur les lois de Kepler.

Le reste du groupe c'est quand a lui interessé a la prise des données necessaire au bon fonctionnement du programme d'un point de vue physique,tandis que d'autre on commencé a metre au point le code python

enfin nous avons créer un pad commun sur le site framapad qui nous sert de ressource commune pour toute les information reçu.

Mardi 11 Mars

Aujourd'hui, nous avons choisi notre projet qui est le projet de simulation de mouvement. Le but de ce projet est de modéliser en 3D une simulation de mouvment en 3D des planetes(exoplanete ou satellite).

Nous avons donc commencer a organiser note projet autour de differents axe : -> Preparation du projet a tavers le cahier de charge

->Preparation des bases du programme en Python (notament l'etude des differents Axe [x,y,z] ou encore trouver des solution offerte par le language pour tout modeliser en 3D[Blender]);

->Créatin d'un fichier ressource commun a l'aide du site framapad.

->On a etudier le système physique a metre en place ainsi que les parametres a prendre en place.

Nous nous somme organisé pour que chacun ai un axe de recherche, pour cette semaine Alexis doit s'interesser au code, Maxence doit s'occuper de la recherche de donné, Charlotte doit s'occuper du framapad et Mehdi s'ccuper du blog.