Discussion :

[matiii]

Bonjour,
j'ai le bout de code suivant.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
mesh Th=square(N,N,[x,y]);
real T=1;
real t=0,dt;
for(dt=1;dt>1./N;dt/=2)
{
	for (t=0;t<T;t+=dt) 
	{
		calculer la solution approchée;
	}
  real error = solution exacte - solution approchée
}

Je ne comprends pas le principe de ces deux boucles. Il y a une boucle sur le pas de temps dt puis à l'intérieur une boucle sur t. C'est un peu flou, ça veut dire qu'on calcule la solution approchée pour chaque t, puis on calcule l'erreur sur chaque maillage ? L'erreur ne devrai t-elle pas se calculer sur pour chaque t ?

Cordialement

[Flodelarab]

Bonjour

ça veut dire qu'on calcule la solution approchée pour chaque t,

Non.
t est toujours un balayage de l'intervalle [0;1]. (enfin [0;T], mais ici T vaut 1).

puis on calcule l'erreur sur chaque maillage ?

Oui.

L'erreur ne devrai t-elle pas se calculer sur pour chaque t ?

Non.
Prenons un t de 0.1; la valeur obtenue sera la même que ton maillage soit fin, moyen, ou grossier.
Donc faire un calcul sur un seul point sera toujours le même et ne permet rien de conclure sur le maillage plus ou moins serré.

[matiii]

Merci pour la réponse.
Je ne comprend pas le dernier point:
1- à quoi ça sert de calculer l'erreur sur chaque maille l'une plus fine que l'autre? C'est quoi la différence si on prend un seul pas de temps dt fixe et on calcul l'erreur pour chaque t?
2- pour chaque dt on fait une série de calcul dans la petite bloucle sur t. Comment cela se fait qu'on sort avec une unique valeur pour l'erreur?

Cordialement

[Flodelarab]

Comment cela se fait qu'on sort avec une unique valeur pour l'erreur?

On ne sort pas une valeur unique mais autant de valeurs que de tours de boucle dt, c'est-à-dire autant que de maillages.

à quoi ça sert de calculer l'erreur sur chaque maille l'une plus fine que l'autre?

Relis le code. On ne demande pas de calculer l'erreur pour chaque maille mais pour chaque maillage.

C'est quoi la différence si on prend un seul pas de temps dt fixe et on calcul l'erreur pour chaque t?

Tu ne calculeras pas d'erreur pour chaque t puisque ta valeur approchée n'est obtenue qu'en passant tous les t en revue.

[matiii]

D'accord, pardon si je pose trop de question, j'essaye de bien comprendre.
Alors on calcule la solution approchée sur un maillage 1 et après on calcule l'erreur $||u-u_h||_H^1$ (l'erreur est en norme $H^1$ dans mon cas). Ensuite on passe à un maillage plus fin, on calcul la solution approchée puis on calcul l'erreur $||u-u_h||_H^1$, et on raffine le maillage de plus en plus plus et à chaque fois on calcul la solution approchée puis l'erreur sur le nouveau maillage.

1- C'est faux de calculer l'erreur sur un seul maillage fixe? C'est à dire on fixe un seul dt et on calcul la solution approché sur ce maillage puis l'erreur (donc pas de boucle sur $dt$). C'est quoi le but de calculer l'erreur sur plusieurs maillages?
2- il y a l'instruction
ofstream error("erreur");
dans le programme. ça nous donne un fichier .txt où la première colonne contient les dt et la deuxième colonne les valeurs de l'erreur.
On peut tracer les erreur avec gnuplot. Qu'est ce qu'il faut tracer sur le même graphe pour savoir si le schéma converge ou pas?
3- est-ce que l'erreur en norme $H^1$ doit être de l'ordre $10^{-3}$ pour dire que le code fonctionne?
4- on prend dt de 1 et on continue jusqu'à dt>1./N: que veut dire ce choix? Comment on a l'idée de choisir de stopper jusqu'à 1/N?

Merci beaucoup pour toute votre aide et pour vos réponses claires, ces dernières questions m'aideront à mieux comprendre le schéma utilisé.
Bien cordialement

[Flodelarab]

C'est faux de calculer l'erreur sur un seul maillage fixe?

Ce n'est pas faux puisque c'est ce que fait ton programme.

C'est à dire on fixe un seul dt

C'est ce que fait ton programme.

on calcul la solution approché sur ce maillage

C'est ce que fait ton programme.

puis l'erreur

C'est ce que fait ton programme.

(donc pas de boucle sur $dt$)

Une fois qu'on a fait tout ce qui a été détaillé, on recommence avec un autre "dt".

C'est quoi le but de calculer l'erreur sur plusieurs maillages?

La réponse est dans la question. Comparer les résultats en fonction du maillage.

ça nous donne un fichier .txt où la première colonne contient les dt et la deuxième colonne les valeurs de l'erreur.

Donc tu vois bien que ça a bouclé.
Chaque ligne est un tour de boucle "dt".

est-ce que l'erreur en norme $H^1$ doit être de l'ordre $10^{-3}$ pour dire que le code fonctionne?

Ne connaissant pas le but du code, personne ne peut dire s'il fonctionne ... à part toi.

on prend dt de 1 et on continue jusqu'à dt>1./N:

C'est exactement le contraire. On continue tant que la condition est vraie. Et pas "jusqu'à".

que veut dire ce choix?

Le maillage est 2 fois plus serré à chaque tour de boucle. "dt=dt/2"
Il faut bien s'arrêter. Quelle est la condition d'arrêt ?
On s'arrête quand le maillage est plus serré que le maillage minimum passé en argument de la fonction.
C'est là que transmettre 1000 à ce code donne un minimum de 1/1000 soit 10^-3.
Mais on peut prendre N=1 000 000 et on ira jusqu'à 10^-6.

Comment on a l'idée de choisir de stopper jusqu'à 1/N?

Toute boucle provoque la question : Quelle est la condition d'arrêt ?
Il devrait être interdit de faire de l'informatique à ceux qui font des boucles infinies.
La boucle for est une boucle. Il faut prévoir son arrêt. Que proposes-tu comme butoir ?

[matiii]

Si j'ai bien compris, la conclusion est que pour voir si un schéma est bon, on ne regarde pas l'ordre de l'erreur à chaque temps! il faut voir si l'erreur converge vers 0 tant qu'on affine le maillage. C'est bien ça?

[Flodelarab]

Si le maillage est grossier, on fait un tour. L'erreur est grande. Sinon, on ne s'embêterait pas à faire des maillages plus fins.
Si le maillage est infiniment fin, on fait des milliards de milliards de tours. L'erreur est infime. Mais on ne veut pas faire autant de tours. C'est trop long.

La question n'est pas de savoir si l'erreur tend vers 0. Car cela est sûr. (et présupposé).
La question est de savoir à partir de quel maillage, on se trouve en dessous d'une erreur acceptable.

Ni trop lâche (trop faux), ni trop serré ( trop long).


A priori.

[matiii]

Voici les erreurs que j'ai obtenu

dt        error

1         3.70639
0.5       1.62684
0.25      0.730348
0.125     0.35554
0.0625    0.200375
0.03125   0.142667
0.015625  0.124712

Cela vous semble correct comme résultat?

[Flodelarab]

C'est ce que j'ai décrit. Donc oui.

Il vaut mieux avoir une première colonne en 1/dt.
Sinon la représentation de la convergence n'est pas naturelle.

Code :

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

plot "toGnuplot.txt" using 1:2 with lines

[matiii]

Merci beaucoup! Donc je retiens deux choses essentielles:
il n'est pas correct de calculer l'erreur pour chaque t pour un seul maillage fixe et chercher à ce que pour chaque t il faut que l'erreur soit d'ordre $10^{-3}$ mais plutôt, il faut considérer plusieurs maillages de plus en plus fins et voir si l'erreur décroit et dans ce cas là c'est une preuve que le code fonctionne. C'est bien ça? S'il vous plaît.

Pour le plot plus naturelle, j'ai essayé votre commande avec Gnuplot et ça ne donne pas le même résultat que le votre. Ou bien il faut d'abord calculer 1/dt à la main? Cela ne se fait pas automatiquement?

[Flodelarab]

Ou bien il faut d'abord calculer 1/dt à la main?

Pas à la main.


Tu parles de gnuplot mais ce forum n'est pas attaché à un système particulier.
Si tu es sous Linux, tu peux faire ceci :

Code :

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

awk '{print 1/$1,$2;$1;}' fichier.txt > toGnuplot.txt

Puis

Code :

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

gnuplot

Puis

Code :

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

plot "toGnuplot.txt" using 1:2 with lines

Ou alors plus simplement changer la première colonne à partir de ton programme.


Ou alors n'afficher que la deuxième colonne en bazardant la valeur de la première colonne (dès le fichier de départ):

Code :

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

plot "toGnuplot.txt" using 2 with lines

Pour la question de fond, on ne connaît pas les données du problème.
Tout ce qu'on peut dire, c'est qu'il faut bien sortir de la boucle intérieure pour commencer à calculer une erreur dans la boucle extérieure.

c'est une preuve que le code fonctionne

Tu n'as toujours pas dit le but. Tu es seule juge.

[matiii]

Bonjour
désolée je n'ai toujours pas compris la logique du choix du pas de temps dt. On a commencé par dt=1 puis on divise par deux à chaque fois mais jusqu'où on s'arrête? Et surtout comment faire si on veut commencer par un pas de temps dt très petit par exemple 0.1 et diminuer encore plus encore? Car avec ce pas de temps l'erreur n'est pas assez petite.

Cordialement

[tbc92]

Personnellement, jusqu'à la semaine dernière, j'avais la certitude de maîtriser le sujet 'Maillage et erreur d'approximation'. Mais je n'ai rien compris à cette discussion. Ni les questions, ni les réponses.
Il faut redescendre un peu. L'art des mathématiques, c'est l'art de simplifier des problèmes compliqués, et pas l'inverse.

Quand on parle de maillage, en gros, on remplace une fonction assez banale par une succession des segments (ou une succession de carrés si on est dans R²...). Bien évidemment, si on prend énormément de tout petits segments, la forme générée à partir du maillage sera très proche de la forme d'origine. Et plus on a un maillage fin, plus on a une bonne approximation de la forme recherchée.
Quel est le bon 'niveau', faut-il découper le segment [0;1] en 100 segments, ou en 1000, ou en 100000000000 ? personne n'a la réponse à cette question. Il n'y a pas de réponse universelle. Tout dépend de ton 'cahier des charges'. Un maillage , c'est un compromis, un compromis entre le coût de traitement, et la précision souhaitée.

[matiii]

Ma question est: si on choisit N=1000 comment choisir dt?

[tbc92]

Tu connais le contexte, tu sais ce que représente N, nous on ne le sait pas. Donc comment peux-tu imaginer recevoir une réponse constructive à cette question ?

Au début, tu dis que tu as une portion de code ... C'est quoi ce code ? Il sert à qui, à quoi ? Essayons de le comprendre ...

Tu as un tableau Th de NxN valeurs, Et j'imagine que dans la ligne 8 de ce code, on lit des données de ce tableau.
Et en l'occurrence, on dit :
J'exploite uniquement très peu de valeurs de Th, et je fais un certain traitement.
Puis J'exploite plus de valeurs , et je fais un traitement similaire
etc, en exploitant de plus en plus de valeurs de ce tableau.
Et dans la dernière itération, on exploite toutes les valeurs.

Ce qui permet de montrer que quand on exploite peu de valeurs, on a un résultat peu précis. Et quand on exploite plus de valeurs, on a un résultat plus précis.
C'est ce qui ressort dans ton copier/coller :

  1         3.70639
0.5       1.62684
0.25      0.730348
0.125     0.35554
0.0625    0.200375
0.03125   0.142667
0.015625  0.124712

La boucle for(dt=1;dt>1./N;dt/=2) sert juste à montrer comment le résultat s'améliore à chaque étape.

Ici, quand on regarde les valeurs ( .... 0.015625 0.124712 ), on a quand même des doutes. Pas des doutes sur la technique de maillage, mais des doutes sur cette procédure "calculer la solution approchée;"
On voit que La précision du traitement s'améliore au début, puis ne n'améliore plus. On arrive à un palier qui est loin de 0.
Je pense qu'il y a des erreurs d'arrondis dans ton traitement.

[matiii]

Bonjour
voici le code (en freefem++): il s'agit de calculer la solution approchée d'un problème parabolique dont on connait la solution exacte, puis de calculer l'erreur en norme H^1 de la différence entre la solution exacte et la solution approchée. Pour l'instant j'ai de mauvais résultats car l'erreur reste grande. Ma question est svp quelle valeur donner au pas de temps et d'espace pour que l'erreur soit au plus 0.1 donc petite.

[Flodelarab]

pour que l'erreur soit au moins 0.1

pour que l'erreur soit au plus 0,1.

[matiii]

Oui Flodelarab merci j'ai corrigé. J'ai lu qu'on peut avoir une idée des valeurs de pas à prendre en prolongeant la courbe de l'erreur obtenue pour des discretisations plus grossières, mais je ne comprends pas très bien en quoi ça consiste. Merci de m'aider.

[tbc92]

J'essaie de lire le code, et ce n'est pas clair du tout. Et tu ne fais pas beaucoup d'efforts pour que ce soit clair.

J'essaie de comprendre la ligne la plus simple, : err = sqrt(int2d(Th)(square(uh - uex(t)))+ int2d(Th)( square(dx(uh)-ux(t))+ square(dy(uh)-uy(t)) ));

Pour ma part, j'aurais plutôt imaginé cela : err = sqrt( int2d(Th)( square(dx(uh)-ux(t))+ square(dy(uh)-uy(t)) ));

Même si c'est idiot, peux-tu faire le test avec cette variante, et montrer le résultat ?

Question sur ce langage.
On a square(dx(uh)-ux(t)) sur cette ligne, ça s'écrirait comment dans un langage plus classique ? (dx(uh)-ux(t))² , c'est ça ?
Et on a mesh Th=square(N,N,[x,y]); au tout début du code, et là, square a une toute autre signification, ça permet de créer une matrice de N x N éléments, c'est ça ?