[Fortran 90][Débutant] Equations mouvement de satellite

**kevin007** · 17/04/2008, 01h30

Bonjour

Je suis débutant en Fortran 90 et j'ai besoin de quelqu'un qui puisse m'aider à faire un programme en utilisant la methode RKF (Rung Kutta ..) pour déterminer la vitesse et l'angle que fait la vitesse avec la direction Jupiter-Soleil de la sonde Pioneer 10 après la rencontre, c'est-à-dire lorsqu'elle est de nouveau à une distance D=33 R de Jupiter, dans un premier temps en négligeant l'influence du soleil en ne prenant pas en compte son interaction gravitationnelle avec la sonde et en considérant que Jupiter a une trajectoire rectiligne uniforme durant la rencontre.

On prendra

Masse de la sonde m=260Kg
Masse de jupiter M=1,90.10^27 Kg
Constante de gravitation G=6,67.10^-11Nm^2/kg^

Merci de pouvoir m'aider s'il vous plait.

**FR119492** · 17/04/2008, 11h42

Salut !
Ta question comporte deux aspects qui doivent être traités séparément:

Formulation du problème: tu dois écrire les équations différentielles qui régissent le mouvement de ton satellite, en appliquant les équations de la physique, puis les mettre sous forme canonique (dérivée première des diverses variables d'état exprimée en fonction des variables d'état elles-mêmes et des actions extérieures).
Programmation de la résolution; tu cherches dans toutes les bibliothèques disponibles un sous-programme appliquant l'algorithme qui, semble-t-il, t'est imposé, tu lis sa documentation et tu l'appliques

Suis méticuleusement cette procédure et tiens nous au courant de l'avancement de ton travail et des éventuelles difficultés que tu rencontres.
Jean-Marc Blanc

**kevin007** · 18/04/2008, 13h01

Bonjour
J'ai reçu votre réponse mais mon problème est que je ne connais rien sur le programme Fortran. Si vous pouviez me donner la solution si ça vous dérange pas sil vous plait.
Merci

**TheOyoStyledMan** · 18/04/2008, 13h51

Bonjour,

pour être plus direct que FR119492: écris les équations et l'algorithme avant de penser au Fortran!

Cela ne sert à rien d'écrire des lignes de code si tu ne comprends pas le problème. ici c'est un forum d'aide sur le Fortran et non de mécanique céleste...

**kevin007** · 18/04/2008, 15h17

Bonjour

Je sais écrire les équations mais le problème c'est que je n'arrive pas à les transformer en Fortran. Si vous pous pouvez me les résoudre s'il vous plait.
Merci

**FR119492** · 18/04/2008, 16h23

Salut !
Admettons que tu as toutes tes équations. As-tu déjà effectué la deuxième étape, soit:

tu cherches dans toutes les bibliothèques disponibles un sous-programme appliquant l'algorithme

Jean-Marc Blanc

**TheOyoStyledMan** · 18/04/2008, 16h49

Envoyé par kevin007

bonjour

je sais ecrire les equation mais le probleme c'est j'arrive pas a le transformer en fortran ci vous pous pouvez me les resoudre s'il vous plait
merci

Et l'algorithme de Runge-Kutta qui va te permettre de résoudre tes équations?

pour Jean-Marc: j'ai pensé que comme c'est un débutant, le fait de lui dire d'aller chercher les bibliothèques c'est un peu délicat surtout s'il ne voit pas comment intervient un RK pour résoudre une équation...

**feynman** · 18/04/2008, 17h15

Pour les debutants

il faut les donner un coup de main en premier temps! pour qu il sache comment travailler
pour cela je vais te donner ma subroutine que j ai fait sur la methode de runge kutta , reste l utiliser dans ton programme . Bon courage

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
           subroutine rungekutta(func,aa,bb,NN,YY)
	    external func
           integer i,NN
           double precision aa,bb,XX(0:NN-1)
           double precision  YY(0:NN-1),hh,K1,K2,K3,K4
           hh=(bb-aa)/NN
           do i=0,NN-1
             XX(i)=0.d0
             YY(i)=0.d0
           enddo
C.........valeur initial de XX(0) et YY(0)
           XX(0)=aa
C           YY(0)=func(XX(0))
             YY(0)=1.d0
C----------calcul du vecteur XX
           do i=0,NN-1
              XX(i+1)=XX(i)+hh
           enddo
 
C---------calcul des YY(i), k1,k2,k3,k4
           do i=0,NN-1	
              K1=hh*func(XX(i),YY(i))
              K2=hh*func(XX(i)+hh/2.,YY(i)+K1/2.)
              K3=hh*func(XX(i)+hh/2.,YY(i)+K2/2.)
              K4=hh*func(XX(i)+hh,YY(i)+K3)
              YY(i+1)=YY(i)+K1/6.+K2/3.+K3/3.+K4/6.
           enddo
           return
           end

**TheOyoStyledMan** · 18/04/2008, 17h30

Envoyé par feynman

Pour les debutants

il faut les donner un coup de main en premier temps! pour qu il sache comment travailler

Tu es bien gentil

Mais je n'ai pas refusé mon aide pour le Fortran! Je refuse juste le fait que l'on débarque quelque part et que l'on peut tout avoir "facilement". J'estime que si on lui demande un Runge-Kutta c'est qu'il a le niveau pour taper "Runge-Kutta" sur Google et voir à quoi ressemble cet algorithme qui permet de résoudre numériquement une équation différentielle et donc d'adapter cet algorithme pour son problème. (Du genre comprendre s'il a bien un équation différentielle dans ses équations).

Je pense que tu n'as pas besoin de te lancer directement dans des lignes de codes si tu ne sais pas ce que tu veux résoudre ou calculer au final.

PS: Désolé Kevin007 de te prendre de haut comme cela, mais si tu arrivais avec un algorithme tout beau tout chaud, je t'aurais volontiers aidé à écrire un code Fortran. Quand je vois que tu nous donnes les chiffres exacts pour qu'on te donne le résultat (genre Feynman qui a eu la gentillesse de te donner un code tout fait que tu n'auras juste qu'à compiler et exécuter pour avoir ton 20/20). Je rejoins vraiment Jean Marc: un peu de méthologie quand même...

Je suis presque sûr que Kevin007 va demander à quoi correspond func, aa, etc...

**feynman** · 18/04/2008, 17h37

Moi j ai donné le code mais j ai pas donné l algorithm, j ai supposé qu il sache l algorithme numérique. Par contre , vu qu il ne sache rien en fortran et il veut une aide j ai juste donner le code sans l expliquer. Maintenant c est son travail de chercher que veut dire external, double precsion, subroutine, ect...., et ensuite de savoire comment on a traduit l algorithme numerique a un code fortran.
Kevin il faut aller chercher maintenant dans cours fortran 77 dans le net et voire que signifient ces choses!

**kevin007** · 18/04/2008, 19h18

bonjour
en fait merci pour votre aide de me donner le code
mon probleme c'est que je comprend mais j'arrive pas l'utiliser j'ai bien compris le code mais pour l'utiliser a resourdre la question c'est trop dur et j'aimerais si ca vous derange pas de me donner le programme resolut a la question que j'ai poser pour la sonde pioneer 10 juste en debut de page
merci de votre gentillesse

**feynman** · 18/04/2008, 19h55

kevin007,
J utiliserai la methode et strategie de Jean-Marc

qui m a beaucoup donne' de puissance et m a transformee en un debutant en fortran a un (presque) bon programeur. On ne peut avancer en Fortran que si on ecrit notre code personnelement , meme si c est faux!
je t ai donne' la subroutine, tu dit que tu as tout compris, mais c est termine.
Tu doit maintenant ecrire un tableau YY(NN) (qui vient de la subroutine) et qui represente la solution numerique . ensuite , tu veut representer ta solution sur un graphe, pour cela tu met ton tableau dans un fichier que tu le nomme comme tu veut (par ex RK) de la facon suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
  open(1,file='RK.dat',status='unknown') 
        do i=1,NN
              write(1,*) i*h,YY(i)
        enddo
        close(1)

ensuite tu utilise gnuplot pour tracer ta courbe.
Voila, c est ton tour de travailler
bon courage

**feynman** · 18/04/2008, 20h00

Moi je programme en fortran 77, je ne sais pas si ce que je dit marche en fortran 90

**kevin007** · 18/04/2008, 21h24

Merci pour tout que tu me donnes
En fait ce que tu m'as donné c'est une partie du programme moi je voulais mettre les valeurs dans la question dans ce programme et comment
Merci

**feynman** · 18/04/2008, 21h33

Tout dépend de ton équation
Tu dois mettre ton edo sous forme Y'=f(x,Y)
Tu définis une fonction f hors programme et ensuite tu appelles ta subroutine et, à la place de func, tu dois mettre f.
Ecris le programme et dis-nous ce qui se passe

**kevin007** · 18/04/2008, 22h00

Pour faire un petit résumé, est-ce que vous pouvez me résoudre la question complètement s'il vous plait ? C'est ce que j'ai posé au début de la page en me donnant le programme entier, si ça ne vous dérange pas.
Merci beaucoup

**feynman** · 18/04/2008, 22h06

Je peux te le résoudre si c'est urgent ! Mais si tu as le temps ....
par contre je n'ai pas l'équation différentielle

**kevin007** · 18/04/2008, 23h21

Merci de votre aide, oui j'ai le temps
Vous me le résolvez sans l'équation différentielle et moi je mets l'équation différentielle apràs si c'est possible.
Merci

**FR119492** · 18/04/2008, 23h33

Salut !
Je te copie ici une subroutine que j'ai écrite il y a quelques années et qui est pratiquement équivalente à celle de Feynman, mais avec en plus des commentaires qui t'aideront à comprendre son fonctionnement:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
      Subroutine D006(SM,N,T,DT,Y)
C
C***********************************************************************
C
C     Bibliothèque JMBPACK
C
C     Série D: Equations différentielles
C
C***********************************************************************
C
C     Méthode de Runge-Kutta d'ordre 4 (1/6 + 2/6 + 2/6 + 1/6)
C
C***********************************************************************
C
C     Version 3.0: Jean-Marc Blanc, juillet 2004
C
C **********************************************************************
C
C     SM     Nom d'un sous-programme fourni par l'utilisateur pour le
C            calcul des dérivées à partir des valeurs de la variable
C            indépendante et des variables d'état. Ce sous-programme
C            doit être de la forme
C              Subroutine SM(N,T,Y,DY)
C                DY(1)= ...
C                DY(2)= ...
C                 .
C                 .
C                DY(N)= ...
C                Return
C              End
C            et avoir été déclaré dans une instruction External.
C
C     N      Ordre du système différentiel.
C
C     T      Variable indépendante.
C
C     DT     Pas d'intégration.
C
C     Y      Vecteur des variables d'état.
C
C **********************************************************************
C
      Implicit None
C
      Integer N
      Real*8 DT,T,Y(N)
C
      Integer I
      Real*8 DY(N),K1(N),K2(N),K3(N),K4(N),Z(N)
C
      Call SM(N,T,Y,DY)
      Do I=1,N
        K1(I)=DT*DY(I)
        Z(I)=Y(I)+K1(I)/2.d0
      End Do
C
      Call SM(N,T+DT/2.d0,Z,DY)
      Do I=1,N
        K2(I)=DT*DY(I)
        Z(I)=Y(I)+K2(I)/2.d0
      End Do
C
      Call SM(N,T+DT/2.d0,Z,DY)
      Do I=1,N
        K3(I)=DT*DY(I)
        Z(I)=Y(I)+K3(I)
      End Do
C
      Call SM(N,T+DT,Z,DY)
      Do I=1,N
        K4(I)=DT*DY(I)
        Y(I)=Y(I)+(K1(I)+2.d0*K2(I)+2.d0*K3(I)+K4(I))/6.d0
      End Do
C
      T=T+DT
      Return
C
      End

Un programme utilisant la méthode de Runge-Kutta ou une méthode équivalente comporte 3 parties (c'est plus clair si je commence par la fin):

Une subroutine que tu dois écrire toi-même et dans laquelle se trouvent les équations différentielles que tu veux intégrer. Cette subroutine a 4 paramètres: le nombre d'équations N, la variable indépendante T, qui est en général le temps, un vecteur Y contenant la valeur instantanée des variables d'état et un vecteur DY contenant la dérivée des variables d'état.N, T et Y sont les variables à l'entrée. DY est la variable de sortie, calculée dans la subroutine.
La subroutine que j'ai appelée D006 qui contient la méthode de Runge-Kutta elle-même. Elle est utilisable sans modification pour (presque) n'importe quel système d'équations différentielles. Tu peux donc la mettre dans une librairie de sous-programmes contenant les méthodes de base du calcul numérique. Comme tu le vois, elle appelle 4 fois la subroutine vue au point 1), en lui donnant le nom local SM. Tu dois évidemment lui indiquer quel est le nom effectif que tu as donné à cette subroutine.
Il te reste à écrire le programme principal, dans lequel tu définis le nombre d'équations N, les conditions initiales Y(t=0) et le pas d'intégration DT, puis tu fais une boucle sur les pas successifs que tu veux effectuer. A chaque pas, tu appelles D006 en lui donnant le nom effectif que tu as donné à ta subroutine, le nombre d'équations N, la variable indépendante T, le pas d'intégration DT et le vecteur d'état Y. Le nom de ta subroutine doit être déclaré dans une instruction External. A chaque appel, T et Y sont mis à jour.

Pour clarifier les choses, voici un petit exemple. Tu programmes d'abord la subroutine qui contient tes équations différentielles:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
      Subroutine Trigo(N,T,Y,DY)
C
      Implicit None
      Integer N
      Real*8 T,Y(N),DY(N)
C
      DY(1)=Y(2)
      DY(2)=-Y(1)
C
      Return
      End

Ensuite, tu peux écrire ton programme principal:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
      Program Test
C
      Implicit None
      Integer I
      Real*8 T,DT,Y(2),Pi
      External Trigo
C
      Pi=3.1415926535d0
      Open (7,File='Result.txt')
      T=0.d0
      DT=Pi/18.d0
      Y(1)=0.d0
      Y(2)=1.d0
      Write (7,'(3F10.3)') T,Y(1),Y(2)
C
      Do I=1,72
        Call D006(Trigo,2,T,DT,Y)
        Write (7,'(3F10.3)') T,Y(1),Y(2)
      End Do