Lenteur du programme puis plantage

Version imprimable

Voir 40 message(s) de cette discussion en une page

24/09/2008, 15h10
eyquem

À propos de gammeF et w
Code:

1 2 3 gammeF = range(int(valStartF),int(gamStopF),int(valFpas)) for f in gammeF: w = 2*pi*f
Tu nous a dit que gammeF compte180 valeurs.
Donc il faut 179 additions au programme pour créer gammeF.

Puis pour obtenir 180 valeurs w à partir de gammeF, il faut 360 multiplications.

Au total, pour obtenir 180 valeurs w à partir de valStartF,gamStopF,valFPas en procédant ainsi,
il faut 179 + 360 = 539 opérations.

-------------------------------

Tandis qu'en écrivant
Code:

1 2 3 4 deupi = 2*pi gammeW = range(deupi*int(valStartF),deupi*int(gamStopF),deupi*int(valFpas)) for w in gammeW: ...instructions....
obtenir 180 valeurs w ne nécessite plus que 4 + 179 = 183 opérations.

---------

Ce n'est pas ça qui va accélérer diantrement l'exécution, mais enfin, dans un esprit d'optimisation, c'est bon à remarquer.
D'autant qu'il ya maintenant deux boucles for f in gammeF: dans ton programme.

J'ai d'autres choses plus importantes à signaler , mais c'est plus long à rédiger.

Ce n'est plus le même programme

Très bien de donner le code in extenso.

Personnellement je préfère, ça permet bien mieux de comprendre, on peut éviter ou éclaircir soi-même des points obscurs.

Par exemple, comme l'a fait remarquer BebeF, ZO = sqrt(L0/C0) dans le premier code que tu as donné, le 5 septembre, n'apparait nulle part ailleurs et on pouvait se demander ce que ça faisait dans ce code.
L'explication est simple: il manquait du code. Les valeurs de ZO sortent maintenant dans une boucle supplémentaire for vdiamA,vdiamB in Z: .

Cependant ce n'est plus le même programme, puisqu'il est apparu de nouvelles parties. C'est embêtant parce que ça oblige de reconsidérer le programme dans une globalité différente.

En résumant,

le code du 5 septembre est

Code:

1
2
3
4
5
6
for f in gammeF:
    for vdiamA,vdiamB in zip(listeDimA,listeDiamB):
         obtention de matS
         valcol = ...addition de strings issus de matS
         matSFile.write(valcol)
matSFile.close()

soit 180 tours de f x 125 tours de vdiam

Maintenant,
le code du 23 septembre fait en résumé ceci:

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
for vdiamA,vdiamB in Z:
    diamA=...  diamB=...  deltaL=...  F0=...  L0=....  C0=....    
    ZO=....    
    valdiamcol=....valeurs vdiamA,vdiamB,ZO
    matSfile(valdiamcol)
matSFile("\n")
 
for f in gammeF:
    w = 2 pi f
    for varExtDiamA,varExtDiamB in zip( [-,-,-] , [-,-,-] ):
        diamA=...  diamB=...  deltaL=...  F0=...  L0=....  C0=....
        calcul de k2,ds,d0,R,L,G,C,Zc,gamma
        valExtCol = ...valeurs varExtDiamA,varExtDiamB,Zc,gamma
        matSFile.write(valExtCol)
matSFile("\n")
 
for f in gammeF:
    w = 2 pi f
    ABCD = matrix( 1,0   0,1 )
    for vdiamA,vdiamB in Z:
        diamA=...  diamB=...  deltaL=...  F0=...  L0=....  C0=....
        calcul de k2,ds,d0,R,L,G,C,Zc,gamma
        coef=....  Cos=.... Sin=....
        ABCD = ABCD * matrix( [-,-] , [-,-] )
        obtention des valeurs de matS
        valcol= valeurs matS11,matS12,marS21,matS22
        matSFile.write(valcol)
matSFile.close()

Soit:
1) une boucle a 125 tours
2) deux boucles imbriquees a 180 x 3 = 540 tours
3) deux boucles imbriquées a 180 x 125 = 22500 tours
On a intérêt à optimiser tout ça....

--------------------------------------------------

Dans le code du 23 septembre, il saute aux yeux que le programme exécute les instructions

Code:

diamA=... diamB=... deltaL=... F0=... L0=.... C0=....

- d'abord dans 1)
- puis dans 3)
pour calculer exactement les mêmes valeurs pour un couple donné.

Ce n'est pas bon, il faut se débrouiller pour faire autrement, me suis-je dit.
Mais à cette occasion je me suis aperçu de quelque chose de pire que je n'avais pas encore vu.

Pour un couple vdiamA,vdiamB donné , les instructions

Code:

diamA=... diamB=... deltaL=... F0=... L0=.... C0=....

ne sont pas effectuées une seule fois mais 180 fois, puisque un couple vdiamA,vdiamB donné revient 180 fois, une fois pour chaque fréquence f.

Ce qui fait que les instructions

Code:

diamA=... diamB=... deltaL=... F0=... L0=.... C0=....

sont effectuées en réalité 181 fois pour calculer exactement les mêmes valeurs F0,C0,L0 pour un couple vdiamA,vdiamB donné.
En effet, w, donc f , n'intervient pas dans le calcul de ces quantités.

Il faut donc absolument modifier les choses à ce niveau.
Je propose de faire de F0,L0,C0 des dictionnaires F0d,L0d,C0d qui seront définis dans la première boucle exploités plus loin quand nécessaire

Code:

1
2
3
4
5
6
7
8
9
10
11
12
nomdiamcol = 'Petit diamètre (mm)' + "\t" + 'Grand diamètre (mm)' + "\t" + 'Impédance Z0' + "\n"
matSFile.write(nomdiamcol)
for nv in range(0,len(Z)):
  vdiamA,vdiamB = Z[nv]
  F0d[nv],L0d[nv],C0d[nv] = F0L0C0(vdiamA,vdiamB)
  Z0 = sqrt(L0d[nv]/C0d[nv]) # Impédance Z0
  valdiamcol = str(value(vdiamA)) + "\t" + str(value(vdiamB)) + "\t" + str(value(Z0)) + \
               str(numpy.array2string(numpy.array(ex.uncertainty(Z0)).ravel())) + "\n"
  matSFile.write(valdiamcol)
espcol = ""
espcol = "\n"
matSFile.write(espcol)

J'ai défini la fonction F0L0C0()

Code:

1
2
3
4
5
6
def F0L0C0(a,b):
    bsura = ex.gaussian(b*1e-3, uAbsolute(0.02e-3))  /  ex.gaussian(a*1e-3, uAbsolute(0.02e-3))
    F0 = ((bsura*2-1)/(2*log(bsura)))-(bsura*log(bsura)/(bsura+1))-0.5*(bsura+1)#F1-F2-0.5*diamB/diamA
    L0 = mu*log(bsura)/2/pi # Inductance linéique sans perte
    C0 = 2*pi*E/log(bsura)
    return F0,L0,C0

Le calcul de deltaL est renvoyé plus loin et integré dans le calcul de coeff.
Et ça donne ç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
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
for f in gammeF:
  w = 2*pi*f              #pulsation
  print u'La fréquence en cours est :', f, u'Hz'
  print ""
  # ----------------------------------------------------------------------------------
  # Détermination de la matrice identité de départ pour les calculs de la matrice ABCD
  # ----------------------------------------------------------------------------------    
  ABCD = numpy.matrix([[1,0],[0,1]])
  # ------------------------------------------------------------------------------------
  # Boucle à partir des données extraites des fichiers (calculs en fonction des diamètres)
  # ------------------------------------------------------------------------------------
  for nz in range(0,len(Z)):
    vdiamA,vdiamB = Z[nz]
    #------------------------------------------------------------------------------------
    # Calcul des caractéristiques d'une ligne à air sans pertes
    #------------------------------------------------------------------------------------
    F0,L0,C0 = F0d[nz],L0d[nz],C0d[nz]
    #------------------------------------------------------------------------------------
    # Calcul des caractéristiques d'une ligne à air avec pertes
    #------------------------------------------------------------------------------------
    k2 = (w*sqrt(L0*C0))**2      #nombre d'onde angulaire au carré
    ds = sqrt(2*rho/w/mu)   #épaisseur de peau
    d0 = ds*(1+(diamB/diamA))/(4*(diamB/2)*log(diamB/diamA))
    R = 2*w*L0*d0*(1-k2*(diamA/2)**2*F0/2)     #résistance linéique
    L = L0*(1+2*d0*(1-k2*(diamA/2)**2*F0/2))   #inductance linéique
    G = w*C0*d0*k2*(diamA/2)**2*F0             #conductance linéique
    C = C0*(1+d0*k2*(diamA/2)**2*F0)           #capacité linéique
    Zc = sqrt((R+((L*w)*1j))/(G+((C*w)*1j)))    #impédance caractéristique
    gamma = sqrt((R+((L*w)*1j))*(G+((C*w)*1j))) #constante de propagation
    #------------------------------------------------------------------------------------
    # Détermination de la Matrice ABCD de la ligne
    #------------------------------------------------------------------------------------
    coef = gamma*ex.gaussian(cdeltaL, uAbsolute(0.5e-3))
    Cos = cosh(coef)
    Sin = sinh(coef)
    ABCD = ABCD * numpy.matrix([[Cos,Sin*Zc],[Sin/Zc,Cos]]) #Création de la matrice ABCD d'un élément de la ligne ([A,B],[C,D])
  #-----------------------------------------------------------------------------------------
  # Calcul du coefficient de la matrice S de la ligne à partir de la matrice ABCD de la ligne
  #-----------------------------------------------------------------------------------------
  Scoef = 1/((ABCD[0,1]+ABCD[1,0]*Zref*Zref)+(ABCD[0,0]*Zref+ABCD[1,1]*Zref))
  #-----------------------------------------------------------------------------------------
  # Calcul des valeurs de la matrice S
  #-----------------------------------------------------------------------------------------
  matS11 =Scoef*(ABCD[0,1]-ABCD[1,0]*Zref*Zref+ABCD[0,0]*Zref-ABCD[1,1]*Zref)
  matS12 =Scoef*(2*Zref*(ABCD[0,0]*ABCD[1,1]-ABCD[0,1]*ABCD[1,0]))
  matS21 =Scoef*(2*Zref)
  matS22 =Scoef*(ABCD[0,1]-ABCD[1,0]*Zref*Zref-ABCD[0,0]*Zref+ABCD[1,1]*Zref)
  #-----------------------------------------------------------------------------------------
  # Formatage de l'écriture en sortie des valeurs d'incertitudes
  #-----------------------------------------------------------------------------------------
  tabIncmatS11 = numpy.array2string(numpy.array(ex.uncertainty(matS11)).ravel())
  tabIncmatS12 = numpy.array2string(numpy.array(ex.uncertainty(matS12)).ravel())
  tabIncmatS21 = numpy.array2string(numpy.array(ex.uncertainty(matS21)).ravel())
  tabIncmatS22 = numpy.array2string(numpy.array(ex.uncertainty(matS22)).ravel())
  #-----------------------------------------------------------------------------------------
  # Ecriture du fichier
  #-----------------------------------------------------------------------------------------
  valcol = str(value(f)) + "\t" + \
           str(value(matS11)) + str(tabIncmatS11) + "\t" + \
           str(value(matS12))  + str(tabIncmatS12) + "\t" + \
           str(value(matS21))  + str(tabIncmatS21) + "\t" + \
           str(value(matS22))  + str(tabIncmatS22) + "\n"
  matSFile.write(valcol)
 
matSFile.close()

Ouf........

dring dring

Pas évident d'arriver à ce qui suit.
D'une part parce qu'il n'est pas évident d'arriver à simplier les formules pour aboutir à celles qui suivent. Et d'autre part parce que le problème était bien embrouillé au départ.
J'expliquerai plus tard, il le faut car il faudra vérifier les formules auxquelles je suis arrivé. Il ne s'agirait pas qu'il y ait des erreurs de calculs introduites à cause d'erreurs de transformations de formules.

Je crois qu'avec ce qui suit, le temps de calcul devrait encore diminuer.
Pas la peine de définir une fonction F0L0C0() finalement, au contraire je crois que ça ralentirait.

Penser à définir les dictionnaires utilisés :
diamA diamB F0d L0d C0d trio ct

Pour la ligne
G = C0[nz]*2*ct[nz]*G
il faut voir ça de façon dynamique. On utilise d'abord la valeur de G à la ligne précédente pour calculer R avant d'achever le calcul de G.

Première boucle 1)

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
nomdiamcol = 'Petit diamètre (mm)' + "\t" + 'Grand diamètre (mm)' + "\t" + 'Impédance Z0' + "\n"
matSFile.write(nomdiamcol)
for nv in range(0,len(Z)):
  vdiamA,vdiamB = Z[nv]
  diamA[nv] = ex.gaussian(a*1e-3, uAbsolute(0.02e-3))
  diamB[nv] = ex.gaussian(b*1e-3, uAbsolute(0.02e-3))
  bsura = ex.gaussian(b*1e-3, uAbsolute(0.02e-3))  /  ex.gaussian(a*1e-3, uAbsolute(0.02e-3))
  #------------------------------------------------------------------------------------------------------
  # Calcul des caractéristiques d'une ligne à air sans pertes
  F0d[nv] = ((bsura*2-1)/(2*log(bsura)))-(bsura*log(bsura)/(bsura+1))-0.5*(bsura+1)#F1-F2-0.5*diamB/diamA
  L0d[nv] = mu*log(bsura)/2/pi # Inductance linéique sans perte
  C0d[nv] = 2*pi*E/log(bsura)
  #-------------------------------------------
  # Constantes necessaires pour plus tard
  trio[nz] = F0*L0*C0/8
  ct[nz] = sqrt(rho/2/mu)*(1+bsura)/log(bsura)
  #----------------------------------------
  # Calcul de l'impédance Z0
  Z0 = sqrt(L0d[nv]/C0d[nv]) # Impédance Z0
  #----------------------------------------------------------------------------------------------
  # Sortie
  valdiamcol = str(value(vdiamA[nv])) + "\t" + str(value(vdiamB[nv])) + "\t" + str(value(Z0)) + \
               str(numpy.array2string(numpy.array(ex.uncertainty(Z0)).ravel())) + "\n"
  matSFile.write(valdiamcol)
espcol = ""
espcol = "\n"
matSFile.write(espcol)

Troisième ensemble de boucle 3)

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
for f in gammeF:
  w = 2*pi*f              #pulsation
  print u'La fréquence en cours est :', f, u'Hz'
  print ""
  # ----------------------------------------------------------------------------------
  # Détermination de la matrice identité de départ pour les calculs de la matrice ABCD
  # ----------------------------------------------------------------------------------    
  ABCD = numpy.matrix([[1,0],[0,1]])
  # ------------------------------------------------------------------------------------
  # Boucle à partir des données extraites des fichiers (calculs en fonction des diamètres)
  # ------------------------------------------------------------------------------------
  for nz in range(0,len(Z)):
    #------------------------------------------------------------------------------------
    # Calcul des caractéristiques d'une ligne à air avec pertes
    #------------------------------------------------------------------------------------
    G = sqrt(w)*(w*diamA[nz])**2*trio[nz]/diamB[nz}
    R = L0[nz]*2*ct[nz]*((sqrt(w)/diamB[nz])-G)#résistance linéique
    G = C0[nz]*2*ct[nz]*G#conductance linéique
    L = L0[nz] + R/w#inductance linéique
    C = C0[nz] + G/w#capacité linéique
    Zc = sqrt((R+((L*w)*1j))/(G+((C*w)*1j)))    #impédance caractéristique
    gamma = sqrt((R+((L*w)*1j))*(G+((C*w)*1j))) #constante de propagation
    #------------------------------------------------------------------------------------
    # Détermination de la Matrice ABCD de la ligne
    #------------------------------------------------------------------------------------
    coef = gamma*ex.gaussian(cdeltaL, uAbsolute(0.5e-3))
    Cos = cosh(coef)
    Sin = sinh(coef)
    ABCD = ABCD * numpy.matrix([[Cos,Sin*Zc],[Sin/Zc,Cos]]) #Création de la matrice ABCD d'un élément de la ligne ([A,B],[C,D])
  #-----------------------------------------------------------------------------------------
  # Calcul du coefficient de la matrice S de la ligne à partir de la matrice ABCD de la ligne
  #-----------------------------------------------------------------------------------------
  Scoef = 1/((ABCD[0,1]+ABCD[1,0]*Zref*Zref)+(ABCD[0,0]*Zref+ABCD[1,1]*Zref))

29/09/2008, 14h36
bourgui78

merci encore de ton aide

bonjour,

après ce beau WE ensolleilé, je m'attaque à ce que tu me proposes, par contre la fonction dictionnaire est nouvelle pour moi, donc je me repenche sur "apprendre à programmer avec Python" et j'y vais...

merci encore pour le temps que tu passes sur mon programme...

Pat
29/09/2008, 16h31
moumine

Salut,

Si tu veux que ton programme soit plus rapide il y a un moyen asser partique.
Tu convertis ton programme (version final et fonctionnel) en un fichier executable (à l'aide de "py2exe") ce qui va nettement augmenter la vitesse d'execution.

A+ :king:

Précisions et corrections.

Hello,

1) Dictionnaires: vraiment rien de compliqué... je crois...
Ce lien
http://diveintopython.adrahon.org/na...dbchelper.dict
devrait te permettre une prise de contact grandement suffisante pour comprendre ce que j'ai proposé.

2) Attention, dans la première boucle 1, les deux lignes
trio[nz] = F0*L0*C0/8
ct[nz] = sqrt(rho/2/mu)*(1+bsura)/log(bsura)
sont mal écrites.

Il faut écrire

trio[nv] = F0[nv]*L0[nv]*C0[nv]/8
ct[nv] = sqrt(rho/2/mu)*(1+bsura)/log(bsura)

3) Les propositions de N.tox (module psyco) et moumine (fichier executable) sont tout à fait valables. Pour la première, j'y avais pensé, bien que ne maitrisant pas le module psyco mais j'ai pensé qu'avant d'exploiter des ressources techniques de Python, il convient d'écrire un programme dont l'algorithme est optimisé et qu'il serait bien temps de voir ça après ladite optimisation. C'est aussi valable pour la transformation en fichier exécutable. Si des possibilités techniques devaient permettre de ne pas se préoccuper d'algorithmique et d'écriture, je pense que ce serait de la programmation de bas niveau. (je ne dis pas que c'est ce que font N.tox et moumine; d'ailleurs moumine écrit bien "version finale et fonctionnelle")

4) Pour les forumules, j'ai eu du mal à retrouver les transformations que j'avais moi-même faites ! Les voici. Sauf mauvaise compréhension de la succession des opérations, j'ai retrouvé la même chose et je ne m'étais pas trompé.
Il faut encore vérifier.
Surtout la transformation de d0 et celles concernant G et R.

diamA = ex.gaussian(vdiamA*1e-3, uAbsolute(0.02e-3))
diamB = ex.gaussian(vdiamB*1e-3, uAbsolute(0.02e-3))
deltaL = ex.gaussian(cdeltaL, uAbsolute(0.5e-3))
ces 3 variables ne dependent pas de w
Je ne me trompe pas, au moins ? Parce que sinon tout est fichu par terre

F0 = (((diamB/diamA)**2-1)/(2*log(diamB/diamA)))-((diamB/diamA)*log(diamB/diamA)/((diamB/diamA)+1))-0.5*((diamB/diamA)+1)
L0 = mu*log(diamB/diamA)/2/pi
C0 = 2*pi*E/log(diamB/diamA)
mu, pi et E etant des constantes et diamA et diamB ne dependant pas de w,
il resulte que FO,LO,CO ne dependent pas de w
et leur calcul peut etre sorti de la boucle for f in gammeF
Comme FO,LO,CO sont deja calculees dans la Prmeiere boucle, il faut pouvoir les tirer de la
et donc les mettre en dictionnaire.

k2 = (w*sqrt(L0*C0))**2 = (w)**2 * L0*C0

ds = sqrt(2*rho/w/mu) = sqrt(2*rho/mu) / sqrt(w)
Code:

1 2 3 4 5 6 d0 = ds*(1+(diamB/diamA))/(4*(diamB/2)*log(diamB/diamA)) = ds * (1 + r) / ( 2 * diamB * log(r) ) = sqrt(2*rho/mu) * (1 + r) ) / ( sqrt(w) * 2 * diamB * log(r) ) = sqrt( rho/2*mu) * (1 + r) / ( sqrt(w) * diamB * log(r) ) = ( sqrt( rho/2*mu) * (1 + r) / log(r) ) / ( sqrt(w) * diamB )
La premiere partie ne depend pas de w, elle sera calculee en dehors de la boucle sur f:
ct[nv] = sqrt(rho/2/mu)*(1+r)/log(r)
La seconde partie depend de w
do = ct[nv] / ( sqrt(w) * diamB )
Code:

1 2 3 4 5 6 7 8 9 ----------------------------------------------------------- R = 2*w*L0*d0*(1-k2*(diamA/2)**2*F0/2) R/w = 2*L0*d0*(1-k2*(diamA/2)**2*F0/2) L = L0*(1+2*d0*(1-k2*(diamA/2)**2*F0/2)) = LO + LO*2*d0*(1-k2 * (diamA/2)**2 * F0/2) = LO + R/W -----------------------------------------------------------
Code:

1 2 3 4 5 6 7 8 9 ----------------------------------------------------------- G = w*C0*d0*k2 * (diamA/2)**2 * F0 G/w = C0*d0*k2 * (diamA/2)**2 * F0 C = C0*(1+d0*k2*(diamA/2)**2*F0) = CO + CO*d0*k2 * (diamA/2)**2 * F0 = CO + G/w -----------------------------------------------------------
Code:

1 2 3 4 5 6 7 8 ----------------------------------------------------------- G = w*C0*d0*k2 * (diamA/2)**2 * F0 = w*CO * ( ct / (sqrt(w) * diamB) ) * w**2 * LO*CO * (diamA)**2 * FO/4 = CO * ct * w * w**2 * (diamA)**2 * (LO*CO*FO/4) / (sqrt(w) * diamB) = CO*ct*2 * sqrt(w) * w**2 * (diamA)**2 * (LO*CO*FO/8) / diamB = CO*ct*2 * sqrt(w) * (w*diamA)**2 * trio / diamB = CO*ct*2 * G1 -----------------------------------------------------------
La premiere partie CO*ct*2 ne depend pas de w
La seconde partie depend de w et se retrouve dans R
Code:

1 2 3 4 5 6 7 8 9 10 ----------------------------------------------------------- R = 2*w*L0*d0*(1-k2*(diamA/2)**2*F0/2) = 2*w*LO * ( ct / (sqrt(w) * diamB) ) * (1-k2*(diamA/2)**2*F0/2) = 2*LO*ct * ( sqrt(w)/diamB ) * (1 - k2*(diamA/2)**2*F0/2) = 2*LO*ct * ( sqrt(w)/diamB ) * (1 - (w)**2 * (diamA)**2 * FO*LO*CO/8 ) = 2*LO*ct * ( sqrt(w)/diamB ) * (1 - (w*diamA)**2 * FO*LO*CO/8 ) = 2*LO*ct * ( sqrt(w)/diamB ) * (1 - (w*diamA)**2 * trio ) = 2*LO*ct * ( sqrt(w)/diamB - sqrt(w)*(w*diamA)**2 * trio/diamB ) = 2*LO*ct * ( sqrt(w)/diamB - G1 ) -----------------------------------------------------------
5) Remplacer
Code:

1 2 nomdiamcol = 'Petit diamètre (mm)' + "\t" + 'Grand diamètre (mm)' + "\t" + 'Impédance Z0' + "\n" matSFile.write(nomdiamcol)
par

Code:

matSFile.write('Petit diamètre (mm)\tGrand diamètre (mm)\tImpédance Z0\n')
Code:

1 2 3 valdiamcol = str(value(vdiamA)) + "\t" + str(value(vdiamB)) + "\t" + str(value(Z0)) + \ str(numpy.array2string(numpy.array(ex.uncertainty(Z0)).ravel())) + "\n" matSFile.write(valdiamcol)
par
Code:

1 2 matSFile.write(str(value(vdiamA)) + "\t" + str(value(vdiamB)) + "\t" + str(value(Z0)) + \ str(numpy.array2string(numpy.array(ex.uncertainty(Z0)).ravel())) + "\n")
6) De plus, il est inutile de déclarer une variable avant qu'une valeur lui soit attribuée:
Code:

1 2 3 nomExtcol = "" nomExtFreqcol = "" valExtcol = ""
pour leur affecter des valeurs plus loin sont des instructions inutiles.

- Le pompon de 5 et 6 réunis, c'est
Code:

1 2 3 espcol = "" espcol = "\n" matSFile.write(espcol)
alors qu'il est si simple d'écrire

Code:

matSFile.write('\n')

7) Si Zref == 50
est-ce que ce ne serait pas mieux de remplacer
Code:

1 2 3 4 matS11 =Scoef*(ABCD[0,1]-ABCD[1,0]*Zref*Zref+ABCD[0,0]*Zref-ABCD[1,1]*Zref) matS12 =Scoef*(2*Zref*(ABCD[0,0]*ABCD[1,1]-ABCD[0,1]*ABCD[1,0])) matS21 =Scoef*(2*Zref) matS22 =Scoef*(ABCD[0,1]-ABCD[1,0]*Zref*Zref-ABCD[0,0]*Zref+ABCD[1,1]*Zref)
par
Code:

1 2 3 4 matS11 =Scoef*(ABCD[0,1] - ABCD[1,0]*2500 + ABCD[0,0]*50 -ABCD[1,1]*50) matS12 =Scoef*100*(ABCD[0,0]*ABCD[1,1] - ABCD[0,1]*ABCD[1,0]) matS21 =Scoef*100 matS22 =Scoef*(ABCD[0,1] - ABCD[1,0]*2500 - ABCD[0,0]*50 + ABCD[1,1]*50 )
?

je suis vraiment désolée

p'tain la merde ça vient de planter... chais pas sur quoi j'ai appuyé.

Bon je me répète au cas où

cette fois-ci j'ai du mal à te suivre... pas évident du tout :roll:

pour le lien, merci je l'avais repéré, mais ça me conforte dans ma lecture

Pour les erreurs que tu a vu, je les avez corrigé par moi-même :yaisse2: je commence à m'améliorer tout de même :mouarf:

Enfin pour le point exe ou psycho, en effet je préfère également partir dans ce registre sur des bases saines, donc j'ai encore du boulot devant moi

Pour le stockage de la valeur de Z0, j'ai cette erreur là qui apparait
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 C:\Python25\Programme>Progglobal_Parametre_S_d_une_ligne.py QUELLE EST LA LONGUEUR DE LA LIGNE A CARACTERISER EN CM ?0.5 QUELLE EST LA DISTANCE ENTRE CHAQUE MESURE DE DIAMETRE EN MM ?1 Entrer les valeurs des fréquences, svp. FREQUENCE DE DEPART : ( cliquer sur <ENTER> pour valider ) 100m FREQUENCE DE FIN : ( cliquer sur <ENTER> pour valider ) 200m INTERVALLE ENTRE CHAQUE FREQUENCE : ( cliquer sur <ENTER> pour valider ) 100m Valeur de la fréquence de départ : 100000000.0 Hz. Valeur de la fréquence de fin : 200000000.0 Hz. Valeur du pas de la mesure : 100000000.0 Hz. Il y aura 2 Traceback (most recent call last): File "C:\Python25\Programme\Progglobal_Parametre_S_d_une_ligne.py", line 202, in <module> str(ex.uncertainty(Z0[nv]).ravel()) + "\n" TypeError: 'float' object is unsubscriptable C:\Python25\Programme>pause Appuyez sur une touche pour continuer...
Voilà, merci encore

@+

Patricia

30/09/2008, 19h57
eyquem
Dans message #43
dans ce que j'ai appelé Première boucle 1)
mon code était vraiment mal écrit !
En plus des corrections déjà vues à faire, il faut aussi définir ZO comme un dictionnaire:

Code:

Z0[nv] = sqrt(L0d[nv]/C0d[nv])

Je m'étais mis dans la tête que ZO ne dépendait pas de vdiamA,vdiamB c'est à dire de nv. Mais c'est faux.

Il faut aussi corriger dans la définition de
Code:

1 2 valdiamcol = str(value(vdiamA[nv])) + "\t" + str(value(vdiamB[nv])) + "\t" + str(value(Z0[nv])) + \ str(numpy.array2string(numpy.array(ex.uncertainty(Z0[nv])).ravel())) + "\n"
Je vois ex.uncertainty(Z0[nv]).ravel() dans le compte rendu d'erreur.
Je pense que tu as fait la 2ième correction dans valdiamcol mais pas dans la définition de ZO un peu plus haut et pas dans la premire apparition de ZO dans value(Z0) si bien que l'erreur ne se produit que sur ex.uncertainty(Z0[nv])
Code:

1 2 zo = 45.67 print zo[3]
donne la même erreur.

-----------------------------------------------

Les calculs dans mon précédent message ne sont que des transformations mathématiques pour arriver à des expressions simplifiées qui réclament moins d'opérations à exécuter par le programme.
01/10/2008, 11h51
bourgui78

Salut

Je pense qu'il y a un souci, car en fait il ne veut pas écrire dans mon fichier des données de type dictionnaire, même si je ne mets que les diamètres à écrire !
je regarde et je te dis comment je peux fairepour contourer le pb

@+

PAtricia

Merci encore pour ton aide

je mérite des baffes

bon j'ai trouvé l'erreur pour l'écriture dans mon fichier... et devine y avait un pb de variables :aie:
donc voici maintenant ce que donne ma boucle 1)

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
matSFile.write('Petit diamètre (mm)\tGrand diamètre (mm)\tImpédance Z0\n')
F0d = {}
L0d = {}
C0d = {}
diamA = {}
diamB = {}
trio = {}
ct = {}
Z0 = {}
for nv in range(0,len(Z)):
  vdiamA,vdiamB = Z[nv]
  diamA[nv] = ex.gaussian(float(a)*1e-3, uAbsolute(0.02e-3))
  diamB[nv] = ex.gaussian(float(b)*1e-3, uAbsolute(0.02e-3))
  bsura = ex.gaussian(float(b)*1e-3, uAbsolute(0.02e-3))  /  ex.gaussian(float(a)*1e-3, uAbsolute(0.02e-3))
  #------------------------------------------------------------------------------------------------------
  # Calcul des caractéristiques d'une ligne à air sans pertes
  F0d[nv] = ((bsura*2-1)/(2*log(bsura)))-(bsura*log(bsura)/(bsura+1))-0.5*(bsura+1)#F1-F2-0.5*diamB/diamA
  L0d[nv] = mu*log(bsura)/2/pi # Inductance linéique sans perte
  C0d[nv] = 2*pi*E/log(bsura)
  #-------------------------------------------
  # Constantes necessaires pour plus tard
  trio[nv] = F0d[nv]*L0d[nv]*C0d[nv]/8
  ct[nv] = sqrt(rho/2/mu)*(1+bsura)/log(bsura)
  #----------------------------------------
  # Calcul de l'impédance Z0
  Z0[nv] = sqrt(L0d[nv]/C0d[nv]) # Impédance Z0
  #----------------------------------------------------------------------------------------------
  # Sortie
  valdiamcol = str(value(diamA[nv])) + "\t" + str(value(diamB[nv])) + "\t" + str(value(Z0[nv])) + "\t" + \
               str(numpy.array2string(numpy.array(ex.uncertainty(Z0[nv]).ravel()))) + "\n"
  matSFile.write(valdiamcol)
matSFile.write("\n")

le pb c'est qu'il fait des calculs pour seulement ma dernière valeur de diamètres soit 3.53 et 1.53 et cela 5 fois... (mon fichier a 5 valeurs)

je reviens de suite

@+

Pat

heps

Ah c'est bien si tu as trouvé pour l'écriture. Je ne voyais pas où était le problème.

----------

Par ailleurs, je n'ai pas osé te signaler une erreur dans le code parce que je pensais que tu l'aurais vue comme tu en avais vue une autre précédemment.
Mais je la vois toujours dans le code:

il y a a et b dans le code mais on ne sait pas d'où ils sortent.
Ça provient de mon message #43 alors que c'était bon dans ton message #39. Je me fonde sur ce dernier pour corriger.
Je suis étonné que le programme tourne avec cette erreur, il doit faire n'importe quoi, c'est peut être à l'origine des bizarreries que tu constates.

De plus, on peut améliorer:

- ta notation r = b/a (dans tom message #27) qui vaut vdiamB/vdiamA est préférable à ma notation bsura. Je la reprend.

- on fait travailler ex.gaussian() DEUX fois de trop

Ce qui donne:
Code:

1 2 3 4 5 for nv in range(0,len(Z)): vdiamA,vdiamB = Z[nv] diamA[nv] = ex.gaussian(float(vdiamA)*1e-3, uAbsolute(0.02e-3)) r = ex.gaussian(float(vdiamB)*1e-3, uAbsolute(0.02e-3)) r = r / diamA[nv]

01/10/2008, 17h09
eyquem

mounine tss tss tss

Ne décourage pas Patricia.
Je commence à bien connaître son code et je crois pouvoir dire qu'elle est proche du but.
C'est un peu touffu, elle a mal expliqué les choses au départ, je n'ai pas pris le temps de regarder suffisamment en profondeur avant de faire des propositions, il y a un module gum qu'elle ne peut pas diffuser donc on ne peut pas faire tourner son code, et il y avait des écritures redondantes qui perturbaient la compréhension (ouf...) mais à part ça, je trouve l'algorithme assez simple. Ce n'est pas parce qu'il y a 4 boucles, dont 2 imbriquées, des fonctions sur complexes, des calculs avec matrices et le recours à des dictionnaires que c'est mal conçu.
Y a pas de problème d'algorithme et y a pas de problème avec les possibilités de Python. Donc y a pas de problème insurmontable. Faut juste prendre le temps de bien rentrer là dedans.
À coté des problèmes posés par les regex ou les sockets, son code c'est du petit lait. D'ailleurs si ce n'était pas fastoche, je ne pourrais rien faire, vu mon niveau en Python.
AMA
Salut.

Eyquem

Merci pour ta sympathie, et je suis d'accord avec toi, au vu de mon niveau en informatique, ce ne peut être que compréhensible ... Pour info, avant cela, je n'ai fait de la programmation que sur LabView... donc en rien du code

Merci encore pour tes conseils, et oui effectivement le a et b plantaient la chose, donc partie résolue :D

Maintenant ma première boucle tourne parfaitement, et je retrouve les résultats d'origine (par mon premier programme, biensûr je garde toutes le versions fonctionnelles pour comparer).

là je commence la boucle 3, voilà le code (enfin la partie jusqu'à ce que ça merdouille)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
  # ------------------------------------------------------------------------------------
  for nz in range(0,len(Z)):
    vdiamA,vdiamB = Z[nz]
    #------------------------------------------------------------------------------------
    # Calcul des caractéristiques d'une ligne à air sans pertes
    #------------------------------------------------------------------------------------
    F0,L0,C0 = F0d[nz],L0d[nz],C0d[nz]
    #------------------------------------------------------------------------------------
    # Calcul des caractéristiques d'une ligne à air avec pertes
    #------------------------------------------------------------------------------------
    k2 = w**2*L0*C0      #nombre d'onde angulaire au carré
    ds = sqrt(2*rho/w/mu)   #épaisseur de peau
    d0 = ct[nz]/(sqrt(w)*diamB[nz])

et j'ai un souci, j'ai cette erreur qui apparait

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
La fréquence en cours est : 100000000 Hz
 
Traceback (most recent call last):
  File "C:\Python25\Programme\Progglobal_Parametre_S_d_une_ligne.py", line 280,
in <module>
    d0 = ct[nz]/(sqrt(w)*diamB[nz])
  File "C:\Python25\lib\site-packages\mst\GUM\_fixed_nodes.py", line 103, in __i
nit__
    self._fill( self._T )
  File "C:\Python25\lib\site-packages\mst\GUM\_fixed_nodes.py", line 33, in _fil
l
    self._context = node.getContext()
  File "C:\Python25\lib\site-packages\mst\GUM\_bases.py", line 84, in getContext
 
    return self.arg.getContext()
AttributeError: 'float' object has no attribute 'getContext'
Exception exceptions.AttributeError: "'float' object has no attribute 'detach'"
in <bound method _UniBuffer.__del__ of <mst.GUM._fixed_nodes._UniBuffer object a
t 0x02A61BF0>> ignored
 
C:\Python25\Programme>pause
Appuyez sur une touche pour continuer...

je ne comprends pas du tout, car si dans la logique je mets vdiamB au lieu de diamB, je n'ai pas l'incertitude associée, et comme j'ai déjà listé diamB dans la boucle 1, je n'ai pas à le rappeler, c'est ça ?

voici ma boucle 1) qui fonctionne parfaitement

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
matSFile.write('Petit diamètre (mm)\tGrand diamètre (mm)\tImpédance Z0\n')
F0d = {}
L0d = {}
C0d = {}
diamA = {}
diamB = {}
trio = {}
ct = {}
Z0 = {}
for nz in range(0,len(Z)):
  vdiamA,vdiamB = Z[nz]
  diamA[nz] = ex.gaussian(float(vdiamA)*1e-3, uAbsolute(0.02e-3))
  diamB[nz] = ex.gaussian(float(vdiamB)*1e-3, uAbsolute(0.02e-3))
  r = diamB[nz]/diamA[nz]
  #------------------------------------------------------------------------------------------------------
  # Calcul des caractéristiques d'une ligne à air sans pertes
  F0d[nz] = ((r*2-1)/(2*log(r)))-(r*log(r)/(r+1))-0.5*(r+1)#F1-F2-0.5*diamB/diamA
  L0d[nz] = mu*log(r)/2/pi # Inductance linéique sans perte
  C0d[nz] = 2*pi*E/log(r)
  #-------------------------------------------
  # Constantes necessaires pour plus tard
  trio[nz] = F0d[nz]*L0d[nz]*C0d[nz]/8
  ct[nz] = sqrt(rho/2/mu)*(1+r)/log(r) #sert par la suite au calcul de d0
  #----------------------------------------
  # Calcul de l'impédance Z0
  Z0[nz] = sqrt(L0d[nz]/C0d[nz]) # Impédance Z0
  #----------------------------------------------------------------------------------------------
  # Sortie
  valdiamcol = str(value(diamA[nz])) + "\t" + str(value(diamB[nz])) + "\t" + str(value(Z0[nz])) + "\t" + \
               str(numpy.array2string(numpy.array(ex.uncertainty(Z0[nz]).ravel()))) + "\n"
  matSFile.write(valdiamcol)
matSFile.write("\n")

je regarderai demain, mais il doit y avoir un truc avec le module du GUM

merci encore

Pat

Je ne suis pas sûr mais je crois que tu n'as pas saisi ma démarche. Alors j'explique, même si c'est de trop.

Dans mon message #4, j'ai essayé de calculer le nombre d'opérations élémentaires que le programme devait effectuer. Je ne sais pas si mes calculs sont très corrects, mais c'était pour avoir une idée.
Pourquoi ?

Parce qu'on prenait peur en voyant ça, avec plein de redondances:
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 diamA = ex.gaussian(vdiamA*1e-3, uAbsolute(0.02e-3)) diamB = ex.gaussian(vdiamB*1e-3, uAbsolute(0.02e-3)) deltaL = ex.gaussian(cdeltaL, uAbsolute(0.5e-3)) a = diamA/2 b = diamB/2 c = 299792458 mu = ex.constant(4*pi*1e-7) E0 = 1/mu/c**2 E = 1.000649*E0 rho = ex.constant(22e-9) r = b/a F1 = (r**2-1)/(2*log(r)) F2 = (r)*log(r)/(r+1) F0 = F1-F2-0.5*(r+1) L0 = mu*log(r)/2/pi C0 = 2*pi*E/log(r) Z0 = sqrt(L0/C0) w = 2*pi*f k = w*sqrt(L0*C0) d1 = 2*rho/w/mu d2 = sqrt(d1) ds = sqrt(2*rho/w/mu) d0 = ds*(1+r)/(4*b*log(r)) R = 2*w*L0*d0*(1-k**2*a**2*F0/2) L = L0*(1+2*d0*(1-k**2*a**2*F0/2)) G = w*C0*d0*k**2*a**2*F0 C = C0*(1+d0*k**2*a**2*F0) Zc = sqrt((R+((L*w)*1j))/(G+((C*w)*1j))) gamma = sqrt((R+((L*w)*1j))*(G+((C*w)*1j))) coef = gamma*deltaL A = cosh(coef) B = sinh(coef)*Zc C = sinh(coef)/Zc D = cosh(coef)
Donc mon idée depuis le début, c'est de diminuer le nombre d'opérations que le programme va devoir faire.

Première piste: ne pas refaire des calculs identiques
- calculer une seule fois les constantes avant tout le bazar
- mettre en dictionnaire des valeurs calculées dans la boucle 1 pour servir dans la boucle 3. Ces valeurs ne sont pas des constantes proprement dites puisqu'elles dépendent de vdiamA,vdiamB mais elles le sont à fréquence f donnée. C'est pour cela qu'on peut les calculer indépendamment de f en dehors de la boucle 3 et les resortir à volonté (180 fois chaque couple) dans la boucle 3.

Deuxième piste:
transformer les équations pour arriver à des expressions épurées de tout le superflu dans lesquelles le nombre de variables et d'expressions aura été diminué.

La partie 4 du message #46 donne les transformations mathématiques que j'ai réussi à trouver pour atteindre l'objectif de cette deuxième piste.
J'ai explicité ces transformations pour que tu les vérifies, pas parce que ça va servir dans le programme.
Le fait que je les ai présentées entre balises de code induit peut être une confusion. C'était simplement pour avoir une lisibilité meilleure.
Le vrai point important, c'est qu'il ne faut pas que le remplacement d'un certain nombre de variables et d'expressions par un autre ensemble de variables et d'expressions introduise des erreurs dans les calculs. C'est à toi de bien vérifier l'exactitude de ce que je propose. Sinon patatras...

Étant arrivé à un résultat que je pense satisfaisant pour cet objectif, il ne faut pas s'effrayer des formules du message #46. Ce ne sont que des maths.
L'essentiel pour cet objectif n'est pas dans le message #46, c'est dans le message #43, le code de la boucle 3. Le message#46 apporte simplement la démonstration de ce que j'ai écrit dans le #43. Je ne l'ai pas écrit tout de suite dans le #43 parce que l'essentiel était dit et que j'avais la flemme de compléter.

Ceci étant dit, ce qu'il faut retenir, c'est que mon idée pour la boucle 3 consiste à:
- ne plus avoir besoin de calculer diamA, diamB, FO,LO,CO dans la boucle 3 ; ces variables ont été calculées dans la boucle 1 et sont disponibles soit par FOd,LOd,COd soit au travers de trio.
- ne plus avoir besoin du tout de k2, ds, d0. Ces valeurs ne s'évaporent pas, la logique des calculs fait qu'elles se retrouvent pour partie dans ct et pour partie dans G1 = sqrt(w)*(w*diamA)**2 * trio/diamB
- on calcule d'abord cette valeur G1. Compte tenu des possibilités d'affectation, on ne l'appelle pas G1 mais G.
- on s'en sert pour calculer R par la formule
R = L0[nz]*2*ct[nz]*((sqrt(w)/diamB[nz])-G)
qui ne me semble pas plus compliquée que la précédente formule
R = 2*w*L0*d0*(1-k2*(diamA/2)**2*F0/2)
- on calcule la valeur finale de G = C0[nz]*2*ct[nz]*G qui n'est guère compliquée non plus.
- et enfin les valeurs de L et C par les expressions simples
L0[nz] + R/w et C = C0[nz] + G/w

L'avantage de toutes ces modifications n'est pas seulement dans le fait que le nombre d'opérations élémentaires à diminué (je pense...il faudrait voir ça de près, faire le même examen que dans le message #4) mais aussi dans le fait qu'on a pu obtenir des expressions pour G et R dans lesquelles il y a une partie ne dépendant que de w et une autre indépendante de w. Ce qui permet d'envoyer dans la boucle 1 le calcul unique des variables FO,LO,CO, diamA,diamB,ct,trio. Donc les transformations mathématiques permettent de faire d'une pierre deux coups, en réalité.

Donc donc donc...
le code de la boucle 3 se trouve dans le message #43, il n'y a rien à y changer,
il ne faut pas se formaliser de la disparition de k2, ds, d0, c'est voulu,
et il faut vite m'enlever de la vue cet horrible bout de code dans la première fenêtre Code de ton message #55 dans laquelle je vois des FO,LO,CO sans indices et des k2, ds, d0.
Si ÇA se trouve dans ton code, ce n'est pas étonnant que ça plante.
Les boucles 1 et 3 que j'ai proposées ne peuvent pas aller l'une sans l'autre, c'est une vision globale du programme qu'il faut avoir.

Voilà, il faut reprendre les choses comme ça, avec les bons morceaux de code, et ça ne devrait pas tarder à aller. On s'intéressera au module GUM après, s'il y a encore des grosses erreurs incompréhensibles comme celle que tu rapportes et à laquelle je ne comprends pour le moment rien du tout.

03/10/2008, 11h48
bourgui78

Eyquem, qq news

si j'ai bien compris ton principe, mais je me suis mal exprimé aussi, et c'est vrai que j'ai oublié de revoir le message #43
Bon voyant quen récrivant le programme hier j'avais les mêmes erreurs, je me suis adressée au créateur du module GUM, Blair Hall, et il m'a répondu ceci :
(attention je ne le traduis pas) :

Regarding your bug report, I have run your
program (proh_bh.py). There is an error in
executing the line (G = sqrt(w)*(w*diamA[nz])**2*(trio[nz]/diamB[nz]))
but the error is not actually a problem with my
software. You try to take the sqrt(w), where w is
a Python float and sqrt() is my GUM sqrt function
that expects an uncertain number. If you write
math.sqrt(w) instead of just sqrt(w) the code
will work properly (the change needs to me made in the next line too).

Note, I have written the bivariate arithmetic
operators +,-,*,\ to accept a numeric argument on
one side (left or right). However, it is not
possible to make univariate functions like sqrt()
convert numeric arguments to uncertain numbers.
This conversion must be done explicitly.

donc voilà aussi une explication du problème.
Je ne peux pas me pencher sur le programme aujourd'hui pour les modifs, par contre Blair Hall m'a écrit également cela :

Part of the solution lies in a new
version of the GUM software which I am working on
at present. The old software is very inefficent
at initialising the objects it uses during the
calculation. The new software will almost
certainly bring your calculation time down < 1h.
However, 1h still seems long to me.

c'est également une autre réponse au truc, je viens de lui demander de m'envoyer la nouvelle veriosn, et la conséquence sera de réécrire tout le programme a priori :aie:

Voilà je t'en dis plus dès lundi prochain, bon WE

Patricia

Ça s'éclaircit

1) Sur le plan de l'efficacité pressante,

il suffit de faire ce qu'il te dit:

Citation:

« If you write
math.sqrt(w) instead of just sqrt(w) the code
will work properly (the change needs to be made in the next line too). »

C'est à dire:
« You MUST write
math.sqrt(w) instead of just sqrt(w) to make the code
working properly (the change NEEDS to be made in the next line too). »

Ce qui se traduit par la boucle 3) du message #43 corrigée:
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 for f in gammeF: w = 2*pi*f #pulsation print u'La fréquence en cours est :', f, u'Hz' print "" # ---------------------------------------------------------------------------------- # Détermination de la matrice identité de départ pour les calculs de la matrice ABCD # ---------------------------------------------------------------------------------- ABCD = numpy.matrix([[1,0],[0,1]]) # ------------------------------------------------------------------------------------ # Boucle à partir des données extraites des fichiers (calculs en fonction des diamètres) # ------------------------------------------------------------------------------------ for nz in range(0,len(Z)): #------------------------------------------------------------------------------------ # Calcul des caractéristiques d'une ligne à air avec pertes #------------------------------------------------------------------------------------ G = math.sqrt(w)*(w*diamA[nz])**2*trio[nz]/diamB[nz] R = L0[nz]*2*ct[nz]*((math.sqrt(w)/diamB[nz])-G)#résistance linéique G = C0[nz]*2*ct[nz]*G#conductance linéique L = L0[nz] + R/w#inductance linéique C = C0[nz] + G/w#capacité linéique Zc = sqrt((R+((L*w)*1j))/(G+((C*w)*1j))) #impédance caractéristique gamma = sqrt((R+((L*w)*1j))*(G+((C*w)*1j))) #constante de propagation #------------------------------------------------------------------------------------ # Détermination de la Matrice ABCD de la ligne #------------------------------------------------------------------------------------ coef = gamma*ex.gaussian(cdeltaL, uAbsolute(0.5e-3)) Cos = cosh(coef) Sin = sinh(coef) ABCD = ABCD * numpy.matrix([[Cos,Sin*Zc],[Sin/Zc,Cos]]) #Création de la matrice ABCD d'un élément de la ligne ([A,B],[C,D]) #----------------------------------------------------------------------------------------- # Calcul du coefficient de la matrice S de la ligne à partir de la matrice ABCD de la ligne #----------------------------------------------------------------------------------------- Scoef = 1/((ABCD[0,1]+ABCD[1,0]*Zref*Zref)+(ABCD[0,0]*Zref+ABCD[1,1]*Zref))
Il ne faut surtout pas faire la même chose pour les autres endroits où apparait sqrt( )

2) Sur le plan de la compréhension de la programmation:

Si tu n'as rien changé concernant l'importation du module Python math, ton code comporte toujours au début

Code:

from math import pi

que j'ai vu dans tous tes extraits de code jusqu'à présent.
Ce qui signifie que tu n'importes que la constante pi et rien d'autre du module math.

Dans un autre cas de figure que le tien,
c'est à dire un programme dans lequel les calculs mathématiques doivent être assurés par des fonctions du module math,
c'est à dire en clair dans un programme qui n'importe pas ton module gum,
chaque fonction mathématique FONKTION utilisée doit être disponible,
ce qui concrètement veut dire qu'elles doit avoir été importée d'une manière ou d'une autre dans le programme:
Code:

1 2 3 4 5 6 #soit par import math #soit par from math import FONKTION #soit par from math import *.
Si une fonction est appelée sans être disponible, il y erreur:
Code:

1 2 3 from math import pi print 'pi =',pi print 'sqrt(2*pi) =','sqrt(2*pi)
va déclencher une erreur
Code:

1 2 3 File "E:/Python/Essais Python/skrt.py", line 3, in <module> print 'sqrt(2*pi) =',sqrt(2*pi) NameError: name 'sqrt' is not defined
parce que rien d'autre que la constante pi n'a été importé du module math.

Dans le cas de figure qui est le tien,
il n'y aura pas CETTE erreur, parce que ton programme dispose de fonctions mathémathiques qui appartiennent au module gum et qui ont été importées par l'instruction

Code:

from mst.GUM.complex.gum import *

Quand le programme rencontre sqrt(w), il demande donc a gum de lui fournir la fonction sqrt, qui existe dans gum, pour effectuer le calcul.
C'est donc gum.sqrt() qui essaye de faire le calcul sqrt(w) et non pas math.sqrt().
Cependant gum.sqrt() n'est pas apte à faire le calcul sqrt(w) qui lui est demandé.

3) Sur le plan de la compréhension du module gum.

Pourquoi gum.sqrt() cale-t-il devant sqrt(w) ?
Et pourquoi cale-t-il dans la boucle 3 et n'a-t-il pas calé pour faire
Code:

1 2 3 ct[nz] = sqrt(rho/2/mu)*(1+bsura)/log(bsura) et Z0[nv] = sqrt(L0d[nv]/C0d[nv]) ?
dans la boucle 1 ?

Parce que, comme je m'en doutais (mais j'ai eu la flemme de creuser et te demander des précisions ), les fonctions du module gum manipulent des variables qui ont un type particulier que Blair Hall appelle "uncertain number". Je ne sais pas trop ce que sont ces machins là (sont ils une forme particuière de nombres complexes?...). Si je peux m'éviter de m'y plonger, ce sera bien. Je crois qu'il suffit d'avoir compris que les fonctions de gum n'acceptent que des «uncertain numbers» et pas des simples «numeric arguments» pour pouvoir se débrouiller.

En fait il précise

Citation:

« Note, I have written the bivariate arithmetic
operators +,-,*,\ to accept a numeric argument on
one side (left or right). »

« Notez que j'ai conçu les opérateurs arithmétiques à deux arguments +,-,*,\ de telle façon qu'ils acceptent la présence d'un argument numérique (càd non uncertain number) d'un coté ou de l'autre du signe de l'opérateur. »

C'est pourquoi dans la boucle 1, le programme ne bronche pas, il fait sans fléchir:

Code:

ct[nz] = sqrt(rho/2/mu)*(1+bsura)/log(bsura)

parce qu'en amont
Code:

1 2 3 mu = ex.constant(4*pi*1e-7) rho = ex.constant(22e-9) bsura = ex.gaussian(b*1e-3, uAbsolute(0.02e-3)) / ex.gaussian(a*1e-3, uAbsolute(0.02e-3))
donc rho/2/mu est un "uncertain number" que gum.sqrt() peux prendre en argument,
(1+bsura)/log(bsura) est aussi un "uncertain number" et toute l'expression est effectuable par gum.

De même, par leur définition, LOd et COd sont des "uncertain argument" qui ne posent pas de problème à gum dans le calcul
Z0[nv] = sqrt(L0d[nv]/C0d[nv])

Par contre arrivé sur sqrt(w) dans la boucle 3, le programme cale parce que w = 2*pi*f dans laquelle f et pi sont des "numeric arguments" , pi venant même direct de math,
ET QUE

Citation:

« However, it is not possible to make univariate functions like sqrt()
convert numeric arguments to uncertain numbers.
This conversion must be done explicitly. »

« Il n'est cependant pas possible de faire en sorte que les fonctions à un seul argument puissent convertir les arguments numériques en uncertain numbers. La conversion doit être prévue explicitement d'abord.»

Pour obtenir une exécution de la ligne

Code:

G = sqrt(w)*(w*diamA[nz])**2*trio[nz]/diamB[nz]

ainsi que de la suivante, il suffit d'appeler math.sqrt().
Mais pour cela il faut l'importer au départ:

Code:

from math import sqrt, pi

Blai Hall considère cela comme une déficience de son soft qui devrait être corrigée dans une nouvelle version. Quand je disais dans le message #23
«Pour moi, c'est le module GUM qui n'est pas utilisé correctement dans le cadre de ton programme.», et que je demandais dans le message #14 ce que produisaient ex.constant() , ex.gaussian() et ex.uncertainty() , j'avais bien anticipé.

La nouvelle version de gum ne demandera absolument pas de réécrire tout le programme. L'instruction

Code:

from mst.GUM.complex.gum import *

importera la nouvelle version, avec ses capacités étendues, et c'est tout.

---------

Bon, avec tout ça, me voilà rassuré car tout est parfaitement clair et ne remet pas en cause les parties de code que je t'ai proposées, qui restent parfaitement simples pour moi.
Ça va marcher, ça va marcher.

Tu as la solution de faire tourner ton programme en déclarant import math et avec math.sqrt(), ou tu attends d'avoir la nouvelle version de gum.

Message précédent incomplet

Dans mon précédent message, j'ai écrit:

Citation:

Pourquoi gum.sqrt() cale-t-il devant sqrt(w)
dans le calcul de
G = sqrt(w)*(w*diamA[nz])**2*trio[nz]/diamB[nz]
R = L0[nz]*2*ct[nz]*((sqrt(w)/diamB[nz])-G)?

Et pourquoi cale-t-il dans la boucle 3 sur ces deux calculs et n'a-t-il pas calé pour faire
ct[nz] = sqrt(rho/2/mu)*(1+bsura)/log(bsura)
Z0[nv] = sqrt(L0d[nv]/C0d[nv]) ?
dans la boucle 1?

Et je réponds en substance:

Citation:

Parce que les fonctions du module gum manipulent des variables de type "uncertain number"
(ce qui est la bonne réponse)
et que «les opérateurs à deux arguments +,-,*,\ acceptent la présence d'un argument numérique d'un coté ou de l'autre du signe de l'opérateur. »
(ce qui n'est pas pertinent dans le cadre de cette question ).

En fait, la seule raison pour laquelle sqrt(w) ne peut pas être effectuée par la fonction sqrt() de gum (la seule à être appelée parce que la fonction sqrt() du module math n'a pas été rendue disponible), c'est que son argument w n'est pas "uncertain number".

ENSUITE, mais ensuite seulement,
le fait qu'un opérateur (il faut comprendre un opérateur de gum) à deux arguments accepte qu'un des deux arguments soit non "uncertain number"
explique que le calcul de
G = sqrt(w)*(w*diamA[nz])**2*trio[nz]/diamB[nz]
et R = L0[nz]*2*ct[nz]*((sqrt(w)/diamB[nz])-G)?
puisse CONTINUER.

De même, ce fait explique que les calculs
Code:

1 2 3 4 L = L0[nz] + R/w C = C0[nz] + G/w Zc = sqrt((R+((L*w)*1j))/(G+((C*w)*1j))) gamma = sqrt((R+((L*w)*1j))*(G+((C*w)*1j)))
dans lesquels il y a *w et \w,
puissent être effectués.

C'est en prolongeant cette idée à propos des deux derniers calculs que j'ai écrit sans explication:

Citation:

Il ne faut surtout pas faire la même chose pour les autres endroits où apparait sqrt( )

car il est important que ce soit la fonction sqrt() de gum, et non pas de math, qui soit appelée pour les calculs de Zc et gamma.

Cependant, j'ai réalisé depuis que si tu introduis une instruction

Code:

from math import sqrt, pi

il va y avoir ambigüité pour le programme sur la fonction qu'il doit appeler quand il rencontrera sqrt(....) sans rien devant.
Pour éviter cette ambigüité, il faut écrire
Code:

1 2 3 4 ct[nz] = mst.GUM.complex.gum.sqrt(rho/2/mu)*(1+r)/log(r) Z0[nz] = mst.GUM.complex.gum.sqrt(L0d[nz]/C0d[nz]) Zc = mst.GUM.complex.gum.sqrt((R+((L*w)*1j))/(G+((C*w)*1j))) gamma = mst.GUM.complex.gum.sqrt((R+((L*w)*1j))*(G+((C*w)*1j)))
Mais comme c'est un peu lourd, je te conseille de définir un alias pour le sqrt de gum:
Code:

1 2 3 4 5 6 sq = mst.GUM.complex.gum.sqrt # d'où ct[nz] = sq(rho/2/mu)*(1+r)/log(r) Z0[nz] = sq(L0d[nz]/C0d[nz]) Zc = sq((R+((L*w)*1j))/(G+((C*w)*1j))) gamma = sq((R+((L*w)*1j))*(G+((C*w)*1j)))

06/10/2008, 14h22
eyquem

Je vais finir par y arriver
Message #56, j'ai écrit

Citation:

Pour obtenir une exécution de la ligne
G = sqrt(w)*(w*diamA[nz])**2*trio[nz]/diamB[nz]
ainsi que de la suivante, il suffit d'appeler math.sqrt().
Mais pour cela il faut l'importer au départ:

Code :
from math import sqrt, pi

FAUX !

Si on met

Code:

from math import sqrt, pi

on appelle la fonction sqrt() du module math par
sqrt(w) et c'est tout.
math.sqrt(w) ne marche que si on a importé par
import math

-----------

Mais par ailleurs, si tu définis les importations au début du programme par
Code:

1 2 from math import pi,sqrt from mst.GUM.complex.gum import *
on ne peut pas définir l'alias sq par

Code:

sq = mst.GUM.complex.gum.sqrt

car, pour la même raison que ci-dessus, on ne peut pas appeler
mst.GUM.complex.gum.sqrt de façon fiable. J'ai fait des essais, ce qu'on obtient comme alias dépend de l'ordre dans lequel on met les déclarations d'importations, je passe les détails mais c'est un bazar qui ne me plait pas.
Donc il faut se débrouiller autrement.

-------------

Comme il me semble en outre que définir l'importation des fonctions gum par

Code:

from mst.GUM.complex.gum import *

est le mieux dans ce cas (en dépit de ce que préconise pacificator)
je pense que la solution est de faire:

1-
Code:

1 2 3 from mst.GUM.complex.gum import * from math import pi from math import sqrt as racine
2- enlever math.sqrt(w) et mettre racine(w) aux deux seuls endroits dont il avait été question en rouge dans le message #56 où il faut appeler sqrt() de math
3- ne pas définir d'alias sq comme je l'avais trop précipitamment proposé
4- mais au contraire laisser sqrt(....) partout ailleurs où il s'agit de la fonction sqrt() du module gum

Avec ceci, ça devrait enfin marcher. Excuse moi pour tous ces errements.
Je me trompe encore peut être à un ou deux endroits, mais comme tu auras compris, tu corrigeras toi même si besoin est.

---------------

Je me permets de te faire remarquer que ces questions ont déjà été abordées dans la file suivante

http://www.developpez.net/forums/d59...ules-importes/

et que si les choses ne sont toujours pas résolues sur ce point des déclarations, c'est que tu n'avais sans doute pas suffisamment creusé le sujet.
mchk0123 avait même écrit précisément !

Citation:

edit: oui surtout quand on importe 2 modules de maths qui peuvent contenir des fonctions de même nom (ex. math -> sqrt sur les floats et complex.gum -> sqrt sur les complexes !!!)

Je suis moi même en défaut de ne pas m'en être rappelé et surtout de ne pas avoir suffisamment bien compris... je sentais bien qu'il fallait que je regarde quelle sorte de variables traite gum, mais comme je te l'ai dit j'ai eu la flemme.

Eyquem j'ai des nouvelles

Bonjour,

le programme fonctionne bien avec la modif math qu'avait précisé B Hall, mais pendant 25h tout de même.
Je viens donc de recevoir la dernière version qu'a développer B Hall sur le module GUM... et après qq modif que B Hall a fait à mon programme pour utiliser la nouvelle version de son module GUM, le programme tourne en 12minutes :yaisse2:

je te donne le code final :

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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
#!/usr/bin/python
# -*- coding:Latin-1 *-*
 
from mst.byGUM.complex.uc_number import *
from math import pi
 
import math
 
import sys
import os
import numpy
import Tkinter
import tkFileDialog
import win32com.client
import time
 
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
# Recherche des fichiers de mesures
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
#
#------------------------------------------------------------------------------------
# Gestion de la fenêtre Tk sous Tkinter
#------------------------------------------------------------------------------------
 
class messageOk(Tkinter.Tk):
  def __init__(self,parent,message):
    Tkinter.Tk.__init__(self,parent)
    self.parent = parent
    Tkinter.Label(self,text=message).grid(column=0,row=0)
    Tkinter.Button(self,text=u"Ok",command=self.ButtonOkClick).grid(column=0,row=1)
 
  def ButtonOkClick(self):
    self.destroy()
 
#------------------------------------------------------------------------------------
# Sélection des fichiers de mesure des diamètres et sélection du répertoire
# d'enregistrement des résultats de la matrice S de la ligne
#------------------------------------------------------------------------------------
if __name__ == "__main__":
  app = messageOk(None,message="""Si vous avez choisi les fichiers correspondant aux petits
  et grands diamètres, alors cliquer sur Ok """)
  filePetitDiam = tkFileDialog.askopenfilename(filetypes = [("Fichier texte", "*.txt"),("Fichier Texte","*.txt")],
                                               title = 'Sélection du fichier des petits diamètres')
  #print filePetitDiam
  fileGrandDiam = tkFileDialog.askopenfilename(filetypes = [("Txt", "*.txt"),("Fichier Texte","*.txt")],
                                               title = 'Sélection du fichier des grands diamètres')
  #print fileGrandDiam
  directMatS = tkFileDialog.asksaveasfilename(initialdir='C:\Python25\Programme',
                                             filetypes = [("Txt", "*.txt"),("Fichier Texte","*.txt")],
                                             title = "Sélection du fichier pour l'enregistrement de la matrice S de la ligne")
  #print directMatS
  app.title('Choix des fichiers')
  app.mainloop()
 
#------------------------------------------------------------------------------------
#Gestion du fichiers des enregistrements des données de la matrice S de la ligne
#------------------------------------------------------------------------------------
matSFile = open(directMatS,'w')
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
# Programme général
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
_J_ = constant(1j)
#------------------------------------------------------------------------------------
# Gestion des fichiers des mesures des diamètres
#------------------------------------------------------------------------------------
diamAFile = open(filePetitDiam,'r')
diamBFile = open(fileGrandDiam,'r')
ListeA = [ float(a) for a in diamAFile ]
ListeB = [ float(b) for b in diamBFile ]
Z = zip( ListeA , ListeB )
diamAFile.close()
diamBFile.close()
 
#------------------------------------------------------------------------------------
# Caractéristique de la ligne
#------------------------------------------------------------------------------------
valLongueur = raw_input("QUELLE EST LA LONGUEUR DE LA LIGNE A CARACTERISER EN CM ?")
clongueur = float(valLongueur)*1e-2
print ""
valdeltaL = raw_input("QUELLE EST LA DISTANCE ENTRE CHAQUE MESURE DE DIAMETRE EN MM ?")
cdeltaL = float(valdeltaL)*1e-3
print ""
#------------------------------------------------------------------------------------
# Question de configuration de la mesure
#------------------------------------------------------------------------------------
print u"Entrer les valeurs des fréquences, svp."
print ""
startF = raw_input('FREQUENCE DE DEPART : ( cliquer sur <ENTER> pour valider ) ')
print ""
stopF = raw_input('FREQUENCE DE FIN : ( cliquer sur <ENTER> pour valider ) ')
print ""
pasF = raw_input('INTERVALLE ENTRE CHAQUE FREQUENCE : ( cliquer sur <ENTER> pour valider ) ')
print ""
#---------------------------------------------------------------
# Transformation ou non des données entrèe en float
#---------------------------------------------------------------
listechglobal = ['k','m','g']
#---------------------------------------------------------------
#       Fréquence de départ
#---------------------------------------------------------------
lcStartF = len(startF)-1
try:
    startF = float(startF)
    valStartF = startF
except ValueError:
    valStartF = float(startF[:-1])*(10**( 3*(listechglobal.index(startF[-1].lower())+1)) ) \
              if startF[-1].lower() in listechglobal else 'Erreur en entrée'
#---------------------------------------------------------------
#       Fréquence de fin
#---------------------------------------------------------------
lcStopF = len(stopF)-1
try:
    stopF = float(stopF)
    valStopF = stopF
except ValueError:
    valStopF = float(stopF[:-1])*(10**( 3*(listechglobal.index(stopF[-1].lower())+1)) ) \
              if stopF[-1].lower() in listechglobal else 'Erreur en entrée'
#---------------------------------------------------------------
#       Pas de la mesure
#---------------------------------------------------------------
lcPasF = len(pasF)-1
try:
    pasF = float(pasF)
    valFpas = pasF
except ValueError:
    valFpas = float(pasF[:-1])*(10**( 3*(listechglobal.index(pasF[-1].lower())+1)) ) \
              if pasF[-1].lower() in listechglobal else 'Erreur en entrée'
t=time.clock()#Temps de départ du calcul du programme
#---------------------------------------------------------------
#       Bilan des fréquences
#---------------------------------------------------------------
if valStartF>valStopF: valStopF,valStartF= valStartF,valStopF
 
nbMesure = int(((valStopF-valStartF)/valFpas)) + 1
 
print u'Valeur de la fréquence de départ :', valStartF, u'Hz.'
print u'Valeur de la fréquence de fin :', valStopF, u'Hz.'
print u'Valeur du pas de la mesure :', valFpas, u'Hz.', u'Il y aura ', nbMesure, u'mesures.'
#---------------------------------------------------------------
#       Boucle de fréquence
#---------------------------------------------------------------
gamStopF = valStopF + valFpas # gamme (début, fin(valeur non atteinte, pas)
gammeF = range(int(valStartF),int(gamStopF),int(valFpas))
#---------------------------------------------------------------
#       Constantes
#---------------------------------------------------------------
##mu = ex.constant(4*pi*1e-7) # Perméabilité
mu = constant(4*pi*1e-7) # Perméabilité
c = 299792458 # Célérité
E0 = 1/mu/c**2 # Permittivité dans le vide
E = 1.000649*E0 # Permittivité dans le matériau
##rho = ex.constant(22e-9) # Résistivité
rho = constant(22e-9) # Résistivité
Zref = 50 # Pour le moment c'est une constante
#------------------------------------------------------------------------------------
#Mise en page du fichier d'enregistrement des données de la matrice S de la ligne
#------------------------------------------------------------------------------------
F0d = {}
L0d = {}
C0d = {}
diamA = {}
diamB = {}
trio = {}
ct = {}
Z0 = {}
matSFile.write('Petit diamètre (mm)\tGrand diamètre (mm)\tImpédance Z0\n')
for nz in range(0,len(Z)):
  vdiamA,vdiamB = Z[nz]
  diamA[nz] = elementary(float(vdiamA)*1e-3, 0.02e-3)
  diamB[nz] = elementary(float(vdiamB)*1e-3, 0.02e-3)
  r = diamA[nz]/diamB[nz]
  #------------------------------------------------------------------------------------------------------
  # Calcul des caractéristiques d'une ligne à air sans pertes
  F0d[nz] = ((r**2-1)/(2*log(r)))-(r*log(r)/(r+1))-0.5*(r+1)#F1-F2-0.5*diamB/diamA
  L0d[nz] = mu*log(r)/2/pi # Inductance linéique sans perte
  C0d[nz] = 2*pi*E/log(r)
  #-------------------------------------------
  # Constantes necessaires pour plus tard
  trio[nz] = F0d[nz]*L0d[nz]*C0d[nz]/8
  ct[nz] = sqrt(rho/2/mu)*(1+r)/log(r)
  #----------------------------------------
  # Calcul de l'impédance Z0
  Z0[nz] = sqrt(L0d[nz]/C0d[nz]) # Impédance Z0
  #----------------------------------------------------------------------------------------------
  # Sortie
  #----------------------------------------------------------------------------------------------
  u_re, u_im, r = as_std_uncertainty( std_covariance(Z0[nz]) )
  valdiamcol = str(value(diamA[nz])) + "\t" + str(value(diamB[nz])) + "\t" + str(value(Z0[nz])) + str(u_re) +  str(u_im) + "\n"
  matSFile.write(valdiamcol)
matSFile.write("\n")
#------------------------------------------------------------------------------------
# Calcul des caractéristiques d'une ligne pour les diamètres min, max et moyen
# et enregistrement de ces données dans le fichier d'enregistrement
#------------------------------------------------------------------------------------
for f in gammeF :
  w = 2*pi*f              #pulsation
  matSFile.write('Fréquence (Hz)' + "\t" + str(value(f)) + "\n")
  matSFile.write('Valeur petit diamètre (mm)\tValeur grand diamètre (mm)\tImpédance caractéristique Zc\tGamma G\n')
  for extdiamA, extdiamB in zip([min(ListeA), sum(ListeA)/len(ListeA), max(ListeA)], [min(ListeB), sum(ListeB)/len(ListeB), max(ListeB)]):
    extdiamA = elementary(extdiamA*1e-3, 0.02e-3)
    extdiamB = elementary(extdiamB*1e-3, 0.02e-3)
    #------------------------------------------------------------------------------------
    # Calcul des caractéristiques d'une ligne à air sans pertes
    #------------------------------------------------------------------------------------
    F0 = (((extdiamB/extdiamA)**2-1)/(2*log(extdiamB/extdiamA)))-((extdiamB/extdiamA)*log(extdiamB/extdiamA)/((extdiamB/extdiamA)+1))-0.5*((extdiamB/extdiamA)+1)
    L0 = mu*log(extdiamB/extdiamA)/2/pi # Inductance linéique sans perte
    C0 = 2*pi*E/log(extdiamB/extdiamA) # Capacité linéique sans perte
    #------------------------------------------------------------------------------------
    # Calcul des caractéristiques d'une ligne à air avec pertes
    #------------------------------------------------------------------------------------
    k2 = (w*sqrt(L0*C0))**2      #nombre d'onde angulaire au carré
    ds = sqrt(2*rho/w/mu)   #épaisseur de peau
    d0 = ds*(1+(extdiamB/extdiamA))/(4*(extdiamB/2)*log(extdiamB/extdiamA))
    R = 2*w*L0*d0*(1-k2*(extdiamA/2)**2*F0/2)     #résistance linéique
    L = L0*(1+2*d0*(1-k2*(extdiamA/2)**2*F0/2))   #inductance linéique
    G = w*C0*d0*k2*(extdiamA/2)**2*F0             #conductance linéique
    C = C0*(1+d0*k2*(extdiamA/2)**2*F0)           #capacité linéique
    Zc = sqrt((R+((L*w)*1j))/(G+((C*w)*1j)))     #impédance caractéristique
    Gamma = sqrt((R+((L*w)*1j))*(G+((C*w)*1j)))  #constante de propagation
    IncZc = "u(re) =%s, u(im) = %s, r = %s" % as_std_uncertainty( std_covariance(Zc) )
    IncGamma = "u(re) =%s, u(im) = %s, r = %s" % as_std_uncertainty( std_covariance(Gamma) )
    valExtcol = str(value(vdiamA)) + "\t" + str(value(vdiamB)) + "\t" + str(value(Zc)) \
                + str(IncZc)+ "\t"+ str(value(Gamma)) + str(IncGamma) + "\n"
    matSFile.write(valExtcol)
matSFile.write("\n")
matSFile.write('Fréquence en Hz\tMatrice S11\tMatrice S12\tMatrice S21\tMatrice S22\n')
#-------------------------------------------------------
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
# Calcul des caractéristiques d'une ligne à air
# avec pertes en fonction de la fréquence
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
print ""
print u'Le calcul de la matrice S par fréquence va commencer.'
print ""
for f in gammeF:
  w = 2*pi*f              #pulsation
  print u'La fréquence en cours est :', f, u'Hz'
  print ""
  # ----------------------------------------------------------------------------------
  # Détermination de la matrice identité de départ pour les calculs de la matrice ABCD
  # ----------------------------------------------------------------------------------    
  ABCD = numpy.matrix([[1,0],[0,1]])
  # ------------------------------------------------------------------------------------
  # Boucle à partir des données extraites des fichiers (calculs en fonction des diamètres)
  # ------------------------------------------------------------------------------------
  for nz in range(0,len(Z)):
    #------------------------------------------------------------------------------------
    # Calcul des caractéristiques d'une ligne à air avec pertes
    #------------------------------------------------------------------------------------
    G = math.sqrt(w)*(w*diamA[nz])**2*(trio[nz]/diamB[nz])
    R = L0d[nz]*2*ct[nz]*((math.sqrt(w)/diamB[nz])-G)#résistance linéique
    G = C0d[nz]*2*ct[nz]*G#conductance linéique
    L = L0d[nz] + R/w#inductance linéique
    C = C0d[nz] + G/w#capacité linéique
    Zc = sqrt((R+((L*w)*1j))/(G+((C*w)*1j)))    #impédance caractéristique
    Gamma = sqrt((R+((L*w)*1j))*(G+((C*w)*1j))) #constante de propagation
    #------------------------------------------------------------------------------------
    # Détermination de la Matrice ABCD de la ligne
    #------------------------------------------------------------------------------------
    coef = Gamma*elementary(cdeltaL, 0.5e-3)
    Cos = cosh(coef)
    Sin = sinh(coef)
    ABCD = ABCD * numpy.matrix([[Cos,Sin*Zc],[Sin/Zc,Cos]]) #Création de la matrice ABCD d'un élément de la ligne ([A,B],[C,D])
  #-----------------------------------------------------------------------------------------
  # Calcul du coefficient de la matrice S de la ligne à partir de la matrice ABCD de la ligne
  #-----------------------------------------------------------------------------------------
  Scoef = 1/((ABCD[0,1]+ABCD[1,0]*Zref*Zref)+(ABCD[0,0]*Zref+ABCD[1,1]*Zref))
  #-----------------------------------------------------------------------------------------
  # Calcul des valeurs de la matrice S
  #-----------------------------------------------------------------------------------------
  matS11 =Scoef*(ABCD[0,1]-ABCD[1,0]*Zref*Zref+ABCD[0,0]*Zref-ABCD[1,1]*Zref)
  matS12 =Scoef*(2*Zref*(ABCD[0,0]*ABCD[1,1]-ABCD[0,1]*ABCD[1,0]))
  matS21 =Scoef*(2*Zref)
  matS22 =Scoef*(ABCD[0,1]-ABCD[1,0]*Zref*Zref-ABCD[0,0]*Zref+ABCD[1,1]*Zref)
  #-----------------------------------------------------------------------------------------
  # Formatage de l'écriture en sortie des valeurs d'incertitudes
  #-----------------------------------------------------------------------------------------
  tabIncmatS11 = "u(re) =%s, u(im) = %s, r = %s" % as_std_uncertainty( std_covariance(matS11) )
  tabIncmatS12 = "u(re) =%s, u(im) = %s, r = %s" % as_std_uncertainty( std_covariance(matS12) )
  tabIncmatS21 = "u(re) =%s, u(im) = %s, r = %s" % as_std_uncertainty( std_covariance(matS21) )
  tabIncmatS22 = "u(re) =%s, u(im) = %s, r = %s" % as_std_uncertainty( std_covariance(matS22) )
  #-----------------------------------------------------------------------------------------
  # Ecriture du fichier
  #-----------------------------------------------------------------------------------------
  valcol = str(value(f)) + "\t" + \
           str(value(matS11)) + str(tabIncmatS11) + "\t" + \
           str(value(matS12))  + str(tabIncmatS12) + "\t" + \
           str(value(matS21))  + str(tabIncmatS21) + "\t" + \
           str(value(matS22))  + str(tabIncmatS22) + "\n"
  matSFile.write(valcol)
matSFile.close()
print time.clock()-t # Temps total du programme
MiseEnPage = raw_input('Les calculs sont finis. Cliquer sur <ENTER> pour Lancer la mise en page du fichier.')
macroExcelFile = 'T:\Mesure dimensionnelle Paramètre S\Programme Python\Test Macro.xls'
 
filepath = os.path.abspath(macroExcelFile) # Always make sure you use an absolute path !
 
excel = win32com.client.Dispatch('Excel.Application')
excel.Visible = True
workbook = excel.Workbooks.Open(filepath)
finMiseEnPage = raw_input('Quand la macro est finie, cliquer sur <ENTER>.')
excel.Quit()

voilà c'est résolu, et je te dis un très grand merci pour ta grande contribution !

Patricia

08/10/2008, 13h22
eyquem

Ouaaaaahhh....

On y arrive enfin. Je savais bien qu'on en n'était pas loin. :D
Je suis satisfait de voir que l'introduction de dictionnaires FOd,LOd,COd etc ne nous a pas entrainé dans une impasse.

C'est résolu pour ce qui est de l'indispensable: que ça tourne !
Mais il reste quelques petites choses à améliorer dans ton code et d'autres plus importantes à faire pour optimiser le programme. J'attendais que ça tourne pour t'en parler.

Mais avant tout, je voudrais que tu me dises que tu as véritablement vérifié les calculs mathématiques par lesquels j'ai transformé les expressions pour arriver à un ensemble de calculs restreints dans lesquels il n'y a plus k2, ds, d0...etc et des expressions de calcul de G,R,L,C réécrites.
Il faut impérativement vérifier que mes modifications n'ont pas introduit d'erreur de calcul.
C'est tout bête à faire, ce n'est pas de la programmation, c'est des maths, il faut simplement prendre un crayon et du papier et refaire méthodiquement les transformations indiquées dans mon message #46.
Mais il faut le faire soigneusement et me tranquiliser sur ce point en me disant que ça a été fait. Merci

Je suis impressionné qu'avec un module gum modifié le temps de calcul tombe de 25h à 12 minutes. Comme je vois qu'il reste dans ton code une ligne import math, je pense que la modification de son programme ne porte pas que sur le seul point de l'acceptation d'argument non "uncertain number" mais qu'il a fait des modifications de l'algorithme.
Ça fait une division du temps d'exécution par 125 ! Je me demande qu'est ce qu'il a bien pu fabriquer dans son module.

Soit dit en passant, j'aimerais bien savoir quel serait le temps d'exécution avec un code qui ne comporterait pas les dictionnaires FOd,LOd etc et qui referait les calculs de ces variables pour chaque valeur f, même en gardant les expressions transformées. Si un jour tu pouvais faire ça, ça satisferait ma curiosité.
Mais ce n'est pas le plus urgent. Je te dis un certain nombre d'autres choses dans un message ultérieur.

Par contre je veux tout de suite te demander:
- quelles sont les valeurs susceptibles de se trouver dans filePetitDiam et fileGrandDiam ?
valeur minimum, valeur maximum ?
nombre de chiffres après la virgule c'est à dire finalement la précision de mesure ?
Je voudrais savoir si les domaines de définition des valeurs de filePetitDiam et fileGrandDiam sont à nombre d'éléments restreint ou s'il sont trés denses en valeurs entre leurs bornes.

Voir 40 message(s) de cette discussion en une page