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