Discussion :

[SKone]

Amis du jour, bonjour; Amis du soir, bonsoir, ...
Depuis peu je me suis surpris à coder. En C++ malgré une infidélités en passant par le C#. Je me suis remis à coder mon moteur physique. Et j'ai décidé de tenté une seconde tentative de virer Euler...

J'ai appelé Runge et Kutta les 2 et tous ça pour un ordre niveau 4...

Je rappel RK4 (c'est comme ça qu'on l'appel pour les intimes)...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
dy = f(t; y)
y(t0) = y0
 
k1 = f(tn; yn)
k2 = f(tn + dt/2; yn + dt/2*k1)
k3 = f(tn + dt/2; yn + dt/2*k2)
k4 = f(tn + dt; yn + dt*k3)
 
p = (k1 + 2*k2 + 2*k3 + k4)/6
 
    * k1 est la pente au début de l'intervalle ;
    * k2 est la pente au milieu de l'intervalle, en utilisant la pente k1 pour calculer la valeur de y au point tn + h/2 par le biais de la méthode d'Euler ;
    * k3 est de nouveau la pente au milieu de l'intervalle, mais obtenue cette fois en utilisant la pente k2 pour calculer y;
    * k4 est la pente à la fin de l'intervalle, avec la valeur de y calculée en utilisant k3.

Et bien moi j'utilise cette méthode pour un problème relativement simple... J'ai une force et je veux connaitre la position après le dt...

Alors avec euler je fesais
Pos += force*dt*dt (partout j'ai lu *dt mais j'ai remarqué bizarrement que c'est plus stable avec dt² [éclairer moi sur cet alchimie]).

Moi je cherches la position alors
y = Position
dy = Force
Comme la dérivée c'est une pente alors...
k1 c'est ma force
k2 avec Euler ça donne : k1*dt*dt/4
k3 avec Euler ça donne : k2*dt*dt/4
k4 avec Euler ça donne : k3*dt*dt

Si j'ai bien compris c'est ça... Mais il semblerait que j'ai rien compris puisque le système comme avec Euler... La force c'est la graviter + la force de ressort...

Si quelqu'un pourrait m'aider...

voilà mon Code :

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
// Methode de Runge-Kutta 4
					case RK4 :
							fVector3D k1, k2, k3, k4, pente;
							// Appliquer l'integration à toute les particules
							for(size_t i = 0; i < S; ++i)
							{
								// recuperer une particule indexé en i
								E_Particule p = ArrPrtcl.GetParticuleAt(i);
								// verifier si la particule n'est pas statique
								if(p.Static == false)
								{
									fVector3D curPos = p.curPos;
									/* schéma de Runge-Kutta d'ordre 4 pour X, Y, Z */
									k1 = p.force;
									k2 = k1 * dt * dt / 4;
									k3 = k2 * dt * dt / 4;
									k4 = k3 * dt * dt;
									pente = (k1 + k2*2 + k3*2 + k4) / 6;
									p.curPos += pente * dt * dt;
									p.oldPos = curPos;
									// Affecter la particule
									ArrPrtcl.SetParticuleAt(i, p);
								}
							}
						break;

Merci

[millie]

Tu peux avoir un code source pour résoudre une équation par Runge-Kutta en C++ ici, si tu veux :

http://www.developpez.net/forums/sho...d.php?t=236982

Je sais pas si ça pourra t'aider.

[SKone]

Desoler ça ne m'aide pas vraiment parce que la méthode montré dans ton code est une résolution de dx/dy = force...

Alors que moi je peux pas donnée une équation explicite du fait que je ne connais pas la position d'après sinon ce que je fais ne sert a rien...

Ton exemple donne une équation explicite si je me souviens bien 2*x*y et tu use de RK4 comme résolution qu'équadiff alors que moi je cherches la position d'après est ce que tu pourrais m'aider ?

[millie]

Non, mon code permet de résoudre une équation différentielle du premier degré, pas forcement linéaire du type :

dy/dx = f(x,y)

C'est à dire que cela peut aussi bien résoudre :
dy/dt = k * y(t) où encore dv/dt = force(t) + mg par exemple.

C'est à toi de trouver la bonne fonction à appliquer.