Discussion :

[24titou24]

Bonsoir,

j'espere que vous pourrez m'apporter de l'aide. je suis actuellement en train de reprendre le code de quelqu'un dans le cadre d'un projet et je voudrais remplacer un pas de temps adaptatif qui se trouve dans se code par autre chose, mais je ne sais pas quoi...

1°) le code permet de calculer en fonction du temps l'evolution d'un nombre de données et l'evolution de la taille de ces données. Les equations qui régissent le probleme sont du type:

dN/dt=6*a*exp(-t/b) et dT/dt=b.c^0.5

avec a, b,c des valeurs qui dépendent d'où on se trouve dans le calcul. t est le temps et dN et dT sont les quantité que je souhaite calculé (evolution du nombre N et de la taille T)

2°) ce qui est fait actuellement est que l'on part d'un pas de temps tres tres faible et que l'on calcul pour le premier pas:

IncrementN=(dN/dt)*Increment_t
IncrementT=(dT/dt)*Increment_t

ensuite on verifie que les resultats N et T sont cohérents:
N=N-1+IncrementN
T=T-1+IncrementT

si c'est le cas alors le prochain increment de temps sera:
Increment_t=Increment_t*1.3
sinon on reduit l'increment pour etre plus precis:
Increment_t=Increment_t*0.5

3°) cette methode marche bien mais ce n'est pas du tout optimisé car les coefficients que je mets pour augmenter ou reduire le pas de temps sont dependants du probleme et je ne peux donc pas les optimiser pour ameliorer les temps de calculs.

Sauriez vous si il existe une autre methode de resoudre mon probleme?

[pseudocode]

Ca ressemble grandement à la régulation d'un système (cf. Régulateur PID).

Avec (N[i],T[i]) comme comme consigne d'entrée, Increment_t comme commande, et tes 2 formules comme fonction de transfert :

N[i] --> N[i]+(dN/dt)*Increment_t
T[i] --> T[i]+(dT/dt)*Increment_t

[Nebulix]

a, b,c des valeurs qui dépendent d'où on se trouve dans le calcul.

Ca veut dire quoi ? Qu'elles dépendent aussi du temps ?

[24titou24]

hello hello
c gentil de m'apporter votre help

Ca ressemble grandement à la régulation d'un système (cf. Régulateur PID).

oui peut etre en effet

Avec (N[i],T[i]) comme comme consigne d'entrée, Increment_t comme commande, et tes 2 formules comme fonction de transfert :
N[i] --> N[i]+(dN/dt)*Increment_t
T[i] --> T[i]+(dT/dt)*Increment_t

c exactement ce que je fais actuellement et je voudrais savoir si il existe pas une façon d'ameliorer cela
=> par exemple avec un algorithme d'euler ou runge kutta ou des truc dans ce style...
=> comme je ne m'y connait pas trop dans ces truc je voudrais avoir votre avis dessus

Ca veut dire quoi ? Qu'elles dépendent aussi du temps ?

en fait elles ne dependent pas explicitement du temps. Elles dependent de l'historique qu'il y a eu avant.

A chaque pas de temps on peut les considere comme des constantes

[24titou24]

je relance le poste, en espérant plus d'indications...
merci d'avance

[pseudocode]

c exactement ce que je fais actuellement et je voudrais savoir si il existe pas une façon d'ameliorer cela
=> par exemple avec un algorithme d'euler ou runge kutta ou des truc dans ce style...
=> comme je ne m'y connait pas trop dans ces truc je voudrais avoir votre avis dessus

C'est une intégration avec un pas adaptatif. Dans ton cas, le pas est modifié à chaque étape par un facteur constant (1.3 ou 0.5). Le mieux serait que ce facteur soit variable.

Wikipedia à un article sur le sujet : Adaptive stepsize. Ca peut te servir de point de départ pour ton problème.

[membreComplexe12]

salut! je m'incruste dans la discussion ;-)

quel serait le critère qui ferai varier coefficient ?

[pseudocode]

salut! je m'incruste dans la discussion ;-)

quel serait le critère qui ferai varier coefficient ?

Généralement on estime la valeur avec une méthode d'ordre "p", et une méthode d'ordre "p+1". La différence de valeur obtenue nous indique si l'estimation d'ordre "p" est suffisamment bonne ou pas.

[membreComplexe12]

tu peux me donner un exemple s'il te plait car je ne suis pas certain d'avoir compris ce que tu voulais dire...

=> une deuxième question:
j'ai fait un petit programme avec un pas de temps adaptatif comme Titou et ce genre de programmation semble amener à des oscillations/instabilités.

J'ai fixé le critere suivant:
=> si une quantité que j'appelerai "A" est négative (ce qui n'arrive que si le pas de temps est trop grand) alors je divise le pas de temps par 2
=> si la quantité n'est pas trop grande alors le pas de temps est multiplié par 1.1

j'ai remarqué que dans la fin de mon programme (lorsque "A" est proche de 0) il y a des oscillations:
=> le pas de temps est sens cesse multiplié par 1.1 puis ensuite divisé par 2 et je tourne dans une boucle presque infini à cause de ceci...

[pseudocode]

tu peux me donner un exemple s'il te plait car je ne suis pas certain d'avoir compris ce que tu voulais dire...

Pour calculer la valeur suivante, le PO utilise une méthode d'ordre 1 (euler = RK1)

N[i+1] = N[i] + step*dérivée(t,N[i])

On peut également calculer plus finement en prenant en compte la variation de la dérivée sur l'intervalle [t,t+step] (RK 2)

N[i+1] = N[i] + step*dérivée(t+step/2 , N[i]+step/2*dérivée(t,N[i]))

Si ces deux calculs nous donnent a peu près le même résultat, alors c'est que la fonction suivait bien la tangente de départ sur l'intervalle... Sinon, c'est que la fonction n'a pas suivi la tangente, surement car notre intervalle est trop grand => il faut diminuer l'intervalle (donc le 'step')

=> une deuxième question:
j'ai fait un petit programme avec un pas de temps adaptatif comme Titou et ce genre de programmation semble amener à des oscillations/instabilités.

J'ai fixé le critere suivant:
=> si une quantité que j'appelerai "A" est négative (ce qui n'arrive que si le pas de temps est trop grand) alors je divise le pas de temps par 2
=> si la quantité n'est pas trop grande alors le pas de temps est multiplié par 1.1

j'ai remarqué que dans la fin de mon programme (lorsque "A" est proche de 0) il y a des oscillations:
=> le pas de temps est sens cesse multiplié par 1.1 puis ensuite divisé par 2 et je tourne dans une boucle presque infini à cause de ceci...

Pour éviter les oscillations, il faut également un critère qui ne modifie pas le 'step'.

[membreComplexe12]

Pour calculer la valeur suivante, le PO utilise une méthode d'ordre 1 (euler = RK1)
N[i+1] = N[i] + step*dérivée(t,N[i])
On peut également calculer plus finement en prenant en compte la variation de la dérivée sur l'intervalle [t,t+step] (RK 2)
N[i+1] = N[i] + step*dérivée(t+step/2 , N[i]+step/2*dérivée(t,N[i]))
Si ces deux calculs nous donnent a peu près le même résultat, alors c'est que la fonction suivait bien la tangente de départ sur l'intervalle... Sinon, c'est que la fonction n'a pas suivi la tangente, surement car notre intervalle est trop grand => il faut diminuer l'intervalle (donc le 'step')

d'accord je comprends ceci

Pour éviter les oscillations, il faut également un critère qui ne modifie pas le 'step'.

donc si je comprends bien je vais un "step" variable lors de tous les calculs sauf dans le cas où je suis très proche de "A=0" qui est le cas où j'ai mes oscillations ???

[pseudocode]

donc si je comprends bien je vais un "step" variable lors de tous les calculs sauf dans le cas où je suis très proche de "A=0" qui est le cas où j'ai mes oscillations ???

Oui, c'est une possibilité.

[membreComplexe12]

vois tu d'autres possibilités sinon?

[souviron34]

un critère d'arrêt (critère de convergence)..

Il y a un moment (suivant ce qu'on modèlise et la précision des éléments) où descendre en dessous d'un certain seuil n'a plus de sens..

Donc, ce n'est pas vraiment "zéro", mais "> précision" qu'il faut tester..

[membreComplexe12]

en fait dans mon cas "A" ne peut pas être également à zero, c'est donc ceci mon critère.

=> par contre que dois je faire selon doit lorsque je me trouve vers cette limite ?

[souviron34]

incrément = constante ?