Lenteur du programme puis plantage

**bourgui78** · 05/09/2008, 15h38

Bonjour,

j'ai écris un prog qui fonctionne seulement si le nombre de boucle est limitée.
Je m'explique.
Voici le code au complet :

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
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
#!/usr/bin/python
# -*- coding:Latin-1 *-*
 
from mst.GUM.complex.gum import *
from math import pi
 
import sys
import os
import numpy
import Tkinter
import tkFileDialog
import win32com.client
 
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='T:\Mesure dimensionnelle Paramètre S\Programme Python',
                                             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
#------------------------------------------------------------------------------------
 
try :
  os.remove(directMatS) # Suppression du fichier s'il existe
  print u"le fichier a été supprimé"
except :
  print u"erreur de suppression du fichier ou fichier n'existe pas ", directMatS
try:
  matSFile = open(directMatS,'a') # Création du fichier et ouverture en mode ajout
  print u"le fichier a été créé"
except:
  print u"erreur de création du fichier ", directMatS
print ""
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
# Programme général
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
ex = Context()
_J_ = ex.constant(0+1j)
#------------------------------------------------------------------------------------
# Gestion des fichiers des mesures des diamètres
#------------------------------------------------------------------------------------
diamAFile = open(filePetitDiam,'r')
diamBFile = open(fileGrandDiam,'r')
diamAListe = diamAFile.readlines() #données extraites du fichier des petits diamètres
listeDiamA = map(float,diamAListe)
diamBListe = diamBFile.readlines() #données extraites du fichier des grands diamètres
listeDiamB = map(float,diamBListe)
diamListe =[]
diamListe.append(listeDiamA)
diamListe.append(listeDiamB)
 
 
#------------------------------------------------------------------------------------
# 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)
    valFdeb = startF
except ValueError:
    valFdeb = 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)
    valFfin = stopF
except ValueError:
    valFfin = 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'
 
#---------------------------------------------------------------
#       Bilan des fréquences
#---------------------------------------------------------------
if valFdeb > valFfin :
    print u'La fréquence de départ est supérieure à la fréquence de fin donc le programme inverse les deux fréquences.'
    valStartF = valFfin
    valStopF = valFdeb
else :
    valStartF = valFdeb
    valStopF = valFfin
 
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'points de mesures.'
 
espcol = ""
espcol = "\n"
gamStopF = valStopF + valFpas # gamme (début, fin(valeur non atteinte, pas)
gammeF = range(int(valStartF),int(gamStopF),int(valFpas))
#-----------------------------------------------------------------------------------
# Calcul de la matrice S d'une ligne 
# et enregistrement de ces données dans le fichier d'enregistrement
#------------------------------------------------------------------------------------
matSFile.write(espcol)
nomcol = ""
valcol = ""
nomcol = 'Fréquence en Hz' + "\t" + 'Matrice S11' + "\t" + 'Matrice S12' + "\t" + 'Matrice S21' + "\t" + 'Matrice S22' + "\n"
matSFile.write(nomcol)
raw_input ('POUR CONTINUER : ( cliquer sur <ENTER> ) ')
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
# 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:
  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
  # ----------------------------------------------------------------------------------    
  ind = numpy.matrix([[1,0],[0,1]])
  matprec = ind
 
  # ------------------------------------------------------------------------------------
  # Boucle à partir des données extraites des fichiers (calculs en fonction des diamètres)
  # ------------------------------------------------------------------------------------
  for vdiamA,vdiamB in zip(listeDiamA,listeDiamB):    
    #------------------------------------------------------------------------------------
    # Données mesurées pour les calculs qui suivent
    #------------------------------------------------------------------------------------
    diamA = ex.gaussian(vdiamA*1e-3, uAbsolute(0.02e-3)) # Petit diamètre
    diamB = ex.gaussian(vdiamB*1e-3, uAbsolute(0.02e-3)) # Grand diamètre
    deltaL = ex.gaussian(cdeltaL, uAbsolute(0.5e-3)) # Pas de mesure
    #------------------------------------------------------------------------------------
    # Calcul des caractéristiques d'une ligne à air sans pertes
    #------------------------------------------------------------------------------------
    a = diamA/2 # Petit rayon
    b = diamB/2 # Grand rayon
    c = 299792458 # Célérité
    mu = ex.constant(4*pi*1e-7) # Perméabilité
    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é
    r = b/a # Rapport des rayons
    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 # Inductance linéique sans perte
    C0 = 2*pi*E/log(r) # Capacité linéique sans perte
    Z0 = sqrt(L0/C0) # Impédance Z0
    #------------------------------------------------------------------------------------
    # Calcul des caractéristiques d'une ligne à air avec pertes
    #------------------------------------------------------------------------------------
    w = 2*pi*f              #pulsation
    #print 'w =',value(w)
    k = w*sqrt(L0*C0)      #nombre d'onde angulaire
    #print 'k =',result(k)
    d1 = 2*rho/w/mu
    #print 'd1 =', result(d1)
    d2 = sqrt(d1)
    #print 'd2 =',result (d2)
    ds = sqrt(2*rho/w/mu)   #épaisseur de peau
    #print 'épaisseur de peau de ligne : ds=',result(ds)
    d0 = ds*(1+r)/(4*b*log(r))
    #print "d0 = ", result(d0)
    R = 2*w*L0*d0*(1-k**2*a**2*F0/2)     #résistance linéique
    #print 'Résistance linéique R =', result(R)
    L = L0*(1+2*d0*(1-k**2*a**2*F0/2))   #inductance linéique
    #print 'Inductance linéique L =',result(L)
    G = w*C0*d0*k**2*a**2*F0             #conductance linéique
    #print 'Conductance linéique G =',result(G)
    C = C0*(1+d0*k**2*a**2*F0)           #capacité linéique
    #print 'Capacité linéique C=',result(C)
    Zc = sqrt((R+((L*w)*1j))/(G+((C*w)*1j)))     #impédance caractéristique
    #print 'Impédance caractéristique Zc =',result(Zc)
    gamma = sqrt((R+((L*w)*1j))*(G+((C*w)*1j)))  #constante de propagation
    #print 'Constante de propagation Gamma =',result(gamma)
    #------------------------------------------------------------------------------------
    # Détermination de la Matrice ABCD de la ligne
    #------------------------------------------------------------------------------------
    coef = gamma*deltaL
    A = cosh(coef)
    B = sinh(coef)*Zc
    C = sinh(coef)/Zc
    D = cosh(coef)
    ABCDprec = numpy.matrix([[A,B],[C,D]]) #Création de la matrice ABCD d'un élément de la ligne
    ABCD = matprec*ABCDprec
    matprec = ABCD
    #print 'ABCD=',value(ABCD)
  #-----------------------------------------------------------------------------------------
  # Calcul de la matrice S de la ligne à partir de la matrice ABCD de la ligne
  #-----------------------------------------------------------------------------------------
  Zref = 50
  Afinal = ABCD[0,0]
  Bfinal = ABCD[0,1]
  Cfinal = ABCD[1,0]
  Dfinal = ABCD[1,1]
  Scoef = 1/((Bfinal+Cfinal*Zref*Zref)+(Afinal*Zref+Dfinal*Zref))
  print 'Scoef pour la matrice S=',value(Scoef)
  tempS11 = Bfinal-Cfinal*Zref*Zref+Afinal*Zref-Dfinal*Zref
  tempS12 = 2*Zref*(Afinal*Dfinal-Bfinal*Cfinal)
  tempS21 = 2*Zref
  tempS22 = Bfinal-Cfinal*Zref*Zref-Afinal*Zref+Dfinal*Zref
  #-----------------------------------------------------------------------------------------
  # Calcul des valeurs de la matrice S
  #-----------------------------------------------------------------------------------------
  matS11 =Scoef*tempS11
  matS12 =Scoef*tempS12
  matS21 =Scoef*tempS21
  matS22 =Scoef*tempS22
  matS = numpy.matrix([[matS11,matS12],[matS21,matS22]]) # Création de la matrice S sans la multiplication par le coef
  #-----------------------------------------------------------------------------------------
#  print 'Résultat de la matrice S de la ligne'
  #-----------------------------------------------------------------------------------------
  print 'matS_11 finale = ', result(matS[0,0])
  print 'matS_12 finale = ', result(matS[0,1])
  print 'matS_21 finale = ', result(matS[1,0])
  print 'matS_22 finale = ', result(matS[1,1])
  print '                                 -------------------------------                       '
  #-----------------------------------------------------------------------------------------
  # Formatage de l'écriture en sortie
  #-----------------------------------------------------------------------------------------
 
  valcol = str(value(f)) + "\t" + str(value(matS11)) + str(numpy.array2string(numpy.array(ex.uncertainty(matS11)).ravel())) \
           + "\t" + str(value(matS12))  + str(numpy.array2string(numpy.array(ex.uncertainty(matS12)).ravel())) + "\t" + \
           str(value(matS21))  + str(numpy.array2string(numpy.array(ex.uncertainty(matS21)).ravel())) + "\t" + \
           str(value(matS22))  + str(numpy.array2string(numpy.array(ex.uncertainty(matS22)).ravel())) + "\n"
  matSFile.write(valcol)
 
matSFile.close()
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()

vDiamA et vDiamB comportent 125 valeurs chacunes, j'ai donc 125 boucles (si =5 ça fonctionne)
en fait j'ai ajouté de l'affichage pour voir où le programme ralentissait.

Code :

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

print 'Scoef pour la matrice S=',value(Scoef)

: affichage ok

Code :

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

 print 'matS_11 finale = ', result(matS[0,0])

: Affichage de matS_11 finale, mais pas de la valeur.
et au bout d'un certain temps... le programme se ferme, sans avoir rien fait.
D'où cela peut-il venir ? j'ai essayé sur 3 pc, dont les ram sont différentes, j'utilise 1.5g de ram soit 25%, et ça plante encore

merci pour votre aide.

Patricia

**eyquem** · 07/09/2008, 21h26

On veut bien être sympa, mais c'est limite moquerie ce genre de post.
Ce n'est pas évident de comprendre ce que fait un programme à partir de son code, tu réalises ?
On ne peut pas avoir une explication préalable, une visite guidée d'introduction, des petites remarques judicieuses ? C'est trop difficile à faire ?
Tiens, au passage, tu as mis combien de temps par exemple pour écrire ton programme tel qu'il est là ?
Je veux bien regarder ça, mais il faudrait aider un peu quand même, faut pas pousser.

**bourgui78** · 08/09/2008, 09h15

je ne voulais pas t'énerver ! je multiplie 125 matrices entre elles d'où le numpy.matrix
pour plus de clarté voici la partie qui plante

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
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
for f in gammeF:
  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
  # ----------------------------------------------------------------------------------    
  ind = numpy.matrix([[1,0],[0,1]])
  matprec = ind
 
  # ------------------------------------------------------------------------------------
  # Boucle à partir des données extraites des fichiers (calculs en fonction des diamètres)
  # ------------------------------------------------------------------------------------
  for vdiamA,vdiamB in zip(listeDiamA,listeDiamB):    
    #------------------------------------------------------------------------------------
    # Données mesurées pour les calculs qui suivent
    #------------------------------------------------------------------------------------
    diamA = ex.gaussian(vdiamA*1e-3, uAbsolute(0.02e-3)) # Petit diamètre
    diamB = ex.gaussian(vdiamB*1e-3, uAbsolute(0.02e-3)) # Grand diamètre
    deltaL = ex.gaussian(cdeltaL, uAbsolute(0.5e-3)) # Pas de mesure
    #------------------------------------------------------------------------------------
    # Calcul des caractéristiques d'une ligne à air sans pertes
    #------------------------------------------------------------------------------------
    a = diamA/2 # Petit rayon
    b = diamB/2 # Grand rayon
    c = 299792458 # Célérité
    mu = ex.constant(4*pi*1e-7) # Perméabilité
    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é
    r = b/a # Rapport des rayons
    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 # Inductance linéique sans perte
    C0 = 2*pi*E/log(r) # Capacité linéique sans perte
    Z0 = sqrt(L0/C0) # Impédance Z0
    #------------------------------------------------------------------------------------
    # Calcul des caractéristiques d'une ligne à air avec pertes
    #------------------------------------------------------------------------------------
    w = 2*pi*f              #pulsation
    #print 'w =',value(w)
    k = w*sqrt(L0*C0)      #nombre d'onde angulaire
    #print 'k =',result(k)
    d1 = 2*rho/w/mu
    #print 'd1 =', result(d1)
    d2 = sqrt(d1)
    #print 'd2 =',result (d2)
    ds = sqrt(2*rho/w/mu)   #épaisseur de peau
    #print 'épaisseur de peau de ligne : ds=',result(ds)
    d0 = ds*(1+r)/(4*b*log(r))
    #print "d0 = ", result(d0)
    R = 2*w*L0*d0*(1-k**2*a**2*F0/2)     #résistance linéique
    #print 'Résistance linéique R =', result(R)
    L = L0*(1+2*d0*(1-k**2*a**2*F0/2))   #inductance linéique
    #print 'Inductance linéique L =',result(L)
    G = w*C0*d0*k**2*a**2*F0             #conductance linéique
    #print 'Conductance linéique G =',result(G)
    C = C0*(1+d0*k**2*a**2*F0)           #capacité linéique
    #print 'Capacité linéique C=',result(C)
    Zc = sqrt((R+((L*w)*1j))/(G+((C*w)*1j)))     #impédance caractéristique
    #print 'Impédance caractéristique Zc =',result(Zc)
    gamma = sqrt((R+((L*w)*1j))*(G+((C*w)*1j)))  #constante de propagation
    #print 'Constante de propagation Gamma =',result(gamma)
    #------------------------------------------------------------------------------------
    # Détermination de la Matrice ABCD de la ligne
    #------------------------------------------------------------------------------------
    coef = gamma*deltaL
    A = cosh(coef)
    B = sinh(coef)*Zc
    C = sinh(coef)/Zc
    D = cosh(coef)
    ABCDprec = numpy.matrix([[A,B],[C,D]]) #Création de la matrice ABCD d'un élément de la ligne
    ABCD = matprec*ABCDprec
    matprec = ABCD
    #print 'ABCD=',value(ABCD)
  #-----------------------------------------------------------------------------------------
  # Calcul de la matrice S de la ligne à partir de la matrice ABCD de la ligne
  #-----------------------------------------------------------------------------------------
  Zref = 50
  Afinal = ABCD[0,0]
  Bfinal = ABCD[0,1]
  Cfinal = ABCD[1,0]
  Dfinal = ABCD[1,1]
  Scoef = 1/((Bfinal+Cfinal*Zref*Zref)+(Afinal*Zref+Dfinal*Zref))
  print 'Scoef pour la matrice S=',value(Scoef)
  tempS11 = Bfinal-Cfinal*Zref*Zref+Afinal*Zref-Dfinal*Zref
  tempS12 = 2*Zref*(Afinal*Dfinal-Bfinal*Cfinal)
  tempS21 = 2*Zref
  tempS22 = Bfinal-Cfinal*Zref*Zref-Afinal*Zref+Dfinal*Zref
  #-----------------------------------------------------------------------------------------
  # Calcul des valeurs de la matrice S
  #-----------------------------------------------------------------------------------------
  matS11 =Scoef*tempS11
  print 'matS11 = ', result(matS11)
  matS12 =Scoef*tempS12
  matS21 =Scoef*tempS21
  matS22 =Scoef*tempS22
  matS = numpy.matrix([[matS11,matS12],[matS21,matS22]]) # Création de la matrice S sans la multiplication par le coef
  #-----------------------------------------------------------------------------------------

et pour info je ne suis pas du genre à me foutre du monde, donc tu pouvais dire la même chose en utilisant un ton plus "neutre".

Merci pour ton éventuel aide

Patricia

**eyquem** · 09/09/2008, 13h00

Salut,

J'ai compté rapidement les nombres d'opérations réalisées pour un tour de la boucle for vdiamA,vdiamB in zip(listeDiamA,listeDiamB): , c'est à dire pour 1 valeur de couple vdiamA,vdiamB:

- diamA,diamB,deltaL:
3 recours à une fonction ex.gaussian

- ligne à air sans pertes:
21 opérations élémentaires et 5 recours à des fonctions dans 9 calculs
(3 opérations élémentaires et 1 recours à la fonction log pour F2 = (r)*log(r)/(r+1) par exemple)
5 affectations de valeurs constantes

- ligne à air avec pertes:
2 opérations élémentaires pour 1 affectation de valeur constante w = 2*pi*f
62 opérations élémentaires et 6 recours à des fonctions dans 11 calculs

- Matrice ABCD de la ligne:
3 opérations élémentaires et 4 recours à une fonction dans 5 calculs
1 création de matrice ABCDprec = numpy.matrix([[A,B],[C,D]])
12 opérations élémentaires dans 4 calculs pour une multiplication de 2 matrices 2lignesx2colonnes

- calculs pour matrice S :
1 affectation de valeur constante
4 affectations de valeurs
32 opérations élémentaires dans 8 calculs
1 création de matrice matS = numpy.matrix([[matS11,matS12],[matS21,matS22]])

Soit au total:
132 opérations élémentaires et 18 fonctions dans 37 calculs
7 affectations de valeurs constantes
4 affectations de valeurs
2 créations de matrice

Ça ne me semble pas un volume énorme d'opérations pour un tour de boucle. Ça devrait prendre sensiblement le même temps de calcul pour chaque tour. Or ce temps semble de plus en plus long pour chaque tour supplémentaire puisqu'au delà de 5 tours ça rame sérieusement, c'est bien ça ?

Je pense que tu devrais truffer ton code d'instructions pour décompter les temps d'exécution de certaines lignes de calcul ou groupes de lignes. L'utilisation de clock() n'est pas très précise mais pour une première évaluation pour un ralentissement aussi marqué que dans ton cas, je pense que c'est suffisant.
Par exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
t1 = clock()
F1 = (r**2-1)/(2*log(r))
t2 = clock()
print t2 -t1
F2 = (r)*log(r)/(r+1)
t3 = clock()
print t3 - t2
F0 = F1-F2-0.5*(r+1)
t4 = clock()
print t4 - t3
print t4 - t1

**eyquem** · 09/09/2008, 13h07

1- Je vois des instructions
_J_ = ex.constant(0+1j)
et
Zc = sqrt((R+((L*w)*1j))/(G+((C*w)*1j)))
gamma = sqrt((R+((L*w)*1j))*(G+((C*w)*1j)))
dans lesquelles il y a (C*w)*1j

Ça me fait penser à des nombres complexes. Y a-t-il des calculs sur des complexes dans ton programme ? Il me semble que tout le reste représente des calculs de variables bateaux.

2- Dans quelle plage de valeurs possibles de f sont susceptibles de se trouver valStartF et gamStopF ? C'est à dire quel est l'intervalle de définition (valStartF,gamStopF) habituel de la grandeur f ?

Quel ordre de grandeur pour valFpas ?

La question étant en fait: quel est le nombre approximatif de valeurs dans le range gammeF ?

3- Que font les lignes suivantes ? ex est Context(), mais qu'est ce que Context() ? C'est encore un truc qui se trouve dans mst.GUM.complex.gum ?

diamA = ex.gaussian(vdiamA*1e-3, uAbsolute(0.02e-3)) # Petit diamètre
diamB = ex.gaussian(vdiamB*1e-3, uAbsolute(0.02e-3)) # Grand diamètre
deltaL = ex.gaussian(cdeltaL, uAbsolute(0.5e-3)) # Pas de mesure

**eyquem** · 09/09/2008, 13h29

1- Tu pourrais avantageusement, je crois, remplacer

Code :

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

1
2
3
4
5
6
7
8
if valFdeb > valFfin :
    print u'La fréquence de départ est supérieure à la fréquence de fin'
    print ' donc le programme inverse les deux fréquences.'
    valStartF = valFfin
    valStopF = valFdeb
else :
    valStartF = valFdeb
    valStopF = valFfin

par

Code :

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

valStartF,valStopF = sorted( [valFdeb, valFfin] )

Je crois qu'il y a une autre façon de faire, avec une fonction spécialement destinée à trouver min et max dans une liste directement par une seule instruction, mais je ne l'ai pas retrouvée, et je ne suis pas mécontent de ma petite trouvaille...

2-

Code :

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

1
2
3
print   
# même résultat que
print ""

Pour ajouter une ligne vide, il suffit aussi d'ajouter \n:

Code :

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

print u'La fréquence en cours est :', f, u'Hz\n'

3- Tu peux remplacer

Code :

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

1
2
3
4
5
6
7
8
9
10
11
diamAFile = open(filePetitDiam,'r')
diamBFile = open(fileGrandDiam,'r')
 
diamAListe = diamAFile.readlines() 
listeDiamA = map(float,diamAListe)
 
diamBListe = diamBFile.readlines() 
listeDiamB = map(float,diamBListe)
 
for vdiamA,vdiamB in zip(listeDiamA,listeDiamB):
    ....instructions....

par

Code :

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

1
2
3
4
5
diamAFile = open(filePetitDiam,'r')
diamBFile = open(fileGrandDiam,'r')
Z = zip( [ float(x) for diamAFile ] , [float(x) for x in diamBFile ] )
for vdiamA,vdiamB in  Z:
    ....instructions....

4- Ça marche même encore si on écrit

Code :

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

1
2
3
Z = zip( [ float(x) for open(filePetitDiam,'r') ] , [float(x) for x in open(fileGrandDiam,'r') ] )
for vdiamA,vdiamB in Z:
....instructions....

la concision Python, c'est dingue !

mais ça ne me plait pas car dans ce cas je ne sais pas comment on peut fermer les objets-fichiers open(filePetitDiam,'r') et open(fileGrandDiam,'r') qui ont été ouverts.

D'ailleurs, soit dit en passant, dans ton code il y a
diamAFile = open(filePetitDiam,'r') qui ouvre filePetitDiam
mais il manque l'instruction
diamAFile.close() qui le ferme.

5-

Code :

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

1
2
3
4
5
diamAFile = open(filePetitDiam,'r')
diamBFile = open(fileGrandDiam,'r')
Z = zip( [ float(x) for diamAFile ] , [float(x) for x in diamBFile ] )
for vdiamA,vdiamB in Z:
    ....instructions....

c'est utilisable si les fichiers filePetitDiam et fileGrandDiam ne sont pas trop grands.
Si deux fichiers A et B sont grands au point de trop pomper sur la ressource RAM, il faudrait écrire:

Code :

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

1
2
3
4
5
6
7
f = open(A,'r')
g = open(B,'r')
a,b = 'go','go'
while a!=''and b!='':
    a,b = f.readline(),g.readline()
    vdiamA,vdiamB = float(a),float(b)
    ...instructions...

6- En réalité, ton code est:

Code :

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

1
2
3
4
5
6
7
8
diamAFile = open(filePetitDiam,'r')
diamBFile = open(fileGrandDiam,'r')
....instructions....
for f in gammeF:
    ind = numpy.matrix([[1,0],[0,1]])
    matprec = ind
    for vdiamA,vdiamB in zip(listeDiamA,listeDiamB):
        ....instructions....

C'est à dire qu'il me semble que la liste zip(listeDiamA,listeDiamB) est recréée pour chaque valeur de f.
Il vaudrait mieux définir zipliste = zip(listeDiamA,listeDiamB) avant d'entrer dans le bouclage sur les valeurs f,
puis boucler avec for vdiamA,vdiamB in zipliste: après l'instruction for f in gammeF:

7- Il y a la même imperfection avec des valeurs de constantes qui sont répétitivement réaffectées à chaque tour de boucle vdiamA,vdiamB:

Code :

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

1
2
3
4
5
6
7
    c = 299792458 # Célérité
    mu = ex.constant(4*pi*1e-7) # Perméabilité
    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é
    w = 2*pi*f              #pulsation
    Zref = 50

Ça fait travailler '125 x nombre de valeurs f ' fois le programme à écrire 7 constantes, qui pourraient être définies une fois pour toutes avant le bouclage sur f.

8- Dans le même esprit, j'écrirais personnellement

Code :

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

1
2
3
vtemp = d0*(1-k**2*a**2*F0/2)
R =   2*w*L0* vtemp)     #résistance linéique
L = L0*( 1+2* vtemp)  )   #inductance linéique

ou peut être mieux:

Code :

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

1
2
3
4
5
kacarre = k**2*a**2
R = 2*w*L0*d0*(1-   kacarre   *F0/2)     #résistance linéique
L = L0*(1+2*d0*(1-  kacarre   *F0/2))   #inductance linéique
G = w*C0*d0*    kacarre      *F0             #conductance linéique
C = C0*(1+d0*   kacarre      *F0)           #capacité linéique

et

Code :

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

1
2
3
4
x =  (R+  ((L*w)*1j))
y = (G+((C*w)*1j))
Zc =        sqrt( x  /  y ) 
gamma = sqrt( x  *  y )

Mais je ne suis pas sûr que ça change beaucoup la vitesse d'exécution. Il faut voir.

Lenteur du programme puis plantage

Python

Vue hybride

Discussions similaires

Partager

Partager