Lenteur du programme puis plantage

**bourgui78** · 16/09/2008, 11h22

oui je vais regarder cette fonction de plus près, pour la saturation de la ram, pour la bécane, en fait au bout de 20 minutes de calcul le pc ferme le prog...

mais merci pour toute ton aide

Patricia

**BebeFoetus** · 16/09/2008, 21h35

Salut bourgui78,

J'ai regardé un peu ton prog et c'est festival.

1.

oui je vais regarder cette fonction de plus près, pour la saturation de la ram, pour la bécane, en fait au bout de 20 minutes de calcul le pc ferme le prog...

En général, ça résulte d'une tentative d'écriture ou d'accès à une portion de RAM non autorisée : l'OS ferme l'application fautive.
C'est peut-être ta lib GUM qui est bugguée.

2.
Question juste comme ça, est-ce que tu as fait toutes les modifs que eyquem t'a suggérées ?
Un retour serait le bienvenu, vu le temps qu'il a dû passer à t'aider.
Ça permettrait également d'y voir plus clair.

3.
Ce qui me chagrine dans ton code c'est que tu crées des variables à tire-larigot. Je ne sais pas trop ce qu'elles contiennent ni combien de mémoire elles occupent, mais si tu dupliques des variables de plusieurs dizaines de Mo (ou plus) à tout va, à un moment ça risque de coincer.

Un exemple :

Code :

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

1
2
3
4
 
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

Il serait peut-être plus judicieux de faire :

Code :

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

1
2
 
ABCD *= numpy.matrix([[A,B],[C,D]]) #Création de la matrice ABCD d'un élément de la ligne

Et c'est comme ça un peu partout dans le code. Quand c'est pour un souci de lisibilité, passe encore, mais de là à créer des variables inutiles...

Autre exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
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

Faire :

Code :

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

1
2
3
4
5
6
7
8
 
#-----------------------------------------------------------------------------------------
# Calcul des valeurs de la matrice S
#-----------------------------------------------------------------------------------------
matS11 = Scoef * (Bfinal-Cfinal*Zref*Zref+Afinal*Zref-Dfinal*Zref)
matS12 = Scoef * (2*Zref*(Afinal*Dfinal-Bfinal*Cfinal))
matS21 = Scoef * (2*Zref)
matS22 = Scoef * (Bfinal-Cfinal*Zref*Zref-Afinal*Zref+Dfinal*Zref)

Essaie de simplifier toi-même ce programme, eyquem t'a déjà donné beaucoup de pistes.

4.
J'ai regardé tes autres posts. Apparemment ils ont à peu près tous rapport avec ce programme que tu développes. Dans l'un d'eux, pacificator t'avait suggéré d'éviter au possible les « from module import * » et de les remplacer par « import module as gum », ce qu'apparemment tu n'as pas tenu compte. Il faudrait penser à y passer : une de tes variables entre peut-être en conflit avec ce module.

Voilà, j'espère que tu trouveras la soluce.
++

**eyquem** · 16/09/2008, 23h27

Je lui ai déjà signalé la complication des lignes de code suivantes :

Code :

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

1
2
3
4
5
6
7
A = cosh(coef)
B = sinh(coef)*Zc
C = sinh(coef)/Zc
D = cosh(coef)
ABCDprec = numpy.matrix([[A,B],[C,D]])
ABCD = matprec*ABCDprec
matprec = ABCD

Je lui ai proposé (message #13, en 4):

Code :

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

1
2
3
A = cosh(coef)
S = sinh(coef)
matprec = matprec*numpy.matrix(  [  [A , S*Zc] , [ S/Zc , A] ] )

Mais ta proposition avec ABCD est bien mieux

Code :

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

ABCD = ABCD * numpy.matrix([[A,B],[C,D]])

C'est vrai que c'est beaucoup plus logique d'appeler ABCD la variable dont on calcule une nouvelle valeur plutôt que matprec. C'est ce qui est avant le signe = qui prime dans une vision dynamique d'un programme qui AVANCE, pas la valeur antérieure.

J'ai mis un moment à comprendre la notation. Je n'avais pas réalisé qu'il y avait la même chose possible avec * qu'avec +

Pour bourgui:

la notation n += 3 condense n = n + 3.
De même p *= z condense p = p*z
et ABCD *= numpy.matrix([[A,B],[C,D]]) condense ABCD = ABCD * numpy.matrix([[A,B],[C,D]])

C'est vrai qu'on aimerait un peu de retour.
Au bout du compte, j'espère qu'on aura un diagnostic clair de la cause du problème, pas une vague annonce du genre "ça marche"

Pour moi, c'est le module GUM qui n'est pas utilisé correctement dans le cadre de ton programme.

**BebeFoetus** · 17/09/2008, 04h30

Envoyé par eyquem

J'ai mis un moment à comprendre la notation. Je n'avais pas réalisé qu'il y avait la même chose possible avec * qu'avec +

En même temps, il y en a un paquet des affectations augmentées.
Certaines, je ne sais même pas comment m'en servir.

-> http://docs.python.org/ref/delimiters.html

**bourgui78** · 17/09/2008, 10h35

j'essaie tout ce que vous me proposez après je vous dis ce qu'il en est.
Mon pb actuel est le temps... j'ai des réunions et j'ai pas le temps de réécrire.

Aujourd'hui promis je prends le temps et vous fais un topo ce soir

j'ai noté aussi un point qui me prenait du temps, c'était que le programme était enregistré sur le serveur central, et en mettant tout sur le DD du pc, j'utilise bcp moins de mémoire, mais toujours beaucoup tout de même.
Je vais aussi limité les affichages.

@+ tard pour plus de retour

PAtricia

**bourgui78** · 18/09/2008, 09h57

grâce à vos propositions j'ai réussi à améliorer le programme dans le sens j'arrive à faire le calcul avec comme nombre de ligne de fichier de diamètre égale à 125. faut que je vérifie si pour 300 points voire au-delà ça marche toujours.
Par contre je n'ai pas pu faire le code suivant

Code :

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

ABCD *=  numpy.matrix([[Cos,Sin*Zc],[Sin/Zc,Cos]])

car j'avais des erreurs type buffer ???
par contre en écrivant cela :

Code :

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

ABCD = ABCD * numpy.matrix([[Cos,Sin*Zc],[Sin/Zc,Cos]])

ça fonctionne

j'ai essayé on m'avait conseillé pour l'importation des modules, mais je n'ai pas généralisé au GUM... j'essaie demain.

Alors le calcul marche parfaitement en ayant diminué le nombre de viariabble (je vous mets le code dans le post suivant), mais par contre j'ai un plantage quand je demande à écrire les résultats dans mon fichier texte.

Code :

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

1
2
3
4
5
6
7
8
9
10
 
#-----------------------------------------------------------------------------------------
  # 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)

faut peut-être que je fasse autrement, je vais me pencher dessus.

le programme sans l'enregistrement des résultats de ma matrice S met 5 minutes : pour 180 fréquences et 125 diamètres.

Patricia

**bourgui78** · 18/09/2008, 10h15

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
#!/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
#-------------------------------------------------------------------------
# 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")
 
  app.title('Choix des fichiers')
  app.mainloop()
 
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 ""

Les conditions de mesure :

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
 
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)
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)
    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 :
    valStartF = valFfin
    valStopF = valFdeb
else :
    valStartF = valFdeb
    valStopF = valFfin
 
nbMesure = int(((valStopF-valStartF)/valFpas)) + 1

Le code général:

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
 
#---------------------------------------------------------------
#       Constantes
#---------------------------------------------------------------
mu = ex.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é
Zref = 50
 
nomcol = ""
valcol = ""
nomcol = 'Fréquence en Hz' + "\t" + 'Matrice S11' + "\t" + 'Matrice S12' + "\t" + 'Matrice S21' + "\t" + 'Matrice S22' + "\n"
matSFile.write(nomcol)
#-------------------------------------------------------------------------
# Calcul des caractéristiques d'une ligne à air
# avec pertes en fonction de la fréquence
#-------------------------------------------------------------------------
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 vdiamA,vdiamB in zip(listeDiamA,listeDiamB):    
 
    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
    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
    #----------------------------------------------------------------------
    k = w*sqrt(L0*C0)      #nombre d'onde angulaire
    d1 = 2*rho/w/mu
    d2 = sqrt(d1)
    ds = sqrt(2*rho/w/mu)   #épaisseur de peau
    d0 = ds*(1+r)/(4*b*log(r))
    R = 2*w*L0*d0*(1-k**2*a**2*F0/2)     #résistance linéique
    L = L0*(1+2*d0*(1-k**2*a**2*F0/2))   #inductance linéique
    G = w*C0*d0*k**2*a**2*F0             #conductance linéique
    C = C0*(1+d0*k**2*a**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]+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)

Voilà, maintenant je m'attaque àl'enregistrement des données dans un fichier texte.

Merci encore pour tous vos conseils

@+

PAtricia

**eyquem** · 18/09/2008, 10h45

Après coup, j'y avais pensé que

Code :

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

ABCD *=  numpy.matrix([[Cos,Sin*Zc],[Sin/Zc,Cos]])

risquait de ne pas marcher tout simplement parce que *= ne serait pas valable dans des calculs de matrice. Les calculs sur matrice se font dans le cadre du module numpy et ce que tu rapportes confirme que la notation *= n'a pas dû être prévue dans ce module.

**bourgui78** · 18/09/2008, 10h50

je comprends mieux pourquoi ça marchait pas.

Merci encore

Patricia

**eyquem** · 18/09/2008, 15h14

Patricia,

J'ai écrit trop de choses, j'ai noyé le poisson.

Ainsi dans mon message #6, partie 5- ,
j'ai indiqué comment extraire les données d'un fichier en les lisant progressivement pour les traiter au fur et à mesure qu'on les lit.
Je n'aurais pas dû, ça parasite l'essentiel.

En effet,
il y a une PREMIÈRE façon de faire qui n'est pas toujours employable:
extraire d'abord toutes les données d'un fichier en le lisant d'abord d'un seul coup pour les mettre dans une variable de type string ou liste avant de commencer à les traiter;
mais
cette façon n'est pas utilisable si le fichier à exploiter est très très volumineux car la variable réceptrice des données, qui est créée dans la RAM consomme alors une part importante de cette RAM.

J'indiquais donc une AUTRE façon de procéder (lecture des données progressive) mais à titre informatif seulement, en passant. Je n'ai pas voulu dire qu'il fallait que tu procèdes à une lecture progressive de tes fichiers filePetitDiam et fileGrandDiam.
Tu as cependant essayé cette méthode, rencontrant un problème parce que mon code était mal écrit, ce que j'ai corrigé dans mon message #11, mais ça a été un détour sans utilité immédiate.

Ceci dit, oublie donc maintenant cette autre méthode de lecture progressive.
En réalité, tu as 2 fichiers filePetitDiam et fileGrandDiam qui ne sont pas très grands puisqu'ils contiennent chacun seulement 125 valeurs.
Je trouve mieux de lire d'abord ces deux fichiers d'un coup.

Mais ça ne veut pas dire que ton code initial doit être conservé tel quel comme il réapparait dans ton dernier message.

Je maintiens qu'il est de beaucoup préférable de faire ce que j'ai écrit dans le message #6 partie 3- .
Non seulement ce sera plus concis mais en plus ça permet de faire ce que je décris dans le message #6 partie 6-.

Avec ton code inchangé, tu obliges le programme à refaire une création de liste avec

Code :

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

zip(listeDiamA,listeDiamB)

POUR CHAQUE COUPLE vdiamA,vdiamB , soit 125 fois pour une valeur f, et 125*180 fois pour l'ensemble des opérations. C'est vraiment alourdir pour rien.

Changer pour le code suivant devrait améliorer encore grandement la performance de ton programme:

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')
Z = zip( [ float(x) for diamAFile ] , [float(x) for x in diamBFile ] )
diamAFile.close()
diamBFile.close()
for f in gammeF:
    ABCD = numpy.matrix([[1,0],[0,1]])
    for vdiamA,vdiamB in Z:
        ....instructions....
        ABCD = ABCD * numpy.matrix([[Cos,Sin*Zc],[Sin/Zc,Cos]])
    ....instructions....

Voilà, cette fois, j'espère que c'est clair.

**N.tox** · 19/09/2008, 20h36

Je ne connais pas vraiment le module psyco, et ne sais pas si il fonctionnerait avec les matrices, toutefois j'ai lu que pour les opérations mathématiques, psyco pouvait accélérer le calcul jusqu'à au moins 10 fois, donc si tu trouve que ton prog va toujours pas assez vite, tu peux regarder de ce côté...

(et plus précisément la fonction bind)

**bourgui78** · 22/09/2008, 15h34

je regarde ce qui en est avec les matrices

Patricia

**bourgui78** · 22/09/2008, 16h27

Donc j'ai fait les dernières modif, et en effet la boucle va un peu mieux, et au final je suis contente aussi car j'ai réussi à ne pas refaire une nouvelle boucle pour la partie min, max, moyenne.
Mon code ressemble à cela :

Code :

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

1
2
3
4
5
6
7
diamAFile = open(filePetitDiam,'r')
diamBFile = open(fileGrandDiam,'r')
ListeX = [ float(x) for x in diamAFile ]
ListeY = [ float(y) for y in diamBFile ]
Z = zip( ListeX , ListeY )
diamAFile.close()
diamBFile.close()

j'ai gardé les listes listeX et listeY car pour mes extremum j'en avais besoin (jusqu'au jour où je trouverai mieux encore)
car la partie extremum ressemble à cela :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
minDiamA = min(ListeX)
maxDiamA = max(ListeX)
moyDiamA = sum(ListeX)/len(ListeX)
minDiamB = min(ListeY)
maxDiamB = max(ListeY)
moyDiamB = sum(ListeY)/len(ListeY)
listeExtDiamA = [minDiamA, moyDiamA, maxDiamA]
listeExtDiamB = [minDiamB, moyDiamB, maxDiamB]
gamStopF = valStopF + valFpas # gamme (début, fin(valeur non atteinte, pas)
gammeF = range(int(valStartF),int(gamStopF),int(valFpas))
for f in gammeF :
  w = 2*pi*f              #pulsation
  for varExtDiamA, varExtDiamB in zip(listeExtDiamA, listeExtDiamB):
      ... instructions

Voilà pour les dernières info, je continue à améliorer...

Patricia

**bourgui78** · 22/09/2008, 16h30

Bonjour,

Ben je ne sais pas ce qui s'est passé ce WE, mais pour ma part, par l'opération du Saint-Esprit, le programme tourne avec le stockage... lentement certe, mais surement !
et j'ai rien modifié, ni le prog, ni le PC

je ne comprends rien à rien... enfin c'est le côté binaire de l'informatique, je pense

Merci encore à tous pour votre aide

PAtricia

**N.tox** · 22/09/2008, 17h57

Tu peux raccourcir, ce passage :

Code :

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

1
2
3
4
5
6
7
8
9
 
minDiamA = min(ListeX)
maxDiamA = max(ListeX)
moyDiamA = sum(ListeX)/len(ListeX)
minDiamB = min(ListeY)
maxDiamB = max(ListeY)
moyDiamB = sum(ListeY)/len(ListeY)
listeExtDiamA = [minDiamA, moyDiamA, maxDiamA]
listeExtDiamB = [minDiamB, moyDiamB, maxDiamB]

Entre autres, de cette façon:

Code :

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

1
2
listeExtDiamA = [min(ListeX), max(ListeX), sum(ListeX)/len(ListeX)]
listeExtDiamB = [min(ListeY), max(ListeY), sum(ListeY)/len(ListeY)]

voir même:

Code :

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

listeExtDiamA,listeExtDiamB=[eval('[min(Liste%s), max(Liste%s), sum(Liste%s)/len(Liste%s)]'%tuple([XY]*4))for XY in 'XY')]

Et si listeExtA et B ne sont pas par la suite utilisés ailleurs que dans

Code :

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

1
2
3
for varExtDiamA, varExtDiamB in zip(listeExtDiamA, listeExtDiamB):
      ... instructions

Alors, on peut même directement ziper les deux listes en une seule:

Code :

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

1
2
for varExtDiamA, varExtDiamB in [zip(a,b) for a,b in [[eval('[min(Liste%s), max(Liste%s), sum(Liste%s)/len(Liste%s)]'%tuple([XY]*4))for XY in 'XY')]] ][0]:
     ...instructions...

par contre si gain de vitesse d'execution il y a, cela reste minime, et le code est moins lisible...

pour info, eval(string) évalue la chaine de caractères passée en paramètre en tant qu'expression, ex:

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
>>> x=128
>>> a=eval('58+96+%i'%x)
>>> a
282
#mais l'exemple suivant ne fonctionnera pas:
>>> eval('b=30')
 
Traceback (most recent call last):
  File "<pyshell#17>", line 1, in <module>
    eval('b=30')
  File "<string>", line 1
    b=30
     ^
SyntaxError: invalid syntax
#parceque 'b=30' n'est pas une expression, pour executer cette chaine de caractères, il aurait fallu utiliser exec(string):
>>> exec('b=30')
>>> b
30

**BebeFoetus** · 23/09/2008, 01h35

re bourgui78,

J'ai lu tes derniers bouts de code (post#27) et voici quelques remarques :

1.
Tu peux encore simplifier ton code, en réunissant les variables :
- a et b dans r (pour calculer R, L, G, C tu utiliseras diamA/2)
- F1 et F2 dans F0
- ds dans d0
- gamma dans coef
Vues qu'elles ne sont utilisées qu'une unique fois (et de plus, dans la ligne qui suit directement)

2.
Comme l'a déjà dit eyquem : calculer k**2 au lieu de k

3.
Ainsi qu'en supprimant les variables : Z0, d1, d2
D'ailleurs elles servent à quoi ces 3 variables ? Je te soupçonne d'avoir sorti ton cours de physique et d'avoir voulu calculer « scolairement » toutes les formules.

4.
Maintenant que ton programme fonctionne, ce que tu peux faire c'est créer des fonctions. Ça devrait te permettre d'économiser encore de la mémoire et surtout de sectionner le code en plusieurs sous-parties pour améliorer la lisibilité.
Tu devrais remplacer par exemple tout le corps de la boucle « for vdiamA,vdiamB in zip(listeDiamA,listeDiamB): » par une fonction, ex: « ABCD = ABCD * calcMatrice(vdiamA, vdiamB) » (puisqu'au final c'est la seule valeur utilisée), créer une fonction qui calcule coef, etc.

5.
Au lieu de « os.remove(directMatS) » + « matSFile = open(directMatS,'a') »,
les remplacer par « matSFile = open(directMatS,'w') »
L'indication 'w' efface le fichier (s'il existe) et en crée un nouveau.
Elle te permet aussi de virer les instruction try...except

6.
Pour optimiser encore tout ça, tu peux essayer d'utiliser les générateurs ou le module itertools. Par contre je ne pourrais pas t'aider sur ce point, je connais la théorie mais je n'ai pas encore pratiqué. Toutefois, je pense qu'ils devraient t'être très utile dans ton cas.

7.
Et désolé, pour mon « ABCD *= numpy.matrix... » qui ne fontionne pas.
Pour ma décharge, je ne connais pas numpy.

**bourgui78** · 23/09/2008, 09h26

Merci de tes conseils BebeFoetus, mais je suis obligée de calculer Z0, Gamma... etc car ce sont des données dont j'ai besoin pour "qualifier" mes lignes à air. En théorie une ligne à air sans perte a une impédance caractéristique de 50 ohm, mais en réalisté j'ai Z0... etc.

Pour a et b et r oui effectivement je peux essayer cela, je regarde.

Tu me parle de simplifier en créant des fonctions, ou bien des classes ? ça j'ai toujours pas essayé, mais faut bien que je m'y mette effectivement.

Pour info mon prog tourne toujours sur une bécane, ça fait 14 heures, et je n'en suis qu'à la moitié de mes 180 fréquences... ce qui ralentit c'est exectement le stockage en fichier texte.

Merci aussi pour N.Tox pour tes pistes pour le calcul de mes extrema, ça va me simplifiait egalement la vie, et effectivement je ne vais peut-être pas mettre ta dernière proposition car à la relecture, je risque de me tirer les cheveux

merci encore

Patricia

**BebeFoetus** · 23/09/2008, 12h10

Envoyé par bourgui78

Merci de tes conseils BebeFoetus, mais je suis obligée de calculer Z0, Gamma... etc car ce sont des données dont j'ai besoin pour "qualifier" mes lignes à air. En théorie une ligne à air sans perte a une impédance caractéristique de 50 ohm, mais en réalisté j'ai Z0... etc.

Code :

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

1
2
Z0 = sqrt(L0/C0) # Impédance Z0
k = w*sqrt(L0*C0)      #nombre d'onde angulaire

Je n'avais pas vu ça. Tu as besoin de Z0 pour avoir k, mais tu le recalcules dans k.
En fait, je t'ai proposé de les supprimer parce qu'elles n'étaient pas utilisées dans les morceaux de codes que tu as publiés (je suppose que ton programme figure ici en entier).

Envoyé par bourgui78

Tu me parle de simplifier en créant des fonctions, ou bien des classes ? ça j'ai toujours pas essayé, mais faut bien que je m'y mette effectivement.

Oui des fonctions. Du genre :
(attention, je n'ai pas vérifié la validité de ce qui suis, ce n'est qu'un 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
def calc_Zc_coef(F0, L0, C0, k, a) :
    """Fonction qui calcule Zc et coef"""
    ds = sqrt(2*rho/w/mu)                        #épaisseur de peau
    d0 = ds*(1+r)/(4*b*log(r))
    R = 2*w*L0*d0*(1-k**2*a**2*F0/2)             #résistance linéique
    L = L0*(1+2*d0*(1-k**2*a**2*F0/2))           #inductance linéique
    G = w*C0*d0*k**2*a**2*F0                     #conductance linéique
    C = C0*(1+d0*k**2*a**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
    coef = gamma*deltaL
    return Zc, coef
 
Zc, coef = calc_Zc_coef(F0, L0, C0, k, a)

Ça te permettra de détruire tes variables intermédiaires et de libérer la mémoire.
En contre-partie les variables « ds, d0, R, L, C, G, gamma » ne seront plus disponibles en dehors de la fonction.
A toi de voir quelles sont les variables intermédiaires que tu peux supprimer sans scrupule.

Pour les classes, je ne sais pas vraiment ce que tu peux gagner à les utiliser; à part travailler dans le même espace de nom pour tes variables.
Mais comme je suis novice en POO, attends plutôt un conseil de quelqu'un de plus expérimenté.

**bourgui78** · 23/09/2008, 15h00

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
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
#!/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
import time
 
#try : import psyco ; psyco.full()
#except : full
 
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
# 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='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
#------------------------------------------------------------------------------------
matSFile = open(directMatS,'w')
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
# 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')
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)
    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'
t=time.clock()#Temps de départ du calcul du programme
#---------------------------------------------------------------
#       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.'
 
#---------------------------------------------------------------
#       Constantes
#---------------------------------------------------------------
mu = ex.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é
Zref = 50
#------------------------------------------------------------------------------------
#Mise en page du fichier d'enregistrement des données de la matrice S de la ligne
#------------------------------------------------------------------------------------
nomdiamcol = ""
valdiamcol = ""
nomdiamcol = 'Petit diamètre (mm)' + "\t" + 'Grand diamètre (mm)' + "\t" + 'Impédance Z0' + "\n"
matSFile.write(nomdiamcol)
for vdiamA, vdiamB in Z :
  #------------------------------------------------------------------------------------
  # 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 pour chaque diamètre
  # et enregistrement de ces données dans le fichier d'enregistrement
  #------------------------------------------------------------------------------------
  F0 = (((diamB/diamA)**2-1)/(2*log(diamB/diamA)))-((diamB/diamA)*log(diamB/diamA)/((diamB/diamA)+1))-0.5*((diamB/diamA)+1)#F1-F2-0.5*diamB/diamA
  L0 = mu*log(diamB/diamA)/2/pi # Inductance linéique sans perte
  C0 = 2*pi*E/log(diamB/diamA) # Capacité linéique sans perte
  Z0 = sqrt(L0/C0) # 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)
#------------------------------------------------------------------------------------
# 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
#------------------------------------------------------------------------------------
nomExtcol = ""
nomExtFreqcol = ""
valExtcol = ""
#listeExtDiamA = [min(ListeA), sum(ListeA)/len(ListeA), max(ListeA)]
#listeExtDiamB = [min(ListeB), sum(ListeB)/len(ListeB), max(ListeB)]
gamStopF = valStopF + valFpas # gamme (début, fin(valeur non atteinte, pas)
gammeF = range(int(valStartF),int(gamStopF),int(valFpas))
for f in gammeF :
  w = 2*pi*f              #pulsation
  nomExtFreqcol = 'Fréquence (Hz)' + "\t" + str(value(f)) + "\n"
  matSFile.write(nomExtFreqcol)
  nomExtcol = 'Valeur petit diamètre (mm)' + "\t" + 'Valeur grand diamètre (mm)' + "\t" \
              + 'Impédance caractéristique Zc' + "\t" + 'Gamma G' + "\n"
  matSFile.write(nomExtcol)
  for varExtDiamA, varExtDiamB in zip([min(ListeA), sum(ListeA)/len(ListeA), max(ListeA)], [min(ListeB), sum(ListeB)/len(ListeB), max(ListeB)]):
    diamA = ex.gaussian(varExtDiamA*1e-3, uAbsolute(0.02e-3))
    diamB = ex.gaussian(varExtDiamB*1e-3, uAbsolute(0.02e-3))
    #------------------------------------------------------------------------------------
    # Calcul des caractéristiques d'une ligne à air sans pertes
    #------------------------------------------------------------------------------------
    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 # Inductance linéique sans perte
    C0 = 2*pi*E/log(diamB/diamA) # 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/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
    valExtcol = str(value(varExtDiamA)) + "\t" + str(value(varExtDiamB)) + "\t" + str(value(Zc)) \
                + str(numpy.array2string(numpy.array(ex.uncertainty(Zc)).ravel()))+ "\t"+ str(value(gamma)) \
                + str(numpy.array2string(numpy.array(ex.uncertainty(gamma)).ravel())) + "\n"
    matSFile.write(valExtcol)
#------------------------------------------------------------------------------------
# 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)
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------
# 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 vdiamA,vdiamB in Z :    
    #------------------------------------------------------------------------------------
    # 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
    #------------------------------------------------------------------------------------
    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 # Inductance linéique sans perte
    C0 = 2*pi*E/log(diamB/diamA) # 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/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*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]+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()
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()

Bien sûr j'ai pas intégré les fonctions que j'essaie de mettre en place.

voilà je continue, mais pour info ce qui me prenais du temps dans le stockage des données étaient le calcul intégré à la fonction écriture dans le fichier... en intégrant des variables avant l'écriture dans le fichier, je gagne 30% du temps

donc pour 100 boucles de diamètres et 180 fréquences, je passe 39h et 22 minutes à 30h

y a encore de la marge je pense

Merci encore

Patricia

**N.tox** · 24/09/2008, 00h43

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
#---------------------------------------------------------------
#       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.'

Ici, tu peux remplacer les variables valFdeb, et valFfin directement par valStartF et valStoptF, les deux premières n'étant utilisée qu'une seule fois après leur création, c'est gacher de l'espace memoire... Une fois cela fait, deux méthode pour arriver presque au même résultat (l'important reste le même...):
1) Python possède une fonction bien utile pour cela, c'est abs() (diminutif de... absolute !

), donc on peut supprimer la condition, et modifier nbMesure de la façon suivante:

Code :

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

1
2
3
4
5
nbMesure = int((abs(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.'

2) Et l'autre méthode mois radine en lignes de code, et avec une plus de chance de cohérance dans la série de print (la fréquence de départ affichée sera toujours la plus petite...):

Code :

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

1
2
3
4
5
6
7
if valStartF>valStopF: valStopF,valStartF= valStartF,valStopF
 
nbMesure = int(((valStopF-valFdeb)/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.'

Ensuite, comme l'a dit BebeFoetus, crées des fonctions, ça te permettera en plus, d'éventuellement pouvoir utiliser psyco pour les fonctions qui executent plein de calcul, par exemple remplacer ce bout de code là:

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
for varExtDiamA, varExtDiamB in zip([min(ListeA), sum(ListeA)/len(ListeA), max(ListeA)], [min(ListeB), sum(ListeB)/len(ListeB), max(ListeB)]):
    diamA = ex.gaussian(varExtDiamA*1e-3, uAbsolute(0.02e-3))
    diamB = ex.gaussian(varExtDiamB*1e-3, uAbsolute(0.02e-3))
    #------------------------------------------------------------------------------------
    # Calcul des caractéristiques d'une ligne à air sans pertes
    #------------------------------------------------------------------------------------
    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 # Inductance linéique sans perte
    C0 = 2*pi*E/log(diamB/diamA) # 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/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
    valExtcol = str(value(varExtDiamA)) + "\t" + str(value(varExtDiamB)) + "\t" + str(value(Zc)) \
                + str(numpy.array2string(numpy.array(ex.uncertainty(Zc)).ravel()))+ "\t"+ str(value(gamma)) \
                + str(numpy.array2string(numpy.array(ex.uncertainty(gamma)).ravel())) + "\n"

par une fonction que tu defini juste après tes imports au debut du programme :

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
import psyco
def function(varExtDiamA,varExtDiamB):
    global mu,pi,E,rho,w
    diamA = ex.gaussian(varExtDiamA*1e-3, uAbsolute(0.02e-3))
    diamB = ex.gaussian(varExtDiamB*1e-3, uAbsolute(0.02e-3))
    #------------------------------------------------------------------------------------
    # Calcul des caractéristiques d'une ligne à air sans pertes
    #------------------------------------------------------------------------------------
    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 # Inductance linéique sans perte
    C0 = 2*pi*E/log(diamB/diamA) # 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/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
    valExtcol = str(value(varExtDiamA)) + "\t" + str(value(varExtDiamB)) + "\t" + str(value(Zc)) \
                + str(numpy.array2string(numpy.array(ex.uncertainty(Zc)).ravel()))+ "\t"+ str(value(gamma)) \
                + str(numpy.array2string(numpy.array(ex.uncertainty(gamma)).ravel())) + "\n"
    return valExtcol
psyco.bind(function)

Cette fonction (je l'ai pas test...) retounera une chaîne de caractère, puisque y'a plein de variables dont tu ne te servira plus par la suite, ou bien que tu redéfinieras avant de t'en reservir... ensuite ton acien bloc de code donnera :

Code :

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

1
2
3
4
5
6
7
valExtcol=''
for varExtDiamA, varExtDiamB in zip([min(ListeA), sum(ListeA)/len(ListeA), max(ListeA)], [min(ListeB), sum(ListeB)/len(ListeB), max(ListeB)]):
    valExtcol+=function(varExtDiamA,varExtDiamB)
    if len(valExtcol)>200000:
        matSFile.write(valExtcol)
        valExtcol=''
if valExtcol!='': matSFile.write(valExtcol)

Tu auras remarqué que j'ai défini valExtcol avant la boucle for, et que par la suite je l'agrandie jusqu'a ce que la chaîne atteigne une certaine taille, et c'est à ce moment là que je l'écris, c'est pour eviter d'avoir un accès au disque trop souvent... grossièrement, un caractère fait un octet, donc 200 000, 200ko, donc à toi de voir la taille qui te parait raisonnable... y'aura éventuellement quelque erreurs à corriger dans la fonction, son nom à redefinir, des globales à ajouter, ah oui, les global dans une fonction servent à dire quelle variables viennent de l'exterieur de la fonction... et si enfin, les fonctions utilisés dans la fonction écrites sont supportées par psyco, alors ça devrait déjà faire un bon gain de temps...

PS: psyco est un module à installer...
http://psyco.sourceforge.net/

EDIT: print bouffe pas mal de temps, donc pourquoi ne pas les remplacer par chaines à écrire dans une fichier log, ou bien redirigé la sortie dans un fichier ? Par contre il peut y avoir des problèmes avec les accents, ce qui se résoudrait le plus rapidement par un remplacement des caractères acentué par leur équivalent non-accentué

Lenteur du programme puis plantage

Python

Discussions similaires

Partager

Partager