1 #@ MODIF lire_fonction_ops Macro DATE 30/11/2004 AUTEUR MCOURTOI M.COURTOIS
2 # -*- coding: iso-8859-1 -*-
3 # CONFIGURATION MANAGEMENT OF EDF VERSION
4 # ======================================================================
5 # COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG
6 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
7 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
8 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
9 # (AT YOUR OPTION) ANY LATER VERSION.
11 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
12 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
13 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
14 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
16 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
17 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
18 # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
19 # ======================================================================
21 import string,os,Numeric
23 # ------------------------------------------------------------------------------
24 def m_format_libre(texte,INDIC_PARA,INDIC_RESU,SEPAR):
25 """Méthode de construction du VALE pour le format libre
27 Les lignes contenant autre chose que des séquences de nombres
28 réels et de séparateurs sont considérées comme délimitant deux
29 fonctions différentes. Cette situation correspond à l exception
30 ValueError levée par le map de float. Le deuxieme indice de
31 INDIC_PARA et INDIC_RESU est l indice permettant de pointer sur la
32 fonction voulue, au sens de ce découpage.
35 from Utilitai.transpose import transpose
39 if SEPAR=='None' : SEPAR=None
42 if string.strip(line)=='' : raise ValueError
43 fonc.append(map(float,string.split(line,SEPAR)))
45 if fonc==[] : pass # dans ce cas, on a plusieurs lignes délimitant 2 fonctions
47 l_fonc.append(Numeric.array(fonc))
50 l_fonc.append(Numeric.array(fonc))
52 # vérifications de cohérences lignes et colonnes
53 ind_para=[INDIC_PARA[0]-1,INDIC_PARA[1]-1]
54 ind_resu=[INDIC_RESU[0]-1,INDIC_RESU[1]-1]
55 if INDIC_PARA[0]>len(l_fonc) :
57 message= "<F> <LIRE_FONCTION> INDIC_PARA :le nombre de blocs de fonctions dans "
58 message=message+"le fichier est inférieur à "+str(INDIC_PARA[0])
60 if INDIC_RESU[0]>len(l_fonc) :
62 message= "<F> <LIRE_FONCTION> INDIC_RESU :le nombre de blocs de fonctions dans "
63 message=message+"le fichier est inférieur à "+str(INDIC_RESU[0])
65 if INDIC_PARA[1]>len(l_fonc[ind_para[0]]) :
67 message= "<F> <LIRE_FONCTION> INDIC_PARA :la fonction numéro "
68 message=message+str(INDIC_PARA[0])
69 message=message+" ne comporte que "+str(l_fonc[INDIC_PARA[0]])+" colonnes"
71 if INDIC_RESU[1]>len(l_fonc[ind_resu[0]]) :
73 message= "<F> <LIRE_FONCTION> INDIC_RESU :la fonction numéro "
74 message=message+str(INDIC_RESU[0])
75 message=message+" ne comporte que "+str(l_fonc[INDIC_RESU[0]])+" colonnes"
78 # construction du VALE de la fonction par recherche des indices
79 # de colonnes et de fonctions dans le tableau l_fonc
80 vale_1=l_fonc[ind_para[0]][:,ind_para[1]]
81 vale_2=l_fonc[ind_resu[0]][:,ind_resu[1]]
82 if len(vale_1)!=len(vale_2) :
84 message= "<F> <LIRE_FONCTION> INDIC_RESU :les deux colonnes demandées "
85 message=message+" pour INDIC_PARA et INDIC_RESU n ont pas la meme longueur :"
86 message=message+str(len(vale_1))+" et "+str(len(vale_2))
88 liste_vale=transpose([vale_1,vale_2])
89 def add(x,y):return x+y
90 liste_vale=reduce(add,liste_vale)
91 return ier,'',liste_vale
93 # ------------------------------------------------------------------------------
94 def liste_simple(texte,INDIC_PARA,SEPAR):
95 """recherche d'une liste simple
103 if SEPAR=='None' : SEPAR=None
106 if string.strip(line)=='' : raise ValueError
107 fonc.append(map(float,string.split(line,SEPAR)))
109 if fonc==[] : pass # dans ce cas, on a plusieurs lignes délimitant 2 fonctions
111 l_fonc.append(Numeric.array(fonc))
114 l_fonc.append(Numeric.array(fonc))
116 # vérifications de cohérences lignes et colonnes
117 ind_para=[INDIC_PARA[0]-1,INDIC_PARA[1]-1]
118 if INDIC_PARA[0]>len(l_fonc) :
120 message= "<F> <LIRE_FONCTION> INDIC_PARA :le nombre de blocs de fonctions dans "
121 message=message+"le fichier est inférieur à "+str(INDIC_PARA[0])
122 return ier,message,[]
123 if INDIC_PARA[1]>len(l_fonc[ind_para[0]]) :
125 message= "<F> <LIRE_FONCTION> INDIC_PARA :la fonction numéro "
126 message=message+str(INDIC_PARA[0])
127 message=message+" ne comporte que "+str(l_fonc[INDIC_PARA[0]])+" colonnes"
128 self.cr.fatal(message)
129 return ier,message,[]
131 # construction du VALE de la fonction par recherche des indices
132 # de colonnes et de fonctions dans le tableau l_fonc
133 vale_1=l_fonc[ind_para[0]][:,ind_para[1]]
134 return ier,'',vale_1.tolist()
136 # ------------------------------------------------------------------------------
137 def lire_fonction_ops(self,FORMAT,TYPE,SEPAR,INDIC_PARA,UNITE,
138 NOM_PARA,NOM_RESU,INTERPOL,PROL_DROITE,
139 PROL_GAUCHE,VERIF,INFO,TITRE,**args):
140 """Méthode corps de la macro
145 # On recopie le mot cle defi_fonction pour le proteger
147 mc_DEFI_FONCTION=args['DEFI_FONCTION']
149 # On importe les definitions des commandes a utiliser dans la macro
150 DEFI_FONCTION =self.get_cmd('DEFI_FONCTION')
151 DEFI_NAPPE =self.get_cmd('DEFI_NAPPE')
153 # La macro compte pour 1 dans la numerotation des commandes
156 # Lecture de la fonction dans un fichier d unité logique UNITE
158 file="./fort."+str(UNITE)
159 if not os.path.isfile(file) :
161 self.cr.fatal("<F> <LIRE_FONCTION> le fichier d unité logique "+str(UNITE)+" est introuvable")
164 texte=file.readlines()
167 self.DeclareOut('ut_fonc',self.sd)
170 # mise en forme de la liste de valeurs suivant le format choisi :
171 ier,message,liste_vale=m_format_libre(texte,INDIC_PARA,args['INDIC_RESU'],SEPAR)
173 self.cr.fatal(message)
176 # création de la fonction ASTER :
177 ut_fonc=DEFI_FONCTION( NOM_PARA =NOM_PARA,
179 PROL_DROITE=PROL_DROITE,
180 PROL_GAUCHE=PROL_GAUCHE,
187 elif TYPE=='FONCTION_C':
188 # mise en forme de la liste de valeurs suivant le format choisi :
189 if 'INDIC_REEL' in args :
190 indic1=args['INDIC_REEL']
191 indic2=args['INDIC_IMAG']
192 if 'INDIC_MODU' in args :
193 indic1=args['INDIC_MODU']
194 indic2=args['INDIC_PHAS']
195 ier,message,liste_vale_r=m_format_libre(texte,INDIC_PARA,indic1,SEPAR)
197 self.cr.fatal(message)
199 ier,message,liste_vale_i=m_format_libre(texte,INDIC_PARA,indic2,SEPAR)
201 self.cr.fatal(message)
204 if 'INDIC_REEL' in args :
205 for i in range(len(liste_vale_r)/2) :
206 liste=liste+[liste_vale_r[2*i],liste_vale_r[2*i+1],liste_vale_i[2*i+1]]
207 elif 'INDIC_MODU' in args :
208 for i in range(len(liste_vale_r)/2) :
209 module=liste_vale_r[2*i+1]
210 phase =liste_vale_i[2*i+1]
211 liste=liste+[liste_vale_r[2*i],module*cos(phase),module*sin(phase)]
213 # création de la fonction ASTER :
214 ut_fonc=DEFI_FONCTION( NOM_PARA =NOM_PARA,
216 PROL_DROITE=PROL_DROITE,
217 PROL_GAUCHE=PROL_GAUCHE,
226 # création de la nappe ASTER :
228 motscles['DEFI_FONCTION']=[]
229 for elem in mc_DEFI_FONCTION:
230 ier,message,liste_vale=m_format_libre(texte,args['INDIC_ABSCISSE'],elem['INDIC_RESU'],SEPAR)
232 self.cr.fatal(message)
234 motscles['DEFI_FONCTION'].append( _F( VALE =liste_vale,
235 INTERPOL =args['INTERPOL_FONC'],
236 PROL_DROITE=args['PROL_DROITE_FONC'],
237 PROL_GAUCHE=args['PROL_GAUCHE_FONC'] ) )
238 ier,message,liste_para=liste_simple(texte,INDIC_PARA,SEPAR)
240 self.cr.fatal(message)
242 ut_fonc=DEFI_NAPPE( PARA =liste_para,
244 NOM_PARA_FONC =args['NOM_PARA_FONC'],
246 PROL_DROITE =PROL_DROITE,
247 PROL_GAUCHE =PROL_GAUCHE,