CodeS-SourceS est hébergé par Frontier.fr

Ce site au démarrage

begin process at 2010 03 14 16:58:08

Accueil Codes Tutoriels Forum Livres Emploi Services Connexion

Trouver un code source :

dans

[ Dernières recherches ]

Accueil >

GRAVITATION UNIVERSELLE

Information sur la source

Note :

10,00 / 10

Catégorie :Math & Algorithmes Classé sous :gravitation, newton Niveau :Débutant Date de création :26/08/2006 Date de mise à jour :31/08/2006 05:40:02 Vu / téléchargé :3 284 / 161

Auteur : Shakan972

Ecrire un message privé

Site perso

Commentaire sur cette source (22)

Ajouter un commentaire et/ou une note

Description

Cliquez pour voir la capture en taille normale

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

# -*- 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

# -*- 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é.

Fichier Zip

Les Membres Club peuvent télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

Gravitation.py 10 973 octets

Télécharger le zip

Historique

27 août 2006 21:33:15 :: Ajout du fichier zip de la source :)
27 août 2006 22:25:18 :: Bon ben j'ai finalement modifié le programme afin que l'on interpréte la nature du corps comme on veut en fonction de la masse choisie. J'ai également défini l'échelle en Km et replacé le champ de saisi de l'échelle en haut afin que l'on sache qu'il faut le remplir en priorité c'est préférable ^^.
27 août 2006 22:28:26 :: Correction dans le script !
28 août 2006 02:38:56 :: Encore une modification mais cette fois au niveau du calcul de la force exercée entre chaque corps qui consistait à calculer les coordonnées des vecteurs de force gravitationnels séparéments puis à les additionner afin de trouver la force totale vectorielle exercée sur chaque corps et non à faire directement la somme des forces exercées sur chaque masse, en espérant que le code est enfin bon ^^
28 août 2006 05:43:32 :: Correction d'une erreur de code ;)
28 août 2006 05:50:14 :: Modif.
29 août 2006 00:10:33 :: Petite modif.
31 août 2006 05:40:03 :: Modif dans la source.

Sources du même auteur

SNAKE

SPACE INVADERS

DÉTERMINATION APPROXIMATIVE DE PI À L'AIDE DE LA MÉTHODE DE ...

ANALYSE FRÉQUENTIELLE D'UNE PHRASE

ATTRACTION ÉLECTROSTATIQUE ENTRE CHARGES ÉLECTRIQUES (LOI DE...

Toutes les sources de Shakan972

Sources de la même categorie

GÉNÉRATION D'UN LABYRINTHE AVEC RECHERCHE DU CHEMIN LE PLUS ... par mehdicherti

DIVISIONS AVEC PRÉCISION RÉGLABLE par Clempython

LE CALCULATOR DE RAYGOLD VERSION 2 par raygold

ALGORITHMIME GENETIQUE : PROBLEME DU VOYAGEUR DE COMMERCE par mehdicherti

PROBLEME DES HUIT DAMES par mehdicherti

Toutes les sources de la catégorie Math & Algorithmes

Sources en rapport avec celle ci

CALCUL DE LA FORCE EN NEWTON DE L'INTERACTION GRAVITATIONELL... par tinux

Commentaires et avis

Commentaire de jpountz le 27/08/2006 15:04:30

Sympa :)
Ça serait bien si tu pouvais mettre un zip, parce-que le copier-coller depuis le site est pas top (pour moi en tout cas).
C''est bien conçu: clair, bien commenté, mais c'est un peu dommage que tu fasses les calculs avec les valeurs exactes (pour G notamment) mais que tu ne précise pas en quelle unité il faut rentrer les masses (kg il me semble) et à quoi correspond l'entrée échelle (nombre de mètres correspondant à une distance de 1 pixel sur l'écran c'est bien ça?)

Bravo, ça devrait bien plaire à HCD ^^

Commentaire de HCD le 27/08/2006 16:25:02

Comme le suggère JPOUNZ ton code m'a bien plu !
Je ferai les mêmes remarques : tu devrais préciser :
1° dans quelle unité il faut rentrer les masses (j'ai essayé 1e24,5e24,2e24)
2° à quoi sert le paramètre "échelle" ? Pourquoi ne pas le fixer une bonne fois pour toute à la valeur 1 ?

Sur le fond, je pense que les forces s'additionnent vectoriellement.
La force d'attraction mutuelle astre1/astre2 est portée par la droite qui relie astre1 à astre2: "vecteur f12".
De même pour astre1 et astre3: "vecteur f13".
La force résultante sur astre1 est donc : "vecteur f12" + "vecteur f13".

Qu'en penses-tu ?

Sinon la syntaxe de ton code est parfaite.
Je noterai un 10 mérité quand tu auras vu ces questions.

HCD

Commentaire de Shakan972 le 27/08/2006 21:30:01

Bonsoir tout le monde et tout d'abord je voulais vous dire que j'étais content que mon code vous ai plus ^^

Donc je répondrai clairement à tes deux questions HCD :

*Pour la 1er c'est simple l'unité correspondant à la masse des astres est le kilogramme.
Je corrige cela tout de suite mais normalment sache que quand tu entres la valeur du poids d'un astre celui-ci s'affiche en bas de la fenêtre avec l'unité Kg.
Cela permet quand même de voir l'unité de masse.

*Pour répondre à ta 2e question je dirai que j'ai mis l'échelle afin de se placer où l'on veut dans l'échelle des grandeur afin de calculer la force éxercé entre les corps.
Car les astres qui sont présent dans le programme peuvents très bien représenter toutes sortes de corps quelconque aussi bien une balle de tennis qu'un être humain bien entendu on suppose cela en fonction des masses choisis ce qui permet de se donner une idée des forces éxercés entre des corps de poids distincs donc si le corps est d'une masse faible on prendra de préférence une échelle plus réduite et ce sera tout le contraire si la masse est plus conséquente tout est question d'interprétation de la part de l'utilisateur du programme.

Donc si je veux calculer la force exercée entre 2 astres je prendrai de préférence une échelle à 1e9 qui correspond à la distance année lumière.

Si ce sont 2 balles de tennis je prendrai une échelle à 0,001 de préférence qui correspondra au mètre ou sinon 0,00001 qui correspondra au cm car 1 vaut 1 km dans ce programme.

Mais c'est vrai que j'ai mis des boutons astres donc c'est un peut inutile d'avoir mis l'échelle
je tâcherai donc de faire une modif à ce niveau là ^^

Sinon j'ai effectivement fait la somme des 2 vecteurs de force s'exerçant sur un astre, j'espère que ce n'est pas une erreur de ma part X(

En tout cas merçi pour ces remarques je vais apporter les modifications nécessaires. ^^

Shakan.

Commentaire de HCD le 27/08/2006 23:14:54

Merci pour avoir apporté toutes ces précisions.
Peut-être serait-il bien de les ajouter au début du code dans une rubrique "PRESENTATION du SCRIPT" ?

Qant à la "somme des deux vecteurs", j'y reviens car, en fait, tu additionnes leurs modules.
Par exemple :
dans
def astre1(event):
f=(forceG(m1, m2, di))+(forceG(m1,m3,di2))

avec f = m1*m2*6.67e-11/di**2 + m1*m3*6.67e-11/di2**2

La bonne approche est la suivante :

soit X1,Y1 les coordonnées de astre1
soit X2,Y2 les coordonnées de astre2
soit X3,Y3 les coordonnées de astre3

soit D12 = sqrt((X2-X1)*(X2-X1)+(Y2-Y1)*(Y2-Y1)) la distance entre astre1 et astre2
soit D13 = sqrt((X3-X1)*(X3-X1)+(Y3-Y1)*(Y3-Y1)) la distance entre astre1 et astre3

Le vecteur unitaire porté par la droite astre1/astre2 a pour coordonnées:
U12,V12 = (X2-X1)/D12,(Y2-Y1)/D12
Le vecteur unitaire porté par la droite astre1/astre3 a pour coordonnées:
U13,V13 = (X3-X1)/D13,(Y3-Y1)/D13

soit f12 le module de la force d'attraction mutuelle entre astre1 et astre2 : f12 = m1*m2*6.67e-11/D12**2
Les coordonnées de cette force sont :f12*U12,f12*V12
soit f13 le module de la force d'attraction mutuelle entre astre1 et astre3 : f13 = m1*m3*6.67e-11/D13**2
Les coordonnées de cette force sont :f13*U13,f13*V13

A partir de là, les coordonnées des forces résultantes sur astre1 sont : f12*U12+f13*U13,f12*V12+f13*V13
et son module est égal à : f1 = sqrt((f12*U12+f13*U13)*(f12*U12+f13*U13)+((f12*V12+f13*V13)*(f12*V12+f13*V13))

Dans ton code tu prends en fait : f1 = f12 + f13 , ce qui est très différent.
Si problème, n'hésites pas à me le dire.

HCD

Commentaire de Shakan972 le 28/08/2006 00:00:05

Pourrais-tu s'il te plaît me transmettre les formules mathématiques qui t'on permis d'exposer ce raisonnement s'il te plaît ça m'aiderait beaucoup ^^

Commentaire de Shakan972 le 28/08/2006 00:05:48

De plus pourquoi utilises-tu sqrt pour calculer la force résultante sur astre1?

Commentaire de HCD le 28/08/2006 00:28:15

Je te répondrai, c'est promis.
Il est un peu tard ce soir : je coupe !!!
Sur le principe :
La force d'attraction de astre2 sur astre1 est un vecteur :appelons le <vecteur 21>.
Son module égal à m1*m2*6.67e-11/di et il est porté par la droite reliant astre2 à astre 1.
Il en est de même pour astre3 et astre1, avec le <vecteur 31>.

Donc la force résultante des attractions de astre2 et de astre3 sur astre1 est égale à la somme vectorielle :
<vecteur 21> + <vecteur 31>

Dans le code, il faut calculer les coordonnées de ces deux vecteurs, faire l'addition pour chaque coordonnées, puis calculer le module (d'où l'utilisation de sqrt)

Good night Sir !

HCD

Commentaire de Shakan972 le 28/08/2006 20:01:41

Tu prends la formule du calcul de la distance entre 2 points pour calculer la somme des forces exercées sur astre1 :

sqrt((f12*U12+f13*U13)*(f12*U12+f13*U13)+((f12*V12+f13*V13)*(f12*V12+f13*V13))

Je ne comprend pas ^^

Commentaire de jpountz le 28/08/2006 21:17:45

Ce que HCD veut dire, c'est que les forces s'additionnent vectoriellement. Par exemple, si tu mets l'astre 2 entre les astres 1 et 3 et à égale distance de chacun, la force exercée sur l'astre 2 est nulle puisque les deux forces f12 et f32 se compensent exactement.

C'est pour cela qu'il faut additionner les forces vectoriellement.
                         __
  ^          ->           /|
->|          F2          / ---->
F1|    +   ------->  =  /  F1+F2    par exemple
  |                    /
               ----->                                                  ----->
et la norme de F1+F2 vaut en appelant Fx, la composante horizontale de F1+F2 et y la composante verticale, sqrt(Fx*Fx+Fy*Fy) ce qui est analogue à la formule de calcul des distances comme tu l'as remarqué.

En fait la valeur de la force est égale à la norme du vecteur représentant la force qui est elle-même proportionnelle à la "longueur" du vecteur, c'est pour ça que c'est la même formule que celle des distances!

Commentaire de jpountz le 28/08/2006 21:21:52

Aïe, la mise en page a foutu le camp quand j'ai validé! ^^
Tu peux copier mon message dans le champ "AJOUTER UN COMMENTAIRE" en bas, tu verras mieux.

Commentaire de HCD le 28/08/2006 22:40:55

Quand tu écris :

sqrt((f12*U12+f13*U13)*(f12*U12+f13*U13)+((f12*V12+f13*V13)*(f12*V12+f13*V13))

ce n'est pas une distance que tu calcules,stricto sensu, mais la LONGUEUR (ou la NORME comme dit JPOUNTZ) du VECTEUR (appelons le <vecteur1>) de coordonnées :

f12*U12+f13*U13 (sur l'axe des abcisses)
f12*V12+f13*V13 (sur l'axe des ordonnées)

Ce VECTEUR est lui-même la somme "vectorielle" des deux VECTEURS (appelons les <vecteur21> et <vecteur31>) de coordonnées :
pour le <vecteur21>
f12*U12(sur l'axe des abcisses)
f12*V12(sur l'axe des ordonnées)
pour le <vecteur31>
f13*U13 (sur l'axe des abcisses)
f13*V13 (sur l'axe des ordonnées)

La NORME du <vecteur21> est ainsi égale à : sqrt((f12*U12)*((f12*U12))+(f12*V12)*(f12*V12))
soit encore :f12*sqrt(U12*U12+V12*V12)=f12 puisque le vecteur (U12,V12) est unitaire (NORME=1)
Ilen est de même pour le <vecteur31> dont la NORME est égale f13

Touy ce qui précède est une autre façon de dire les choses.
Mais à la base tout repose sur l'addition VECTORIELLE comme te le rappelle JPOUNTZ.

Sinon j'ai bien reçu des deux autres messages et te répondrai dès mon retour dans environ une semaine.

Commentaire de HCD le 28/08/2006 22:49:14

Ah ... j'oubliais !
Les modifications apportées à ton code sont les bonnes.
Reste à bien vérifier les questions de signe.

HCD

Commentaire de Shakan972 le 28/08/2006 22:56:12

J'ai utilisé la fonction abs() pour l'histoire des signes car cela engendre des erreurs de domaine puisque la racine carrée d'un nombre négatif ne peut-être calculée sinon je voulais te dire que les vecteurs je ne connais pas trop c'est pour cela que ça me pose problème (trop feignasse à l'école peut-être ^^) sinon j'aai fait des recherches à ce sujet et j'en déduis que cette méthode permet de calculer la force résultante F3=F1+F2 qui s'exerce sur un corps.

Bref un peu dur à digérer mais j'y arriverai ^^

Commentaire de HCD le 28/08/2006 23:20:41

Je pense que tu es sur la bonne voie.
La théorie sur les vecteurs est un peu surprenante au départ, mais en s'accrochant un peu on s'apperçoit très vite que leur manipulation est facile. Elle permet de faire plein de choses intéressantes en électromagnétisme, par exemple. Mais elle n'est pas indispensable pour vivre, bien entendu !!!
Compte tenu de ce que tu sais faire en programmation, je suis certain que tu y arriveras sans peine.
Pour la question de signe, il faut vraiment y regarder de près pour être sûr que la formulation résiste à tous les cas de figures.
Un test à faire : vérifier que si astre1 est au milieu de astre2 et de astre3 (de même masse) la force est bien égale à zéro (les deux attractions se compensent dans ce cas).
A bientôt.

HCD

Commentaire de Shakan972 le 28/08/2006 23:41:31

Oui c'est bon la force est bien égale à zero quand je met un astre au milieu des deux autres. ^^

Commentaire de HCD le 28/08/2006 23:53:06

Désolé, mais en y regardant de plus près :

aulieu de :
f=sqrt(abs((f1*u12+f2*u13)+(f1*v12+f2*v13)))

je pense qu'il faut mettre
f=sqrt((f1*u12+f2*u13)*(f1*u12+f2*u13)+(f1*v12+f2*v13)*(f1*v12+f2*v13))

ceci règle en même temps le problème de signe

Commentaire de Shakan972 le 29/08/2006 00:06:56

J'ai corrigé.

Commentaire de HCD le 29/08/2006 01:03:20

OK mais il te reste à mettre le code corrigé sur le site.
Good night Sir.

HCD

Commentaire de HCD le 07/09/2006 23:10:26

Tu n'as toujours pas corrigé le code comme je te l'indiquais le 28/O8 :

au lieu de :
f=sqrt(abs((f1*u12+f2*u13)+(f1*v12+f2*v13)))
mettre :
f=sqrt((f1*u12+f2*u13)*(f1*u12+f2*u13)+(f1*v12+f2*v13)*(f1*v12+f2*v13))

HCD

Commentaire de Shakan972 le 10/09/2006 04:59:26

f=sqrt((f1*u12+f2*u13)*(f1*u12+f2*u13)+(f1*v12+f2*v13)*(f1*v12+f2*v13))

et

f=sqrt((f1*u12+f2*u13)**2+(f1*v12+f2*v13)**2)

ce n'est pas la même chose?
car j'ai opté pour le second.

Commentaire de HCD le 10/09/2006 22:57:37

Pardonnes-moi : je n'avais pas les yeux en face des trous !!!
Les deux écritures donnent évidemment des résultats identiques.
Pour moi, ton code est parfait maintenant.
Et je le note 10.

HCD

Commentaire de Shakan972 le 11/09/2006 03:08:31

Merçi tu m'honores ^^

Ajouter un commentaire

Nos sponsors

Derniers Blogs

CSDL FUNCTION par Matthieu MEZIL

LINQ TO ENTITIES par Matthieu MEZIL

FAIRE APPARAITRE L'ONGLET 'DéVELOPPEUR' DANS OFFICE 2010 par neodante

[ASTUCE] PATCH POUR MICROSOFT FORUMS NNTP BRIDGE V1 par pierre

PB LORS DE L'INSTALLATION SHAREPOINT 2010. par Patrick Guimonet

Forum

AFFICHAGE DU MAXIMUM D'UNE LISTE par laloutre78

RE : GESTION D'UNE INTERFACE GRAPHIQUE par lespinx

RE : ET UN SOUCIS (UN DE PLUS...) par notepc

GESTION D'UNE INTERFACE GRAPHIQUE par lilly74

[PROGRAMME PYTHON] CRYPTAGE RSA (CHERCHE CODEUR) par GelH

Côté IT

Offres d'emploi

Formations Video

Appels d'offres

Site internet php
Budget : 350€
site formation reiki distance
Budget : 900€
Banniere Flash Drupal
Budget : 150€

Logiciels

Xilisoft Convertisseur Vidéo Ultimate (5.1.39.0305)
XILISOFT CONVERTISSEUR VIDéO ULTIMATE (5.1.39.0305)

Xilisoft Convertisseur Vidéo Ultimate est un outil puissant de conversion vidéo, facile à utilise...

Cliquez pour télécharger Xilisoft Convertisseur Vidéo Ultimate
Xilisoft DVD Ripper Ultimate (5.0.64.0304)
XILISOFT DVD RIPPER ULTIMATE (5.0.64.0304)

Xilisoft DVD Ripper Ultimate est un logiciel excellent pour copier et convertir DVD vers presque ...

Cliquez pour télécharger Xilisoft DVD Ripper Ultimate
Axalot, logiciel de sauvegarde de données en ligne (1.10.108.1)
AXALOT, LOGICIEL DE SAUVEGARDE DE DONNéES EN LIGNE (1.10.108.1)

Perdre tout le contenu de votre disque dur, vous imaginez ? Vos photos, vos musiques, votre compt...

Cliquez pour télécharger Axalot, logiciel de sauvegarde de données en ligne
Rigs of Rods (63.3)
RIGS OF RODS (63.3)

c'est un jeu de multi-simulation camions,autobus voitures, avions, bateaux, hélicoptère avec défo...

Cliquez pour télécharger Rigs of Rods
Konvertor (4.00)
KONVERTOR (4.00)

Le logiciel est un gestionnaire multimedia affichant, jouant et convertissant plus de 2000 format...

Cliquez pour télécharger Konvertor