Discussion :

[bourgui78]

Bonjour,
j'ai un petit problème d'écriture de données en temps réel dans un fichier.
En effet j'utilise deux boucles for imbriquées pour un calcul, et à la fin de la 1ère boucle, j'ai écrit l'instruction d'écrire dans mon fichier

Code :

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

1
2
3
4
5
6
7
 
for nF in range(0,len(ListeF)) :
   .....
  for nAB in range(1,len(AB1)):
        .....
  valcol = ....
  matSFile.write(valcol)

or ça écrit, si j'ai bien compris, dans une mémoire tampon, et à la fin de mon programme (sortie des deux boucles) ça va aller écrire dans le fichier... et comme j'ai un problème demémoire, mon programme plante et rien est enregistré

Pouvez-vous me dire comment faire pour résoudre cela ?
Je vous en remercie par avance

Patricia

[pfeuh]

Salut,

Il faut probablement rajouter un flush après chaque écriture si tu veux sauver tes données avant que le tampon soit rempli.

Code :

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

1
2
3
4
5
6
7
8
for nF in range(0,len(ListeF)) :
   .....
  for nAB in range(1,len(AB1)):
        .....
  valcol = ....
  matSFile.write(valcol)
  matSFile.flush()

A+

Pfeuh

[bourgui78]

à mon pb, effectivement ça a écrit dans le fichier... avant le plantage
je continue à chercher,
est-ce que le module cPickle pourrait m'aider ?

merci encore

Patricia

[pfeuh]

est-ce que le module cPickle pourrait m'aider ?

Ne connaissant pas ton problème, je dirais que non. Il n'est pas dans les 4 lignes que tu as postées. La méthode légère pour déboguer est de mettre des print partout, la méthode plus professionnelle est d'utiliser un environnement professionnel, comme par exemple PyDev + Eclipse. Mais il faut être conscient que tu risques de passer des heures juste pour mettre l'environnement en place. A ta place, j'essaierais les print. Ou alors poste un peu plus de code... Un code minimal (c'est à dire qui se lance avec un simple copier-coller + invocation de python) qui reproduit le bug.

A+

Pfeuh

[bourgui78]

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
for nF in range(0,len(ListeF)) :
  FreqVal = ListeF[nF]
  valF = float(FreqVal)*1e9
  w = 2*pi*valF              # Pulsation
  print u'La fréquence en cours est :', valF, 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]])
    # ------------------------------------------------------------------------------------
  #     Calcul de la matrice ABCD du premier tronçon
  # ------------------------------------------------------------------------------------
  nAB =0
  ABCD = ABCD
  deltaL = elementary(0, incdeltaL) # Pas de mesure du premier tronçon
  #------------------------------------------------------------------------------------
  #       Calcul des caractéristiques d'une ligne à air sans pertes
  #------------------------------------------------------------------------------------
  F0 = (((diamB[nAB]/diamA[nAB])**2-1)/(2*log(diamB[nAB]/diamA[nAB])))-((diamB[nAB]/diamA[nAB])*log(diamB[nAB]/diamA[nAB])/((diamB[nAB]/diamA[nAB])+1))-0.5*((diamB[nAB]/diamA[nAB])+1)
  L0 = mu*log(diamB[nAB]/diamA[nAB])/2/pi # Inductance linéique sans perte
  C0 = 2*pi*E/log(diamB[nAB]/diamA[nAB]) # 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+(diamB[nAB]/diamA[nAB]))/(4*(diamB[nAB]/2)*log(diamB[nAB]/diamA[nAB]))
  R = 2*w*L0*d0*(1-k2*(diamA[nAB]/2)**2*F0/2)     # Résistance linéique
  L = L0*(1+2*d0*(1-k2*(diamA[nAB]/2)**2*F0/2))   # Inductance linéique
  G = w*C0*d0*k2*(diamA[nAB]/2)**2*F0             # Conductance linéique
  C = C0*(1+d0*k2*(diamA[nAB]/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*deltaL
  Cos = cosh(coef)
  Sin = sinh(coef)
  ABCD = ABCD * numpy.matrix([[Cos,Sin*Zref],[Sin/Zref,Cos]]) # Création de la matrice ABCD d'un élément de la ligne ([A,B],[C,D]) - pour le point 0
 
    # ------------------------------------------------------------------------------------
    #       Boucle à partir des données extraites des fichiers (calculs en fonction des diamètres)
    # ------------------------------------------------------------------------------------
 
  for nAB in range(1,len(AB)):
    ABCD=ABCD
    deltaL = elementary(cdeltaL, incdeltaL) # Pas de mesure
    #------------------------------------------------------------------------------------
    #       Calcul des caractéristiques d'une ligne à air sans pertes
    #------------------------------------------------------------------------------------
    F0 = (((diamB[nAB]/diamA[nAB])**2-1)/(2*log(diamB[nAB]/diamA[nAB])))-((diamB[nAB]/diamA[nAB])*log(diamB[nAB]/diamA[nAB])/((diamB[nAB]/diamA[nAB])+1))-0.5*((diamB[nAB]/diamA[nAB])+1)
    L0 = mu*log(diamB[nAB]/diamA[nAB])/2/pi # Inductance linéique sans perte
    C0 = 2*pi*E/log(diamB[nAB]/diamA[nAB]) # 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+(diamB[nAB]/diamA[nAB]))/(4*(diamB[nAB]/2)*log(diamB[nAB]/diamA[nAB]))
    R = 2*w*L0*d0*(1-k2*(diamA[nAB]/2)**2*F0/2)     # Résistance linéique
    L = L0*(1+2*d0*(1-k2*(diamA[nAB]/2)**2*F0/2))   # Inductance linéique
    G = w*C0*d0*k2*(diamA[nAB]/2)**2*F0             # Conductance linéique
    C = C0*(1+d0*k2*(diamA[nAB]/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*deltaL
    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]+Zref*Zref*ABCD[1,0])+(Zref*ABCD[0,0]+Zref*ABCD[1,1]))
  #-----------------------------------------------------------------------------------------
  #       Calcul des valeurs de la matrice S
  #-----------------------------------------------------------------------------------------
  matS11 =(Scoef*(ABCD[0,1]-Zref*Zref*ABCD[1,0]+Zref*ABCD[0,0]-Zref*ABCD[1,1]))
  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]-Zref*Zref*ABCD[1,0]-Zref*ABCD[0,0]+Zref*ABCD[1,1])
  #-----------------------------------------------------------------------------------------
  #       Formatage de l'écriture en sortie des valeurs d'incertitude
  #-----------------------------------------------------------------------------------------
  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 dans le fichier d'enregistrement des données
  #-----------------------------------------------------------------------------------------
  valcol = str(valF) + "\t" + \
           str(value(matS11)) + "\t" + str(tabIncmatS11) + "\t" + \
           str(value(matS12))  + "\t" + str(tabIncmatS12) + "\t" + \
           str(value(matS21))  + "\t" + str(tabIncmatS21) + "\t" + \
           str(value(matS22))  +  "\t" + str(tabIncmatS22) + "\n"
  matSFile.write(valcol)

Avec AB allant jusqu'à 1250 (si AB = 900 mon programme fonctionne)

Voici ce que me donne python :

Code :

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

1
2
3
    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])
  File "C:\Python27\lib\site-packages\numpy\matrixlib\defmatrix.py", line 330, in __mul__
MemoryError

je ne peux pas en donner plus car... c'est mon boulot
Merci encore

[pfeuh]

je ne peux pas en donner plus car... c'est mon boulot

Je n'en veux pas plus, j'aimerai juste quelque chose qui reproduise le bug... Après avoir bataillé 5 minutes et rajouté les lignes suivantes en début de ton code, j'ai abandonné... Un code qui reproduise le bug est le minimum pour t'aider... Tu peux même enlever les commentaires, pas de problème...

A+

Pfeuh

Code :

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

1
2
3
4
5
6
7
#!/usr/bin/python
# -*- coding: 1252 -*-
 
import numpy
 
ListeF = [1.0, 2.0, 3.0]
pi = 3.14

[wiztricks]

Salut,
Pas le temps de lire votre code pour voir comment minimiser l'encombrement mémoire des arrays numpy. Ceci dit, à la sortie de la boucle interne, on a

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
  Scoef = 1/((ABCD[0,1]+Zref*Zref*ABCD[1,0])+(Zref*ABCD[0,0]+Zref*ABCD[1,1]))
  #-----------------------------------------------------------------------------------------
  #       Calcul des valeurs de la matrice S
  #-----------------------------------------------------------------------------------------
  matS11 =(Scoef*(ABCD[0,1]-Zref*Zref*ABCD[1,0]+Zref*ABCD[0,0]-Zref*ABCD[1,1]))
  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]-Zref*Zref*ABCD[1,0]-Zref*ABCD[0,0]+Zref*ABCD[1,1])
  #-----------------------------------------------------------------------------------------
  #       Formatage de l'écriture en sortie des valeurs d'incertitude
  #-----------------------------------------------------------------------------------------
  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 dans le fichier d'enregistrement des données
  #-----------------------------------------------------------------------------------------
  valcol = str(valF) + "\t" + \
           str(value(matS11)) + "\t" + str(tabIncmatS11) + "\t" + \
           str(value(matS12))  + "\t" + str(tabIncmatS12) + "\t" + \
           str(value(matS21))  + "\t" + str(tabIncmatS21) + "\t" + \
           str(value(matS22))  +  "\t" + str(tabIncmatS22) + "\n"
  matSFile.write(valcol)

Plutôt que d'occuper la mémoire avec la construction de 2*4 matrices (matSnn et tabIncMatSnn), puis on les écrits sur disque pourquoi ne pas découper cela en construction de (matSnn et tabIncMatSnn), écriture, delete.

Ca donnerait un code du genre:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
  Scoef = 1/((ABCD[0,1]+Zref*Zref*ABCD[1,0])+(Zref*ABCD[0,0]+Zref*ABCD[1,1]))
 
  matSFile.write(str(valF) + "\t")
 
  matS11 =(Scoef*(ABCD[0,1]-Zref*Zref*ABCD[1,0]+Zref*ABCD[0,0]-Zref*ABCD[1,1]))
  tabIncmatS11 = "u(re) =%s, u(im) = %s, r = %s" % as_std_uncertainty( std_covariance(matS11) )
  matSFile.write(str(value(matS11)) + "\t" + str(tabIncmatS11) + "\t")
  del matS11, tabIncmatS11
 
  matS12 =Scoef*(2*Zref*(ABCD[0,0]*ABCD[1,1]-ABCD[0,1]*ABCD[1,0]))
  tabIncmatS12 = "u(re) =%s, u(im) = %s, r = %s" % as_std_uncertainty( std_covariance(matS12) )
  matSFile.write(str(value(matS12))  + "\t" + str(tabIncmatS12) + "\t")
  del matS12, tabIncmatS12
  ...

- W