variable dépendant de 2 boucles for

Version imprimable

03/07/2012, 10h37
clem3900

variable dépendant de 2 boucles for
Bonjour,

je voudrais tracer une variable B en fonction d'une variable R, mais la variable B dépend de 2 boucles for...
Voici mon programme simplifié:
Code:

1 2 3 4 5 6 for R=0:5:1000 t = a*R + b for la=540:0.1:560 B = c*la + d*t end end
Et moi mon objectif serait de tracer B en fonction de R. Il faudrait donc que j'obtienne B, avec t = b, par exemple, et qu'ensuite B soit calculé pour tous les la, puis il faudrait t = 5*R + b et B calculé pour tous les la etc....

Si quelqu'un a une idée...
Merci
03/07/2012, 10h47
TRSRT

En gros, corrige moi si je me trompe mais tu veux tracer "B" en fonction de "la" et ce pour chaque valeur de R c'est cela?

Veux tu tout sur la même figure (donc graphique 3D) ou alors une figure par valeur de R?

Antoine
03/07/2012, 10h56
clem3900

Non je veux tracer B en fonction de R et ce pour chaque valeur de la.
Pour chaque tour de boucle j'ai une valeur de B en fonction de la , et cette valeur je veux la tracer en fonction de R.
Donc au final ça devrait me donner un graph 2D, avec B en ordonnées et R en abscisse.

Bonjour,

Tu as besoin de structure dans tes idées et de coder proprement. Expose nous ton problème en entier, ça simplifiera les choses. Mais à ce que je vois, tu es en train de faire des sortes de balayages sur certaines valeurs. Essaye plutôt de faire des choses du style :
Code:

1 2 3 4 c = 5; la = [540:0.1:560]; B = c*la; plot(la, B)
teste et regarde ce que ça donne. Tu peux essayer de comprendre le code, mais décris-nous déjà ton problème en entier (math/physique/... ?), c'est quoi R ? c'est quoi t ? etc...

En attendant, voici une solution possible :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 clear all; a = 5; b = 3; c = 1; d = 4; R = [0:5:1000]; la = [540:0.1:560]; [Nlignes, Ncolonnes] = size(la); t = a*R+b; B{c} = []; for k=1:Ncolonnes B{k} = c*la(k) + d*t; end % puis pour afficher le graphique pour la 15° valeur de la (ie: "la(15)") plot(R,B{15});

03/07/2012, 11h19
TRSRT

Citation:

Envoyé par clem3900

Non je veux tracer B en fonction de R et ce pour chaque valeur de la.

Alors tes boucles ne sont pas bonnes je crois :roll: là pour chaque R tu as B en fonction de la :?

Citation:

Envoyé par clem3900

Pour chaque tour de boucle j'ai une valeur de B en fonction de la , et cette valeur je veux la tracer en fonction de R.
Donc au final ça devrait me donner un graph 2D, avec B en ordonnées et R en abscisse.

donc tu veux pour chaque valeur de la une figure de B=f(R) ? Alors, je reviens au problème décrit en début de ce message, tu es pas dans le bon ordre des boucles for :?

édit: je n'avais pas vu la solution de tachmou, tu peux effectivement essayer comme cela!;)

Voilà mon code complet:

Code:

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
80
81
82
 
clear all; 
clc,close all;
 
    e = 1.6E-19;        
    E0 = 8.85E-12;      
    me = 9.11E-31;      
    c = 3E8;           
    h = 6.63E-34;       
    kb = 1.38E-23; 
    kb2 = kb/1.6E-19;
    l = 546E-9;
    n0 = 7E25 ; 
    a = 10;
    b = 3;
    w = 0.22;
    tmid = 3700;
    t0 = 8350;
    twall = 1230;
    T=8500;
 
    E1=4.67; E2=4.89;E3=5.46;
    E4=6.7;
    E5=7.73;
    E6=7.93; 
    E7=8.54; E8=9.77; 
    E9=8.61; E10=8.64; E11=8.83;
 
 
 
format long e;
 
    for R=0:5:1000
        t = tmid - (tmid - twall)*(R/1000)^a + (t0 - tmid)*exp(-(((R/1000)^b)/(w^b)));
        mRt(R/5+1,:) = [R/1000 t];
 
        S1=3*(exp(-(E1/(kb2*t))));
        S2=3*(exp(-(E2/(kb2*t))));
        S3=3*(exp(-(E3/(kb2*t))));
        S5=3*(exp(-(E5/(kb2*t))));
        S4=(exp(-(E4/(kb2*t))));
        S6=(exp(-(E6/(kb2*t))));
        S7=2*(exp(-(E7/(kb2*t))));
        S8=2*(exp(-(E8/(kb2*t))));
        S9=3*(exp(-(E9/(kb2*t))));
        S10=3*(exp(-(E10/(kb2*t))));
        S11=3*(exp(-(E11/(kb2*t))));
 
        S123= S1+S2+S3;
        Si= S1+S2+S3+S4+S5+S6+S7+S8+S9+S10+S11;
        Ni = n0*(exp(-(E1)/(kb2*t)))/Si;
        mRNi(R/5+1,:)=[R/1000 Ni];
 
 
            for la=540:10:560
                B = ((2*h*c^2)/((la*1E-9)^5))*(1/(exp((h*c)/((la*1E-9)*kb*t))-1));
                mRB(R/5+1,:) = [R/1000 B];
 
                Blu = ((la/1E9)^3)*(4.87E7)/(8*pi*h);
                mRBlu(R/5+1,:) = [R/1000 Blu]
 
                Flu = (4*E0*h*c*me)/(e^2)*((la/1E9)^2)*(4.87E7)/(8*pi*h);
                mRFlu(R/5+1,:) = [R/1000 Flu];
 
                P = (1/2)*(((0.3*n0^2)/(20E-9)^2)^(1/2))*exp(-(pi*(0.3*n0^2))/(4*20E-9));
 
                Kline = ((e^2)*Flu*1E-14*n0)/(4*E0*me*c);
                mRKline(R/5+1,:) = [R/1000 Kline];
 
                L = B*Kline;
                mRL(R/5+1,:) = [R/1000 L];
            end
    end   
 
figure(1);
subplot(3,3,1);plot(mRt(:,1),mRt(:,2), 'b-');title('T');
subplot(3,3,2);plot(mRNi(:,1),mRNi(:,2));title('Ni');
subplot(3,3,3);plot(mRBlu(:,1),mRBlu(:,2));title('Blu');
subplot(3,3,4);plot(mRFlu(:,1),mRFlu(:,2));title('Flu');
subplot(3,3,5);plot(mRKline(:,1),mRKline(:,2));title('Kline');
subplot(3,3,6);plot(mRB(:,1),mRB(:,2));title('B');
subplot(3,3,7);plot(mRL(:,1),mRL(:,2));title('L');

Dans mon problème, j'ai un cylindre dont le rayon relatif est R. Ce cylindre émet un rayonnement lumineux B qui dépend de la longueur d'onde 'la' et de la température t.
Les formules viennent d'une publication, et moi mon objectif c'est de tracer L en fonction de 'la', avec 'la' compris entre 540 et 560 nm.Pour l'instant je voudrais tout tracer en fonction de R pour voir si mes courbes ont un sens ou pas... Le problème c'est que Blu (et donc Flu et Kline) est constant car il prend la dernière valeur de la (560nm) au lieu de varier entre 540 et 560. Avec ce programme je pense que mon B est bon mais je ne suis pas sur, d'où ma question. Mais en fait mon plus gros problème c'est Blu...

03/07/2012, 11h32
tachmou
Ok, merci d'avoir décrit.

Alors pour tes variables, tu t'es planté (tu écrases tes valeurs à chaque pas de temps, donc tu ne les as plus à la sortie de ta boucle !). Plusieurs conseils, dans l'ordre :

- Crée un fichier "test.m" dans lequel tu vas effectuer des tests basiques
- enlever un point virgule à la fin d'une ligne te permets d'afficher le résultat dans ton command window quand tu fais "F5" : très pratique pour faire des tests à l'arrache
- pour stocker des séries de données, utilise R = [0:0.1:1000] plutôt qu'une boucle... compare les deux codes :
Code:

1 2 3 4 5 6 7 R = [0:0.1:10]; for k = 1:size(R,2) R(k) end disp('-------------------------') R k
et
Code:

1 2 3 4 5 for R = 0:0.1:10 R end disp('-------------------------') R
Tu remarqueras quelque chose... que tu as fait dans ton code !

Ce que j'ai utilisé c'est un tableau à 1 ligne et plusieurs colonnes. Pour connaître le nombre de colonne j'ai fait size(R,2). Du coup, autre conseil : fais souvent des "help" dans le command window...

Code:

help size

ainsi que des "doc" :

Code:

doc size

et regarde un peu qu'est ce qu'ils racontent, et pourquoi j'obtiens effectivement le nombre de colonnes.

Enfin, utilise des cellules comme je l'ai fait dans la solution que je t'ai proposé avec les accolades : ce type de structure te permet de mettre ce que tu veux dans chaque élément B{k} pour k variant de 1 à ce que tu veux avec un pas de 1.

A partir de tout ça, tu reformules ton problème clairement pour être sûr de bien tracer ce dont tu as réellement besoin, et pas autre chose.

Si tu as d'autres questions, n'hésites pas à me demander, je tenterai de t'expliquer... par contre je ne connais pas le vocabulaire exact...

Dernier conseil : go lire ce site.

j'ai changé mon programme, maintenant j'ai ça:
Code:

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 R = [0:5:1000]; la = [540:0.1:560]; [Nlignes, Ncolonnes] = size(la); t = tmid - (tmid - twall).*(R./1000).^a + (t0 - tmid).*exp(-(((R./1000).^b)/(w^b))); % B{1} = []; for k=1:Ncolonnes B{k} = ((2*h*c^2)./((la(k).*(1E-9)).^5)).*(1./(exp((h*c)./((la(k).*1E-9).*kb*t))-1)); S1=3*(exp(-(E1./(kb2.*t)))); S2=3*(exp(-(E2./(kb2.*t)))); S3=3*(exp(-(E3./(kb2.*t)))); S5=3*(exp(-(E5./(kb2.*t)))); S4=(exp(-(E4./(kb2.*t)))); S6=(exp(-(E6./(kb2.*t)))); S7=2*(exp(-(E7./(kb2.*t)))); S8=2*(exp(-(E8./(kb2.*t)))); S9=3*(exp(-(E9./(kb2.*t)))); S10=3*(exp(-(E10./(kb2.*t)))); S11=3*(exp(-(E11./(kb2.*t)))); S123= S1+S2+S3; Si= S1+S2+S3+S4+S5+S6+S7+S8+S9+S10+S11; Ni = n0*(exp(-(E1)./(kb2.*t)))./Si; Blu = ((la(60)/1E9)^3)*(4.87E7)/(8*pi*h); Flu = (4*E0*h*c*me)/(e^2)*((la(60)/1E9)^2)*(4.87E7)/(8*pi*h); Kline = ((e^2)*Flu*1E-14*n0)/(4*E0*me*c); end L = Kline.*B{60}
A priori mes courbes sont bonnes merci.
Par contre j'ai 2 autres questions:

1) A quoi sert le B{1} = []?

2) Comment est ce que je pourrais calculer l'intégrale de ma courbe L pour chaque valeur de k, avec R comme variable dans l'intégrale? Parce que dans le programme ci dessus, je trace L pour k=60 ce qui correspond à la longueur d'onde 546nm, et en faisant trapz(R,L), je calcule l'intégrale de L sur l'intervalle [0 1000] avec un pas de 5, mais uniquement pour la longueur d'onde 546 nm... Alors que moi je voudrais l'ensemble des intégrales pour chaque k (=chaque longueur d'onde) et tracer ces points en fonction de k

03/07/2012, 14h13
tachmou

Bravo. Mais méfies-toi de l'utilisation des .* et autres ./
C'est pas forcément très clair... mais après certains diront que c'est du "beau" matlab...

1)
En fait j'avais mis B{c} = [] mais je voulais mettre

Code:

B{Ncolonnes} = [];

(au départ, j'avais utilisé la variable c, mais je n'avais pas vu que tu l'avais déjà utilisé, et j'avais oublié de corriger... bref)

Cela sert à créer ton B avec "Ncolonnes" cases... cela permet de les créer toutes une seule fois, plutôt que d'augmenter la taille à chaque fois que tu rentres dans la boucles ==> gains de temps lors de l’exécution.

D'ailleurs je remplacerais tes .* par une boucle utilisant directement des "variable(k)"... mais bon ça c'est une question de point de vue

2) Tu y arriveras tout seul ^^ pose ton problème calmement et clairement, et traduits le petit à petit en faisant des tests dans ton "test.m" etc... (cf post précédent)