Problème de formule (unité)

[azertylr]

Bonjour,
J'ai crer un programme de simulation de l'orbite de cassini, il est a peu pres au point, mais il y a un problème : il n'est pas quantitatif. En fait le programme calcul la position jour apres jour des planetes et calcule a quel acceleration la sonde subit, or celle ci est dans le SI : en m.s^-1 et j'aimerai savoir comment avoir la position de cassini en fonction de l'acceleration mais je voudrai ce deplacement en UA/jour. Est ce que quelqu'un pourrai m'aider svp ?
voici les formules que j'utilisent actuellement :
Vx=Vx+ax
Vy=Vy+ay
x=x1+Vx/2+Vx1/2 (x1 la position precedente et Vx1 la vitesse precedente)
y=y1+Vy/2+Vy1/2 (de meme)
car si je fait Vx=Vx+86400*ax cela ne marche pas :'( ce qui se raprocherai le plus serai :
Vx=Vx+86400*ax
x=x1+86400*(Vx/2+Vx1/2)

merci de votre aide
-----

[Coincoin]

Salut,

Vx=Vx+ax

Je crois savoir ton problème... On a Vx'=Vx+ax*t (avec Vx la vitesse avant l'itération de calcul, Vx' la vitesse après, a l'accélération et t la durée de ton itération) (dans l'approximation d'Euler).
De même Vy'=Vy+ay*t

Et x=x1+t*(Vx+Vx1)/2 (dans ton approximation de prendre la moyenne des vitesses)

[azertylr]

je programme en delphi et Vx=Vx+ax ou Vx=Vx'+ax cela revient au meme.
Si je fais Vx=Vx+86400*ax ou Vx=Vx'+86400*ax j'obtiens un resultat que je trouve aberant et j'ai fait le calcul, si je lache une balle a la surface de la terre , au bout d'un jour a a parcourru gt²/2 soit 5*85400²
et si j'utilise celle formule :
Vx=Vx'+86400*ax
x=x'+(Vx/2+Vx1/2) (avec les ' avec le calcul), je trouve 5*86400 au lieu de 5*86400² m (pas envi de faire le calcul

edit : une precision : j'ai utiliser Vx=Vx'+ax (je n'est pas multiplier par t car dans mon premier programme, la position est calculer chaque seconde. si je veux faire la trajectoire de cassini : 7ans a raison de la position seocnde par seconde 2,8E8 calcul (heu c'est beaucoup moins que ce que je pensais )

[Coincoin]

C'est normal que si tu calcules la trajectoire d'une bille lâchée sur Terre avec un pas de temps d'un jour, tu trouves des trucs aberrants ! Fais des calculs avec une seconde ou un dixième de seconde, et ça ira déjà mieux

[A voir en vidéo sur Futura]

[azertylr]

oui mais justement, pour la trajectoire des planètes je ne peux pas faire un calcul par seconde, il y en aurai trop.
Pour la terre :
j'ai fait ce calcul (ca ne devrai aps etre trop dur a comprendre

for i:=1 to 86400 do
begin
x1:=x;
vx1:=vx;
vx:=vx+1*10;
x:=x1+(Vx/2+Vx1/2);
end;

et je trouve d=37324800000m
et si je fait toute les 2 secondes :

for i:=1 to 43200 do
begin
x1:=x;
vx1:=vx;
vx:=vx+2*10;
x:=x1+(Vx/2+Vx1/2);
end;

et je trouve d=18662400000m
pour que je trouve le meme result il faut que je fase comme ce ci :

for i:=1 to 43200 do
begin
x1:=x;
vx1:=vx;
vx:=vx+2*10;
x:=x1+2*(Vx/2+Vx1/2);
end;

est-ce que c'est normal ?
merci

[Coincoin]

est-ce que c'est normal ?

Oui ! Regarde mon premier message, de même que pour passer de l'accélération de à la vitesse, pour passer de la vitesse à la position, il faut que le pas de temps intervienne.
Mathématiquement, l'approximation d'Euler te dit que : f(x+dx)=f(x)+f'(x)dx (développement limité au 1er ordre en dx). Et comme l'accélération est la dérivée de la vitesse, qui est elle-même la dérivée de la position, tu obtiens les formules que tu as après tripatouillage... (Une petite subitlité étant ici que tu n'utilises pas v(t) mais (v(t)+v(t+dt))/2 pour avoir des calculs moins faux)
Bref, continue les maths sont avec toi !

[azertylr]

ok merci,
par ccontre si j'utilise cette formule, j'ai un problème d'echelle :
un pixel = 1 UA / 20 soit 7 480 000 000m donc uen fois que j'ai le decalage de position je le divise par ce nombre pour avoir le resultat en pixel et ensuite je ajoute la position precedente. Or avec Vx0 et Vy0 (vitesse initial) la sonde par tout droit ! et pour Vx=-0,17 la sonde parcours en 1 jour 4 UA ! est-ce normal ? ou est-ce mes formules ?

[Coincoin]

Tu as peut-être des erreurs d'arrondis... Tu utilises des entiers ou des floats ? Tu as moyen d'affiner l'échelle ou bien c'est suffisamment lourd comme ça ?

Vx0 et Vy0 (vitesse initial) la sonde par tout droit

Tu veux dire Vx=0 et Vy=0 ? Est-ce qu'elle part suivant un axe (x ou y) ou bien dans une direction quelconque ?
Comment as-tu calculé les accélérations ?

Et je conseille de raisonner directement en UA ou mieux en pixels, mais surtout pas en mètres...

[azertylr]

d'arrondi je pense pas, je resonne en float. La valeur est arrondi uniquement pour l'affichaque.
Je ne resonne pas en metre, c'est justement pour ca ue je divise par 7 480 000 000
pour l'acceleration elle est calculer par la formule suivant :
dTT=(x-xTerre(d))²+(y-yTerre(d))² /distance au carre entre la terre et la sonde
thetaT=arccos((xTerre(d)-x)/sqrt(dTT)) /angle entre la terre et la sonde
axT=(masseT/dTT)*cos(thetaT) /acceleration
ayT=(masseT/dTT)*sin(thetaT)
xterre(d) est l'abscisse de la terre et x l'abscisse de la sonde (repere heliocentrique)
ensuite tout les ax et les ay sont additionner (des differentes planetes) et ensuite il y a la formule precedente

masseT= masse terre * G / coefficient pour avoir l"'acceleration en metre/seconde avec la distance en pixel

pour ce qui est de la sonde elle part dans une direction quelconque

[Coincoin]

A part ça, tes planètes tournent bien ? Ca me rappelle un simulation que j'avais essayé de faire en C du système Soleil-Terre-Lune dans lequel la Lune se précipitait sur le Soleil avant de partir avec une vitesse très grande n'importe où (forcément, lorsque la Lune traverse le Soleil la distance est tellement petite qu'on a des nombres énormes de partout et donc des dépassements...), suivie par la Terre (et j'ai donc par conséquent prévu la fin du monde pour le mois d'avril 2004 ).
Pour ce qui est de ton problème, je ne vois pas... Vérifie bien ton programme (histoire que la Terre ait pas la masse de Saturne, etc...), et essaye de le simplifier pour voir si ça marche (par exemple tu ne gardes que la Terre (en mettant les autres masses à zéro) et tu essayes de satelliser ta sonde).

[azertylr]

Dans le 1er programme que j'ai fait qui prend en compte uniquement la terre (fixe) et la sonde, pas de problème maisle calcul se faisait seconde par seconde. Pour ce qui est de la verification c'est deja fait (les fonction et procedure ca aide ) si tu veux le voir va sur mon site. (trajectoire v4)
merci

[azertylr]

Oups Je me suis apercu que j'ai fait une erreur : j'ai mis un x au lieu d'un y
a oui une question :
j'ai fait

dTT=(x-xTerre)²+(y-yTerre)² /distance au carre entre la terre et la sonde
thetaT=arccos((xTerre-x)/sqrt(dTT)) /angle entre la terre et la sonde

et axT=(masseT/dTT)*cos(thetaT) mais est-ce bien sin et non cos ? (en faisant un scheme je sais plus trop quel angle je calcul et apres j'ai fait :
if (x>xTerre) AND (axT>0) then
axT:=-axT
mais je ne suis pas sur de ce calcul (j'ai fait ceci car un cos ou un sin peux avoir deux valeurs et suivant la position de la sonde par rapport a la planète, la valeur etait positive alros quel doit etre negative)
merci bien

[Coincoin]

Ca me paraît bon... T'as fait pareil pour les y ?

Sinon, j'ai peut-être un début d'explication : http://forums.futura-sciences.com/sh...ad.php?t=23779

[zoup1]

Il ne faut surtout pas repasser par les cosinus ou les sinus... Donc en reprenant tes notations ;
La force d'attraction gravitationnelle est suivant le vecteur qui relie la Terre à la sonde soit le vecteur :
suivant x : x-xTerre/sqrt(DTT) et suivant y : y-yTerre/sqrt(DTT)
ax = - (x-xTerre)/DTT^3/2

[azertylr]

donc axT=(masseT/dTT)*cos(thetaT)=- (x-xTerre)/DTT^3/2 ?
et ay:=(masseT/dTT)*sin(thetaT)=- (y-yTerre)/DTT^3/2 ?
heu j'essayerai bien mais delphi accepte pas ^3/2 (ou alors je ne sais pas quel fonction utiliser)
si j'utilise les cosinus ou sinus que ce passe t-il ? imprecisions ?
merci beaucoup zoup1

[Coincoin]

Pour le 3/2, tu peux dire que c'est sqrt( )^3

[zoup1]

donc axT=(masseT/dTT)*cos(thetaT)=- (x-xTerre)/DTT^3/2 ?
et ay:=(masseT/dTT)*sin(thetaT)=- (y-yTerre)/DTT^3/2 ?
heu j'essayerai bien mais delphi accepte pas ^3/2 (ou alors je ne sais pas quel fonction utiliser)
si j'utilise les cosinus ou sinus que ce passe t-il ? imprecisions ?
merci beaucoup zoup1

pour le 3/2 tu peux effectivement utilser sqrt()*sqrt()*sqrt()

Si tu passe par le sinus et le cosinus cela marche aussi mais tu te compliques terriblement la vie car il faut remonter à l'angle complet si tu fais un arccos, tu as quelque chose qui n'est défini qu'à pi près or tu as besoin de la défintion complète de l'angle. En gros, cela revient à dire x = sqrt(x*x) ; C'est vrai, certes mais seulement si x>0 et puis de toute façon c'est plus compliqué que de faire simplement x=x

Note : j'ai oublié le masseT dans l'expression...

[azertylr]

salut,
donc ax=-masseT* (x-xTerre)/(sqrt(DTT)*sqrt(DTT)*sqrt(DTT) )
?
merci beaucoup
j'essayerai ca demain
bonne nuit

[zoup1]

Oui, c'est cela... enfin si l'on omet la constante de gravitation universelle... ou plutot, dans un système d'unité tel qu'elle soit égale à 1.

[azertylr]

merci beaucoup tout le monde ! mais ca marche pas mieux !
Par contre j'ai un problème et je ne sais pas il celui ci se repercute sur la trajectoire :
pour delphi , l'origine du repère est en haut a gauche de l'ecran, et si on descend ordonnée augmente mais dans le positif. (il n'y a aps de problème pour les abcisses je pense) est-ce que ces formules marchent ?

ax= -masse *(x-xTerre)/(d*sqrt(d)) où d est la distacne en carre entre la terre(xterre,yterre) et la sonde(x,y)
ay= -masse *(y-yTerre)/(d*sqrt(d)) et où masse = masse terre * G / un coefficient pour simplifier les calculs

merci
nota : ca marche mieu mais pas sur que ca soit la bonne trajectoire avec ces formules :
ax= -masse *(x-xTerre)/(d/sqrt(d))
ay= -masse *(y-yTerre)/(d/sqrt(d))

[zoup1]

Sans trop réfléchir, je dirais qu'avec cette histoire d'ordonnée, les "formules" marchent. Cependant, ce que je te conseille fortement de faire, c'est de découpler la physique de l'affichage.

Tu as tout interêt à calculer tes positions successives dans un repere donné... le repère habituelle, avec x orienté vers la droite de ton écran et y orienté vers le haut.
Ensuite tu calcule des coordonnées d'affichage (xa, ya) comme il faut pour faire en sorte que ton écran représente les coordonnées de ton repère comme tu le souhaites. Typiquement : xa:= dec+g*x; ya:=dec-g*y; où decx et decy est un décalage qui permet de placer l'origine des x et des y au milieu de ton écran (decx=500 et decy=500 par exemple) et g est un facteur d'échelle de ta representation (c'est lui qui fait la conversion depuis l'unité que tu as utilisée pour le calcul vers les pixels).

mais ca marche pas mieux !

peux-tu être un peu plus précis et nous dire comment cela ne marche pas mieux... on pourat peut-être te dire pourquoi ça ne marche pas mieux...

Sinon montre nous ton programme (complet) on pourra aussi éventuellement voir où il y a des problèmes...

[azertylr]

Pour le changement de repère, j'utilise + 300 pour centré de l'ecran
En fait, quelque soit la vitesse initial, la sonde par celon une droite dont la direction varie selon la Vx0 et Vy0
Si tu veux voir le programme va sur http://azertylr.chez.tiscali.fr/ et prend "trajectoire v4 presque au point"
si tu veux la source en delphi contact moi.
Le problème vient peut etre du fait que le masse de la planète correspond G*masse/(7480000000)²
(7480000000 = 1UA / 20 car 1 pixel = 1/20 UA)
et ensuite :

d:=(x-xTerre)*(x-xTerre)+(y-yTerre)*(y-yTerre);
ax:= -masseT *(x-xTerre)/(d*sqrt(d));
ay:= -masseT *(y-yTerre)/(d*sqrt(d));

Vx=Vx'+86400*ax
Vy=Vy'+86400*ay

x=x'+(86400*(Vx/2+Vx1/2)/7480000000)
y=y'+(86400*(Vy/2+Vy1/2)/7480000000)

(86400 car le calcul de position se fait jour apres jour)

merci tous le monde

[zoup1]

Pour le changement de repère, j'utilise + 300 pour centré de l'ecran
En fait, quelque soit la vitesse initial, la sonde par celon une droite dont la direction varie selon la Vx0 et Vy0
Si tu veux voir le programme va sur http://azertylr.chez.tiscali.fr/ et prend "trajectoire v4 presque au point"
si tu veux la source en delphi contact moi.
Le problème vient peut etre du fait que le masse de la planète correspond G*masse/(7480000000)²
(7480000000 = 1UA / 20 car 1 pixel = 1/20 UA)
et ensuite :

d:=(x-xTerre)*(x-xTerre)+(y-yTerre)*(y-yTerre);
ax:= -masseT *(x-xTerre)/(d*sqrt(d));
ay:= -masseT *(y-yTerre)/(d*sqrt(d));

Vx=Vx'+86400*ax
Vy=Vy'+86400*ay

x=x'+(86400*(Vx/2+Vx1/2)/7480000000)
y=y'+(86400*(Vy/2+Vy1/2)/7480000000)

(86400 car le calcul de position se fait jour apres jour)

merci tous le monde

Bon, j'ai un peu de mal à lire un programme écrit de cette façon et je suis sur que toi aussi...
Quand on programme, il est toujours bénéfique de faire des choses qui soient le plus clair possible et le plus chargé de sens.
Il ne faut pas hésiter à définir des variables qui portent un nom bien identifié pour avoir des expressions qui restent lisibles.
Par exemple si je reprends ton code, j'écrirais cela comme cela plutot...

Le vecteur position de la sonde par rapport à la terre a deux composantes (rx et ry)
J'appelle d2 le carré de la distance terre sonde... et d la distance terre sonde... cela évite des confusion
J'appelle (ux et ux) le vecteur unitaire dirigé suivant l'axe terre sonde
J'appelle Cste la constante de l'expression de la force d'attraction gravitationnelle GMm
J'appele F le module de la force d'attraction gravitationnelle
J'apelle dt le pas de temps d'intégration

Cste = G*ms*mt;

rx := (x-xTerre);
ry : = (y-yTerre);
d2:=rx*rx+ry*ry;
d:=sqrt(d2);

ux:= rx/d;
uy:= ry/d;

F := Cste/d2;

ax:= -F*ux;
ay:= -F*uy;

Vx:=Vx1+ax*dt;
Vy:=Vy1+ay*dt;

x:=x1+(Vx+Vx1)*dt/2
y:=y1+(Vy+Vy1)*dt/2


xaff = xc + x*gross;
yaff = yc + y*gross;

---- Affichage de la trajectoire

x1:=x;
y1:=y;

vx1:=vx;
vy1:=vy;

--- On bloucle...

[zoup1]

Commentaire du bout de programme du message précédent ;

Tu as interet à travailler dans un système d'unité le plus adapté possible au calcul...
Dans ce système d'unité, le mieux serait que toutes les grandeurs que tu aditionnes soit de l'ordre de 1... cela limite les problèmes d'arrondis numérique.

Pour cela, au lieu d'utiliser le metre ou le pixel comme unité de longueur ou même l'unité astronomique tu as interet à tout exprimer dans l'unité de taille caractéristique de la trajectoire...
De la même façon, au lieu d'utiliser la seconde comme unité de temps, tu as interêt à utiliser le temps caractérisitque de ta trajectoire... à savoir le temps nécessaire pour faire un tour, ou quelque chose comme cela.

Enfin, le choix du pas de temps est essentiel... Il faut que ce pas de temps soit petit par rapport à aux temps caractérisitques de ta trajectoire. Et cela d'autant plus petit que ton algorithme est peu évolué dans ton cas ici où l'algorithme est très basique, il vaut mieux prendre un pas de temps tout petit... à voir...

[zoup1]

x=x'+(86400*(Vx/2+Vx1/2)/7480000000)
y=y'+(86400*(Vy/2+Vy1/2)/7480000000)

A regarder ce que tu avais écris d'un peu plus près, je ne suis pas vraiment sur de comprendre pourquoi tu divise par 7480000000 dans les expressions qui sont ici ?

[azertylr]

A regarder ce que tu avais écris d'un peu plus près, je ne suis pas vraiment sur de comprendre pourquoi tu divise par 7480000000 dans les expressions qui sont ici ?

merci pour tout zoup1, je vais essayer ton code.
Je divise par 1UA/20 = 7480000000 car 1 pixel = 1*20 UA mais je vais changer de base et d'unite. (0,0) sera le soleil et je fait une variable uniquement pour l'affichage.
Je vias voir ca tout de suite, et encore merci

[zoup1]

merci pour tout zoup1, je vais essayer ton code.
Je divise par 1UA/20 = 7480000000 car 1 pixel = 1*20 UA mais je vais changer de base et d'unite. (0,0) sera le soleil et je fait une variable uniquement pour l'affichage.
Je vias voir ca tout de suite, et encore merci

Mon code n'est a priori pas fondamentalement différent du tiens. C'est juste une façon de le rendre plus lisible.
Pourquoi ne pas mettre le texte de ton programme sur ton site si tu veux que je puisse le regarder...

[azertylr]

Je ne vois aps ce que tu entend pas le texte de mon programme,
J'ai essayer ton code mais apparament il bug.
J'ai proceder comme suis :

rxT := (x-xTerre)*150000000000;
ryT := (y-yTerre)*150000000000;
d2Terre:=rxT*rxT+ryT*ryT;
dTerre:=sqrt(d2Terre);

uxT:= rxT/dTerre;
uyT:= ryT/dTerre;

F := (G*masseT)/(d2Terre);

axT:= -F*uxT;
ayT:= -F*uyT;

vx1:=vx;
vy1:=vy;

ax:=axT;
ay:=ayT;

Vx:=Vx+86400*ax;
Vy:=Vy+86400*ay;

x:=x+(86400*(Vx/2+Vx1/2))/150000000000;
y:=y+(86400*(Vy/2+Vy1/2))/150000000000;

(x et y sont en UA et le pas de 1j)

En fait rien ne s'affiche : la positiion x de la sonde oscilli entre -6,17394101706429E-13 et -6,35709989780497E-13 !!
je vias essayer quelque chose.

[zoup1]

Je ne vois aps ce que tu entend pas le texte de mon programme

Ce que j'appelle le texte du programme, c'est le code source si tu préfères. Ce que tu m'envoies quoi partiellement dans les messages, mais je le voudrais en complet... L'essemble de ce que tu écris... le fichier .pas quoi !!! avec les boucles et tout et tout...

[azertylr]

Je code source est disponible sur mon site : http://azertylr.chez.tiscali.fr) (Sources)
C'est un fichier *.pas mais ouvrable avec n'importe quel editeur texte