1 #@ MODIF calc_fonction_ops Macro DATE 03/10/2007 AUTEUR SALMONA L.SALMONA
2 # -*- coding: iso-8859-1 -*-
3 # CONFIGURATION MANAGEMENT OF EDF VERSION
4 # ======================================================================
5 # COPYRIGHT (C) 1991 - 2005 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 # ======================================================================
26 # -----------------------------------------------------------------------------
28 if arg[0]=='RI' : return complex(arg[1],arg[2])
29 if arg[0]=='MP' : return complex(arg[1]*cos(arg[2]),arg[1]*sin(arg[2]))
32 # -----------------------------------------------------------------------------
33 def calc_fonction_ops(self,FFT,DERIVE,INTEGRE,LISS_ENVELOP,
34 SPEC_OSCI,ABS,COMB,COMB_C,COMPOSE,EXTRACTION,
35 ENVELOPPE,ASSE,CORR_ACCE,PUISSANCE,INVERSE,
36 NOM_PARA,NOM_RESU,INTERPOL,PROL_DROITE,
37 PROL_GAUCHE,NOM_PARA_FONC,INTERPOL_FONC,PROL_DROITE_FONC,
38 PROL_GAUCHE_FONC,INFO,**args):
40 Ecriture de la macro CALC_FONCTION
43 from Utilitai.t_fonction import t_fonction, t_fonction_c, t_nappe, homo_support_nappe, \
44 FonctionError, ParametreError, InterpolationError, ProlongementError
45 from Utilitai import liss_enveloppe
47 from Cata.cata import nappe_sdaster,fonction_sdaster,fonction_c
48 from Utilitai.Utmess import UTMESS
49 from Numeric import alltrue,less,array,reshape,cos,sin,exp,sqrt
50 from Numeric import choose,zeros,Float
51 import aster_fonctions
52 EnumTypes = (list, tuple)
54 ### On importe les definitions des commandes a utiliser dans la macro
55 DEFI_FONCTION = self.get_cmd('DEFI_FONCTION')
56 IMPR_FONCTION = self.get_cmd('IMPR_FONCTION')
57 DEFI_NAPPE = self.get_cmd('DEFI_NAPPE')
59 ### Comptage commandes + déclaration concept sortant
61 self.DeclareOut('C_out',self.sd)
63 # éléments de contexte
65 ### l'ensemble est dans un try/except pour recuperer les erreurs du module t_fonction
69 __ff=INTEGRE['FONCTION'].convert()
71 if INTEGRE['METHODE']=='TRAPEZE' :
72 __ex=__ff.trapeze(INTEGRE['COEF'])
73 elif INTEGRE['METHODE']=='SIMPSON' :
74 __ex=__ff.simpson(INTEGRE['COEF'])
77 __ff=DERIVE['FONCTION'].convert()
82 __ff=INVERSE['FONCTION'].convert()
87 __ff=ABS['FONCTION'].convert()
92 __ff=COMPOSE['FONC_RESU'].convert()
93 __fg=COMPOSE['FONC_PARA'].convert()
94 ctxt.f = [__ff.nom, __fg.nom]
98 __f0=ASSE['FONCTION'][0].convert()
99 __f1=ASSE['FONCTION'][1].convert()
100 ctxt.f = [__f0.nom, __f1.nom]
101 __ex=__f0.cat(__f1,ASSE['SURCHARGE'])
105 if isinstance(self.sd,nappe_sdaster):
107 list_fonc.append(mcfact['FONCTION'].convert())
108 ctxt.f = [f.nom for f in list_fonc]
109 list_fonc = homo_support_nappe(list_fonc)
110 elif isinstance(self.sd,fonction_sdaster):
112 __ex=mcfact['FONCTION'].convert()
113 list_fonc.append(__ex)
116 for item, comb in zip(list_fonc, COMB):
118 __ex = item * comb['COEF'] + __ex
119 # on prend les paramètres de la 1ère fonction
120 __ex.para = copy.copy(list_fonc[0].para)
124 if isinstance(self.sd,nappe_sdaster):
125 for mcfact in COMB_C:
126 list_fonc.append(mcfact['FONCTION'].convert())
127 ctxt.f = [f.nom for f in list_fonc]
128 list_fonc = homo_support_nappe(list_fonc)
129 elif isinstance(self.sd,fonction_sdaster) or isinstance(self.sd,fonction_c):
130 for mcfact in COMB_C :
131 __ex=mcfact['FONCTION'].convert(arg='complex')
132 list_fonc.append(__ex)
135 for item, comb in zip(list_fonc, COMB_C):
136 if comb['COEF_R'] != None:
137 coef = complex(comb['COEF_R'])
138 elif comb['COEF_C'] != None:
139 if type(comb['COEF_C']) in EnumTypes:
140 coef = tocomplex(comb['COEF_C'])
142 coef = comb['COEF_C']
144 __ex = item * coef + __ex
145 # on prend les paramètres de la 1ère fonction
146 __ex.para = copy.copy(list_fonc[0].para)
148 ### mot clé LIST_PARA uniquement présent si COMB ou COMB_C
149 if (COMB != None) or (COMB_C != None) :
150 if (args['LIST_PARA'] != None) :
151 __ex=__ex.evalfonc(args['LIST_PARA'].Valeurs())
153 if (PUISSANCE != None):
154 __ff=PUISSANCE['FONCTION'].convert()
157 for i in range(PUISSANCE['EXPOSANT']-1):
160 if (EXTRACTION != None):
161 if EXTRACTION['PARTIE']=='REEL':
162 __ex=EXTRACTION['FONCTION'].convert(arg='real')
163 if EXTRACTION['PARTIE']=='IMAG':
164 __ex=EXTRACTION['FONCTION'].convert(arg='imag')
165 if EXTRACTION['PARTIE']=='MODULE':
166 __ex=EXTRACTION['FONCTION'].convert(arg='modul')
167 if EXTRACTION['PARTIE']=='PHASE':
168 __ex=EXTRACTION['FONCTION'].convert(arg='phase')
170 if (ENVELOPPE != None):
172 l_env=ENVELOPPE['FONCTION']
173 if type(l_env) not in EnumTypes:
175 if isinstance(self.sd,nappe_sdaster):
177 list_fonc.append(f.convert())
178 ctxt.f = [f.nom for f in list_fonc]
179 list_fonc = homo_support_nappe(list_fonc)
180 vale_para=list_fonc[0].vale_para
181 para =list_fonc[0].para
183 for i in range(len(vale_para)):
184 __ff=list_fonc[0].l_fonc[i]
185 for nap in list_fonc[1:] :
186 ctxt.f = nap.l_fonc[i].nom
187 __ff=__ff.enveloppe(nap.l_fonc[i], ENVELOPPE['CRITERE'])
188 l_fonc_f.append(__ff)
189 __ex=t_nappe(vale_para,l_fonc_f,para)
190 elif isinstance(self.sd,fonction_sdaster):
192 list_fonc.append(f.convert())
194 for f in list_fonc[1:]:
195 ctxt.f = [__ex.nom, f.nom]
196 __ex = __ex.enveloppe(f, ENVELOPPE['CRITERE'])
198 if (CORR_ACCE != None):
199 __ex=CORR_ACCE['FONCTION'].convert()
201 para=copy.copy(__ex.para)
202 # suppression de la tendance de l accelero
203 __ex=__ex.suppr_tend()
204 # calcul de la vitesse
205 __ex=__ex.trapeze(0.)
206 # calcul de la tendance de la vitesse : y = a1*x +a0
207 __ex=__ex.suppr_tend()
208 if CORR_ACCE['CORR_DEPL']=='OUI':
209 # suppression de la tendance deplacement
210 # calcul du deplacement : integration
211 __ex=__ex.trapeze(0.)
212 # calcul de la tendance du déplacement : y = a1*x +a0
213 __ex=__ex.suppr_tend()
214 # regeneration de la vitesse : derivation
216 # regeneration de l accelero : derivation
221 if isinstance(self.sd,fonction_c):
222 __ff=FFT['FONCTION'].convert()
224 __ex=__ff.fft(FFT['METHODE'])
225 if isinstance(self.sd,fonction_sdaster):
226 __ff=FFT['FONCTION'].convert(arg='complex')
228 __ex=__ff.fft(FFT['METHODE'],FFT['SYME'])
230 if (SPEC_OSCI != None):
231 if SPEC_OSCI['AMOR_REDUIT']==None:
232 l_amor=[0.02, 0.05, 0.1]
233 UTMESS('I','CALC_FONCTION',' : génération par défaut de 3 amortissements :'+str(l_amor))
235 if type(SPEC_OSCI['AMOR_REDUIT']) not in EnumTypes :
236 l_amor=[SPEC_OSCI['AMOR_REDUIT'],]
238 l_amor= SPEC_OSCI['AMOR_REDUIT']
239 if SPEC_OSCI['FREQ']==None and SPEC_OSCI['LIST_FREQ']==None:
242 l_freq.append( 0.2+0.050*i)
244 l_freq.append( 3.0+0.075*i)
246 l_freq.append( 3.6+0.100*i)
248 l_freq.append( 5.0+0.125*i)
250 l_freq.append( 8.0+0.250*i)
252 l_freq.append(15.0+0.500*i)
254 l_freq.append(18.0+1.000*i)
256 l_freq.append(22.0+1.500*i)
258 for i in range(len(l_freq)/5) :
259 texte.append(' %f %f %f %f %f' %tuple(l_freq[i*5:i*5+5]))
260 UTMESS('I','CALC_FONCTION',' : génération par défaut de 150 fréquences :\n'+'\n'.join(texte))
261 elif SPEC_OSCI['LIST_FREQ']!=None:
262 l_freq=SPEC_OSCI['LIST_FREQ'].Valeurs()
263 elif SPEC_OSCI['FREQ']!=None:
264 if type(SPEC_OSCI['FREQ']) not in EnumTypes:
265 l_freq=[SPEC_OSCI['FREQ'],]
267 l_freq= SPEC_OSCI['FREQ']
268 if min(l_freq)<1.E-10 :
269 UTMESS('S','CALC_FONCTION','Les fréquences doivent etre strictement positives.')
270 if abs(SPEC_OSCI['NORME'])<1.E-10 :
271 UTMESS('S','CALC_FONCTION',' : SPEC_OSCI, la norme ne peut etre nulle')
272 if SPEC_OSCI['NATURE_FONC']!='ACCE' :
273 UTMESS('S','CALC_FONCTION',' : SPEC_OSCI, le type de la fonction doit etre ACCE')
274 if SPEC_OSCI['METHODE']!='NIGAM' :
275 UTMESS('S','CALC_FONCTION',' : SPEC_OSCI, seule la méthode NIGAM est codée')
279 UTMESS('S','CALC_FONCTION',' : SPEC_OSCI, la méthode choisie '\
280 'suppose des amortissements sous-critiques, amor<1.')
282 __ff=SPEC_OSCI['FONCTION'].convert()
286 spectr = aster_fonctions.SPEC_OSCI(__ff.vale_x, __ff.vale_y, l_freq, l_amor)
288 # construction de la nappe
290 para = { 'INTERPOL' : ['LIN','LOG'],
291 'NOM_PARA_FONC' : 'FREQ',
293 'PROL_DROITE' : 'EXCLU',
294 'PROL_GAUCHE' : 'EXCLU',
295 'NOM_RESU' : SPEC_OSCI['NATURE'] }
296 para_fonc = { 'INTERPOL' : ['LOG','LOG'],
298 'PROL_DROITE' : 'CONSTANT',
299 'PROL_GAUCHE' : 'EXCLU',
300 'NOM_RESU' : SPEC_OSCI['NATURE'] }
301 if SPEC_OSCI['NATURE']=='DEPL':
303 elif SPEC_OSCI['NATURE']=='VITE':
308 for iamor in range(len(l_amor)) :
309 l_fonc.append(t_fonction(l_freq,spectr[iamor,ideb,:]/SPEC_OSCI['NORME'],para_fonc))
310 __ex=t_nappe(vale_para,l_fonc,para)
312 if (LISS_ENVELOP!= None):
313 __ff=LISS_ENVELOP['NAPPE'].convert()
314 sp_nappe=liss_enveloppe.nappe(listFreq=__ff.l_fonc[0].vale_x, listeTable=[f.vale_y for f in __ff.l_fonc], listAmor=__ff.vale_para, entete="")
315 sp_lisse=liss_enveloppe.lissage(nappe=sp_nappe,fmin=LISS_ENVELOP['FREQ_MIN'],fmax=LISS_ENVELOP['FREQ_MAX'],elarg=LISS_ENVELOP['ELARG'],tole_liss=LISS_ENVELOP['TOLE_LISS'])
316 para_fonc=__ff.l_fonc[0].para
318 for val in sp_lisse.listTable:
319 l_fonc.append(t_fonction(sp_lisse.listFreq,val,para_fonc))
320 __ex=t_nappe(vale_para=sp_lisse.listAmor,l_fonc=l_fonc,para=__ff.para)
322 except InterpolationError, msg:
323 UTMESS('F', 'CALC_FONCTION', 'Un problème d interpolation a été rencontré'+ctxt.f+'Vérifier les valeurs fournies derrière'+
324 'le mot-clé INTERPOL lors de la création de cette(ces) fonction(s). Debug '+str(msg))
325 except ParametreError, msg:
326 UTMESS('F', 'CALC_FONCTION', 'Un problème concernant le nom des abscisses ou ordonnées a été rencontré'+ctxt.f+
327 'Vérifier la valeur fournie derrière les mots-clés NOM_PARA/NOM_RESU lors de la création de cette(ces) fonction(s).'+
329 except ProlongementError, msg:
330 UTMESS('F', 'CALC_FONCTION','Un problème concernant le prolongement de la (des) fonction(s) a été rencontré.'+ctxt.f+
331 'Vérifier la valeur fournie derrière les mots-clés PROL_GAUCHE/PROL_DROITE lors de la création de cette(ces) fonction(s)'+
333 except FonctionError, msg:
334 UTMESS('F', 'CALC_FONCTION', 'Une erreur s est produite lors de l opération'+ctxt.f+'Debug :'+str(msg)+
335 'Remontée d erreur (pour aider a l analyse) :'+traceback.format_exc())
337 ### creation de la fonction produite par appel à DEFI_FONCTION
338 ### on récupère les paramètres issus du calcul de __ex
339 ### et on les surcharge par ceux imposés par l'utilisateur
341 if isinstance(__ex,t_fonction) or isinstance(__ex,t_fonction_c):
343 if NOM_PARA !=None : para['NOM_PARA'] =NOM_PARA
344 if NOM_RESU !=None : para['NOM_RESU'] =NOM_RESU
345 if PROL_DROITE!=None : para['PROL_DROITE']=PROL_DROITE
346 if PROL_GAUCHE!=None : para['PROL_GAUCHE']=PROL_GAUCHE
347 if INTERPOL !=None : para['INTERPOL'] =INTERPOL
348 if isinstance(__ex,t_fonction_c): para['VALE_C'] = __ex.tabul()
349 elif isinstance(__ex,t_fonction) : para['VALE'] = __ex.tabul()
350 C_out=DEFI_FONCTION(**para)
351 elif isinstance(__ex,t_nappe):
353 for f in __ex.l_fonc :
355 def_fonc.append(_F(VALE =f.tabul(),
356 INTERPOL =f.para['INTERPOL'],
357 PROL_DROITE=f.para['PROL_DROITE'],
358 PROL_GAUCHE=f.para['PROL_GAUCHE'],))
360 if NOM_PARA !=None : para['NOM_PARA'] =NOM_PARA
361 if NOM_RESU !=None : para['NOM_RESU'] =NOM_RESU
362 if PROL_DROITE !=None : para['PROL_DROITE']=PROL_DROITE
363 if PROL_GAUCHE !=None : para['PROL_GAUCHE']=PROL_GAUCHE
364 if NOM_PARA_FONC !=None : para['NOM_PARA_FONC'] =INTERPOL
365 if INTERPOL_FONC !=None : para['INTERPOL'] =INTERPOL
366 C_out=DEFI_NAPPE(PARA=__ex.vale_para.tolist(),DEFI_FONCTION=def_fonc,**para)
368 IMPR_FONCTION(FORMAT='TABLEAU',
370 COURBE=_F(FONCTION=C_out),)
374 # -----------------------------------------------------------------------------
375 class Context(object):
376 """Permet de stocker des éléments de contexte pour aider au
377 diagnostic lors de l'émission de message.
387 """Retourne le texte formatté.
390 if type(nomf) not in (list, tuple):
396 res = """Fonction%(s)s concernée%(s)s : %(nomf)s""" % {
398 'nomf' : ', '.join(nomf),
401 res = 'erreur de programmation !'
404 def set_val(self, value):
410 f = property(get_val, set_val, del_val, "")