Lenteur du programme puis plantage

**bourgui78** · 08/10/2008, 13h03

ça donne les mêmes résultats qu'avec le programme d'origine, donc c'est très rassurant, je l'avais déjà vérifié la semaine dernière, mais je viens de le refaire, c'est tout à fait OK.
Pour les fichiers de diamètres, en fait ça dépend des caractéristiques des câbles coaxials, de 0.80mm à 7mm, je t'envoie par mail l'exemple de fichier que j'ai (cas réel). et je t'envoie aussi la modif du GUM. la précision sera les 20 micron, je pense

Par contre je viens de m'apercevoir que le tout dernier programme ne me donne pas les résultats que j'avais à l'orgine, je vais me repencher dessus... j'ai peut-être fait une boulette en entrée.

@+

Patricia

**eyquem** · 09/10/2008, 13h24

Quand j'ai lu que les diamètres vont de 0,80 mm à 7 mm par précision de 20 microns, soit 310 valeurs possibles, j'ai pensé qu'une idée que j'avais ne pouvait pas être mise en œuvre.
Mon idée était la suivante: si Z contenait plusieurs fois un même couple vdiamA,vdiamB , il serait intéressant de ne pas refaire un calcul long avec des matrices, ayant déjà été fait, à f donnée, à chaque fois que revient ce couple dans la boucle for nz in range(0,len(Z)).
Mais 310 x 310 = 96100 couples vdiamA,vdiamB possibles --> la probabilité de voir revenir un même couple est trop faible et ne justifie pas de compliquer le programme pour tenir compte de cette rare éventualité.

Cependant en voyant les fichiers filePetitDiam et fileGrand Diam que tu m'as transmis, je vois que dans chacun, les valeurs de vdiamX tournent autour d'une valeur précise, elles ne vont pas de 0,80 à 7.
Donc j'ai regardé combien de fois se répètent des couples dans ces fichiers.

Pour filePetitDiamA par exemple

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
diamAFile = open('filePetitDiam','r')
ListeA = [ float(a) for a in diamAFile ]
diamAFile.close()
 
ct = {}
n = 0
for r in ListeA:
    ct[r] = 0
 
for r in ListeA:
    ct[r] += 1
 
rvus = []
for r in ListeA:
    if ct[r]>1 and r not in rvus:
        rvus.append(r)
        print 'ct[',r,'] =',ct[r]
 
tot = 0
for r in ListeA:
    if ct[r]>1:
        tot += 1
print tot,'valeurs sur les',len(ListeA),'sont des valeurs repetees'

ça donne

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
>>> 
ct[ 3.03921 ] = 2
ct[ 3.03874 ] = 6
ct[ 3.03872 ] = 5
ct[ 3.03869 ] = 2
ct[ 3.03867 ] = 3
ct[ 3.03885 ] = 3
ct[ 3.0388 ] = 3
ct[ 3.03882 ] = 4
ct[ 3.03889 ] = 2
ct[ 3.03886 ] = 3
ct[ 3.03893 ] = 3
ct[ 3.03913 ] = 6
ct[ 3.03912 ] = 2
ct[ 3.03901 ] = 2
ct[ 3.03929 ] = 3
ct[ 3.03915 ] = 5
ct[ 3.03925 ] = 3
ct[ 3.03932 ] = 2
ct[ 3.03926 ] = 2
ct[ 3.03935 ] = 2
ct[ 3.03937 ] = 2
ct[ 3.03927 ] = 2
ct[ 3.03934 ] = 2
ct[ 3.0391 ] = 4
ct[ 3.03908 ] = 2
ct[ 3.03911 ] = 2
ct[ 3.03884 ] = 4
ct[ 3.0387 ] = 2
ct[ 3.03876 ] = 2
ct[ 3.03924 ] = 2
ct[ 3.03941 ] = 2
89 valeurs sur les 126 sont des valeurs repetees
>>>

C'est suffisant pour justifier d'améliorer le programme pour éviter de refaire des calculs de diamA et diamB identiques, à mon avis.
Je te propose donc de remplacer les deux lignes

Code :

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

1
2
  diamA[nz] = elementary(float(vdiamA)*1e-3, 0.02e-3)
  diamB[nz] = elementary(float(vdiamB)*1e-3, 0.02e-3)

par

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
  if vdiamA not in vdiamAvus:
      diamA[nz] = elementary(float(vdiamA)*1e-3, 0.02e-3)
      valeurA[vdiamA] = diamA[nz]
      vdiamAvus.append(vdiamA)
  else:
      diamA[nz] = valeurA[vdiamA]
 
  if vdiamB not in vdiamBvus:
      diamB[nz] = elementary(float(vdiamB)*1e-3, 0.02e-3)
      valeurB[vdiamB] = diamB[nz]
      vdiamBvus.append(vdiamB)
  else:
      diamB[nz] = valeurB[vdiamB]

Il faut définir vdiamAvus, vdiamBvus, valeurA, valeurB avant.

Par ailleurs, il faut pousser la logique de l'introduction de dictionnaires jusqu'au bout. Ça ne va pas de laisser
diamA[nz]**2*(trio[nz]/diamB[nz])
dans l'expression

Code :

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

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

parce que le calcul diamA[nz]**2*(trio[nz]/diamB[nz]) est refait à chaque f nouvelle alors que c'est une constante indépendante de f.

Il faut donc réécrire dans la boucle 3

Code :

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

G = sqrt(w) * w**2 * constanteG[nz]

et remplacer dans la boucle 1
trio[nz] = F0d[nz]*L0d[nz]*C0d[nz]/8
par

Code :

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

constanteG[nz] =  ( F0d[nz]*L0d[nz]*C0d[nz] * diamA[nz]**2 ) / ( 8 * diamB[nz] )

À l'occasion de ces modifications, je me suis aperçu qu'on peut remplacer sqrt(w) par w**0.5 sans avoir à importer le module math.
On peut donc écrire dans la boucle 3:

Code :

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

G[nz] = (w**2.5) * constanteG[nz]

(il n'y a pas besoin des parenthèses autour de w**2.5 en fait, mais je préfère les mettre)

J'ai aussi vu quelque chose:
dans la nouvelle expression de G[nz] il n'apparait plus diamA[nz]. On peut donc se passer de définir un dictionnaire diamA.
Dans la boucle 1, il suffit de faire

Code :

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

1
2
3
4
5
6
  if vdiamA not in vdiamAvus:
      diamA = elementary(float(vdiamA)*1e-3, 0.02e-3)
      valeurA[vdiamA] = diamA
      vdiamAvus.append(vdiamA)
  else:
      diamA = valeurA[vdiamA]

Encore une chose.

Code :

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

1
2
ListeA = [ float(a) for a in diamAFile ]
ListeB = [ float(b) for b in diamBFile ]

Les valeurs dans ListeA et ListeB sont des float. Inutile donc d'écrire
diamX = elementary(float(vdiamX)*1e-3, 0.02e-3)
Il suffit de

Code :

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

diamX = elementary(vdiamX*1e-3, 0.02e-3)

Tout ça donne:

pour la boucle 1

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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
F0d = {}
L0d = {}
C0d = {}
diamB = {}
constanteG ={}
ct = {}
Z0 = {}
matSFile.write('Petit diamètre (mm)\tGrand diamètre (mm)\tImpédance Z0\n')
 
vdiamAvus = []
vdiamBvus = []
valeurA = {}
valeurB = {}
t1 = clock()
for nz in range(0,len(Z)):
  vdiamA,vdiamB = Z[nz]
 
  if vdiamA not in vdiamAvus:
      diamA = elementary(vdiamA*1e-3, 0.02e-3)
      valeurA[vdiamA] = diamA
      vdiamAvus.append(vdiamA)
  else:
      diamA = valeurA[vdiamA]
 
  if vdiamB not in vdiamBvus:
      diamB[nz] = elementary(vdiamB*1e-3, 0.02e-3)
      valeurB[vdiamB] = diamB[nz]
      vdiamBvus.append(vdiamB)
  else:
      diamB[nz] = valeurB[vdiamB]
 
  r = diamA/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
  constanteG[nz] = ( F0d[nz]*L0d[nz]*C0d[nz] * diamA[nz]**2 ) / ( 8 * diamB[nz] )
  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")
print '\nExecution de la boucle 1 en',clock() - t1,' secondes\n'

pour la boucle 3

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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
for f in gammeF:
  tf = clock()
  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)
  # ------------------------------------------------------------------------------------
  t3 = clock()
  for nz in range(0,len(Z)):
    #------------------------------------------------------------------------------------
    # Calcul des caractéristiques d'une ligne à air avec pertes
    #------------------------------------------------------------------------------------
    G = (w**2.5) * constanteG[nz]
    R = L0d[nz]*2*ct[nz]*(W**0.5/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])
  print 'pour nz =',nz,"  temps d'execution =",clock() - t3
  #-----------------------------------------------------------------------------------------
  # 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)
  print "Temps d'execution du tour f=",f,' :  ',clock() - tf

Remarque les instructions clock() et print que j'ai ajoutées pour avoir des mesures des divers temps d'exécution. J'aimerais bien avoir une idée de ces divers temps, notamment celui impliquant les matrices.

Ce serait bien de mettre ces instructions aux mêmes endroits dans le code non modifié pour voir à quels endroits du code les améliorations influent le plus, si elles influent.

Pour que clock() fonctionne il faut mettre

Code :

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

from time import clock

au debut

**bourgui78** · 13/10/2008, 13h45

Salut,

tout est dans le titre, je penses que tu es arrivé à un niveau tip top total 227.89s

et en moyenne 1.20s par fréquence pour la boucle 3 et 1.28 pour la boucle 1 pour 100 diamètres et 180 fréquences !

je te tire mon chapeau !

Merci encore, maintenant je vais faire des mesures réelles, et avec des collègues d'un autre secteur (statistique) on va valiser les calculs de B Hall, et voir si on peut généraliser ce processus.

Merci encore

@+

PAt

Lenteur du programme puis plantage

Python

Discussions similaires

Partager

Partager