Gravitation universelle

Télécharger le projet
Commenter

Description

Ce code permet de calculer la gravitation exercé entre 3 corps selon leur masse et la distance qu'il y a entre chacun d'entre eux.
Tout ceci est rendu possible à l'aide d'une interface graphique programmé grâce à la bibliothèque Tkinter de python.

Les possibilités sont les suivantes :
  • Déplacer les corps dans le canevas en ayant pris soin de sélectionner le corps voulu à l'aide de son bouton lui correspondant qui est également de la même couleur que lui.
  • Définir la masse de chaque corps ainsi que l'échelle de la distance exprimé entre chaque corps

Source / Exemple : 


# -*- coding: cp1252 -*-
#Simulation du phenomene de gravitation universelle

from Tkinter import *
from math import sqrt

# ---------- Déclaration de fonctions locales -----------------

def distance(x1, y1, x2, y2):                               #Cette fonction va nous permettre de calculer la distance entre chaque corps
    d=sqrt((x2-x1)**2+(y2-y1)**2)
    return d

def forceG(m1, m2, di):                                         #Cette fonction va nous permettre de calculer la force exercée entre chaque corps
    return m1*m2*6.67e-11/di**2

def echell(event):                                                      #Echelle de distance entre les corps
    global echelle
    echelle=float(entr4.get())*1000
    return echelle
  
#Les trois fonctions suivantes vont permettre de redéfinir la masse de chaque corps relatif au champ de saisi correspondant

def masse1(event):
    global m1
    f=0
    m1=float(entr1.get())
    di=distance(x[0],y[0],x[1],y[1])
    di2=distance(x[0],y[0],x[2],y[2])
    di=di*echelle
    di2=di2*echelle
    u12,v12=((x[1]-x[0])/di),((y[1]-y[0])/di)
    u13,v13=((x[2]-x[0])/di2),((y[2]-y[0])/di2)   
    f1=forceG(m1,m2,di)
    f2=forceG(m1,m3,di2)
    f=sqrt((f1*u12+f2*u13)**2+(f1*v12+f2*v13)**2)
    valDis.configure(text="Distance avec corps 2 = " +str(di)+" m")
    valDis2.configure(text=" Distance avec corps 3 = " +str(di2)+" m")
    valFor.configure(text="Force exercée sur l'astre sélectionné = " +str(f)+" N")
    valMass1.configure(text="Masse du corps 1 = "+str(eval(entr1.get()))+" Kg")
   

def masse2(event):
    global m2
    f=0
    m2=float(entr2.get())
    di=distance(x[1],y[1],x[0],y[0])
    di2=distance(x[1],y[1],x[2],y[2])
    di=di*echelle
    di2=di2*echelle
    u21,v21=((x[0]-x[1])/di),((y[0]-y[1])/di)
    u23,v23=((x[2]-x[1])/di2),((y[2]-y[1])/di2)
    f1=forceG(m2, m1, di)
    f2=forceG(m2,m3,di2)
    f=sqrt((f1*u21+f2*u23)**2+(f1*v21+f2*v23)**2)
    
    valDis.configure(text="Distance avec corps 1 = " +str(di)+" m")
    valDis2.configure(text=" Distance avec corps 3 = " +str(di2)+" m")
    valFor.configure(text="Force exercée sur le corps sélectionné = " +str(f)+" N")
    valMass2.configure(text="Masse du corps 2 = "+str(eval(entr2.get()))+" Kg")
 
def masse3(event):
    global m3
    f=0
    m3=float(entr3.get())
    di=distance(x[2],y[2],x[0],y[0])
    di2=distance(x[2],y[2],x[1],y[1])
    di=di*echelle
    di2=di2*echelle
    u31,v31=((x[0]-x[2])/di),((y[0]-y[2])/di)
    u32,v32=((x[1]-x[2])/di2),((y[1]-y[2])/di2)   
    f1=forceG(m3,m1,di)
    f2=forceG(m3,m2,di2)
    f=sqrt((f1*u31+f2*u32)**2+(f1*v31+f2*v32)**2)

    valDis.configure(text="Distance avec corps 1 = " +str(di)+" m")
    valDis2.configure(text=" Distance avec corps 2 = " +str(di2)+" m")
    valFor.configure(text="Force exercée sur le corps sélectionné = " +str(f)+" N")
    valMass3.configure(text="Masse du corps 3 = "+str(eval(entr3.get()))+" Kg")

#Les 3 fonctions ci-dessous permettent de redéfinir les coordonnées de chaque corps

def corps1(event):
    can.coords(corps[0],event.x+10,event.y+10,event.x-10,event.y-10)
    di=distance(event.x,event.y, x[1], y[1])
    di2=distance(event.x,event.y, x[2], y[2])
    di=di*echelle
    di2=di2*echelle
    u12,v12=((x[1]-x[0])/di),((y[1]-y[0])/di)
    u13,v13=((x[2]-x[0])/di2),((y[2]-y[0])/di2)   
    f1=forceG(m1,m2,di)
    f2=forceG(m1,m3,di2)
    f=sqrt((f1*u12+f2*u13)**2+(f1*v12+f2*v13)**2)
    valDis.configure(text="Distance avec corps 2 = " +str(di)+" m")
    valDis2.configure(text=" Distance avec corps 3 = " +str(di2)+" m")
    valFor.configure(text="Force exercé sur corps 1 = " +str(f)+" N")
    x[0],y[0]=event.x,event.y
 
def corps2(event):
    can.coords(corps[1],event.x+10,event.y+10,event.x-10,event.y-10)
    di=distance(event.x, event.y, x[0], y[0])
    di2=distance(event.x, event.y, x[2], y[2])
    di=di*echelle
    di2=di2*echelle
    u21,v21=(x[0]-x[1])/di,(y[0]-y[1])/di
    u23,v23=(x[2]-x[1])/di2,(y[2]-y[1])/di2
    f1=forceG(m2, m1, di)
    f2=forceG(m2,m3,di)
    f=sqrt((f1*u21+f2*u23)**2+(f1*v21+f2*v23)**2)
    valDis.configure(text="Distance avec corps 1 = " +str(di)+" m")
    valDis2.configure(text="Distance avec corps 3 = " +str(di2)+" m")
    valFor.configure(text="Force exercé sur corps 2= " +str(f)+" N")
    x[1],y[1]=event.x,event.y

def corps3(event):
    can.coords(corps[2],event.x+10,event.y+10,event.x-10,event.y-10)
    di=distance(event.x, event.y, x[0], y[0])
    di2=distance(event.x, event.y, x[1], y[1])
    di=di*echelle
    di2=di2*echelle
    u31,v31=((x[0]-x[2])/di),((y[0]-y[2])/di)
    u32,v32=((x[1]-x[2])/di2),((y[1]-y[2])/di2)   
    f1=forceG(m3,m1,di)
    f2=forceG(m3,m2,di2)
    f=sqrt((f1*u31+f2*u32)**2+(f1*v31+f2*v32)**2)
    valDis.configure(text="Distance avec corps 1 = " +str(di)+" m")
    valDis2.configure(text="Distance avec corps 2 = " +str(di2)+" m")
    valFor.configure(text="Force exercée sur corps 3= " +str(f)+" N")
    x[2],y[2]=event.x,event.y

    
# Les 3 fonctions ci-dessous vont permettre d'obtenir l'état de la distance et de la force
# exercée pour chacun des corps, elles vont également nous permettre de replacer
# chacun des corps dans le canevas où bon nous semble en appelant les 3 fonctions ci-dessus.

def corps_1():
    can.bind("<Button-1>" ,corps1)
    di=distance(x[0],y[0],x[1],y[1])
    di2=distance(x[0],y[0],x[2],y[2])
    di=di*echelle
    di2=di2*echelle
    u12,v12=((x[1]-x[0])/di),((y[1]-y[0])/di)                #Coordonées du vecteur de force entre corps 1 et corps 2       
    u13,v13=((x[2]-x[0])/di2),((y[2]-y[0])/di2)          #Coordonnées du vecteur de force entre corps 2 et corps 3
    f1=forceG(m1,m2,di)
    f2=forceG(m1,m3,di2)
    f=sqrt((f1*u12+f2*u13)**2+(f1*v12+f2*v13)**2)
    valDis.configure(text="Distance avec corps 2 = " +str(di)+" m")
    valDis2.configure(text=" Distance avec corps 3 = " +str(di2)+" m")
    valFor.configure(text="Force exercée sur le corps sélectionné = " +str(f)+" N")
    Label(fra1,text="Corps 1 sélectionné ", fg='red').grid(row=0, column=4)
    Label(fra1,text="Cliquez n'importe où dans le cadre afin de redéfinir la position du corps sélectionné").grid(row=0,column=5,padx=10)
  
    

def corps_2():
    can.bind("<Button-1>",corps2)
    di=distance(x[1],y[1],x[0],y[0])
    di2=distance(x[1],y[1],x[2],y[2])
    di=di*echelle
    di2=di2*echelle
    u21,v21=((x[0]-x[1])/di),((y[0]-y[1])/di)
    u23,v23=((x[2]-x[1])/di2),((y[2]-y[1])/di2)   
    f1=forceG(m2, m1, di)
    f2=forceG(m2,m3,di)
    f=sqrt((f1*u21+f2*u23)**2+(f1*v21+f2*v23)**2)
    valDis.configure(text="Distance avec corps 1 = " +str(di)+" m")
    valDis2.configure(text="Distance avec corps 3 = " +str(di2)+" m")
    valFor.configure(text="Force exercée sur l'astre sélectionné = " +str(f)+" N")
    Label(fra1, text="Corps 2 sélectionné ", fg='blue').grid(row=0,column=4)
    Label(fra1,text="Cliquez n'importe où dans le cadre afin de redéfinir la position du corps sélectionné").grid(row=0,column=5,padx=10)
   

def corps_3():
    can.bind("<Button-1>",corps3)
    di=distance(x[2],y[2],x[0],y[0])
    di2=distance(x[2],y[2],x[1],y[1])
    di=di*echelle
    di2=di2*echelle
    u31,v31=((x[0]-x[2])/di),((y[0]-y[2])/di)
    u32,v32=((x[1]-x[2])/di2),((y[1]-y[2])/di2)   
    f1=forceG(m3,m1,di)
    f2=forceG(m3,m2,di2)
    f=sqrt((f1*u31+f2*u32)**2+(f1*v31+f2*v32)**2)
 
    valDis.configure(text="Distance avec corps 1 = " +str(di)+" m")
    valDis2.configure(text="Distance avec corps 2 = " +str(di2)+" m")
    valFor.configure(text="Force exercée sur le corps sélectionné = " +str(f)+" N")
    Label(fra1, text="Corps 3 sélectionné ", fg='green').grid(row=0,column=4)
    Label(fra1,text="Cliquez n'importe où dans le cadre afin de redéfinir la position du corps sélectionné").grid(row=0,column=5,padx=10)
 
    

# ------------- Programme principal ------------------

global m1,m2,m3 
                                               

m1=0                                                            #Masse des corps                                     
m2=0
m3=0
corps=[0]*3

x=[50., 50.,50.]                                  # Coordonnées des corps
y=[100., 150.,200.]

global echelle
echelle=1

fen=Tk()
fen.title(' Gravitation universelle suivant Newton')            #Titre de la fenêtre

valM1=Label(fen, text="Masse du corps 1 (en Kg) :")                        #Affichage de la masse de chacun des corps
valM1.grid(row=3, column=1,sticky=E)

#Champs de saisie permettant de redéfinir la masse de chacun des corps

entr1=Entry(fen)
entr1.grid(row=3,column=2, sticky=W)
entr1.bind("<Return>",masse1)

valM2=Label(fen, text="Masse du corps 2 (en Kg) :")
valM2.grid(row=4, column=1, sticky=E)

entr2=Entry(fen)
entr2.grid(row=4,column=2,sticky=N)
entr2.bind("<Return>",masse2)

valM3=Label(fen,text="Masse du corps 3 (en Kg) :")
valM3.grid(row=5, column=1,sticky=E)

entr3=Entry(fen)
entr3.grid(row=5,column=2,sticky=N)
entr3.bind("<Return>",masse3)

#Champ de saisi permettant de rédéfinir l'échelle de distance entre les corps

echelleDis=Label(fen, text="(A saisir en premier !!) Echelle de la distance (1 = 1Km) :")
echelleDis.grid(row=2,column=1,sticky=E)

entr4=Entry(fen)
entr4.grid(row=2,column=2,sticky=W)
entr4.bind("<Return>",echell)

Label(fen,text="Attention!! Toujours appuyer sur entrée après avoir saisi afin de considérer le nouveau changement !",fg='red').grid(row=6,column=1)

valDis=Label(fen)                        
valDis.grid(row=2, column=0)

valDis2=Label(fen, text="Veuillez sélectionner un corps à l'aide des 3 boutons se réferrant aux astres")
valDis2.grid(row=3,column=0)

valFor=Label(fen)
valFor.grid(row=4, column=0)

valMass1=Label(fen)
valMass1.grid(row=5,column=0)
valMass2=Label(fen)
valMass2.grid(row=6,column=0)
valMass3=Label(fen)
valMass3.grid(row=7,column=0)

#Création de la surface coloré sur laquelle les corps y seront plaçés et replaçés

can=Canvas(fen, bg="light yellow", width=800, height=600)
can.grid(row=1, column=0,columnspan=2)
corps[0]=can.create_oval(x[0]-10,y[0]-10, x[0]+10, y[0]+10, fill="red", width=1)
corps[1]=can.create_oval(x[1]-10, y[1]-10, x[1]+10, y[1]+10, fill="blue", width=1)
corps[2]=can.create_oval(x[2]-10,y[2]-10,x[2]+10,y[2]+10,fill="green",width=1)

fra1=Frame(fen)
fra1.grid(row=0, column=0, sticky=W, padx=10)

Button(fra1, text="corps1", fg='red', command=corps_1).grid(row=0,column=1,sticky=W,padx=1)                     #Boutons permettant de sélectionner un corps
Button(fra1,text="corps2",fg='blue',command=corps_2).grid(row=0,column=2,sticky=E,padx=1)
Button(fra1,text="corps3",fg="green",command=corps_3).grid(row=0,column=3,sticky=E,padx=1)

fen.mainloop()              #Demarrage

Conclusion :


Pour ceux qui ont le livre ou le tutorial "Apprendre à programmer avec python", ce programme est un exercice à réaliser au chapitre 8 du livre ou du tuto.
Bien entendu j'ai améliorer et ajouté de minimes retouches à ce qui était demandé.
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (Shakan972)