1 #@ MODIF co_fonction SD DATE 22/04/2008 AUTEUR COURTOIS M.COURTOIS
2 # -*- coding: iso-8859-1 -*-
3 # CONFIGURATION MANAGEMENT OF EDF VERSION
4 # ======================================================================
5 # COPYRIGHT (C) 1991 - 2007 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 # ======================================================================
23 from sd_fonction import sd_fonction_aster
29 # -----------------------------------------------------------------------------
31 class fonction_class(ASSD):
36 Retourne un dictionnaire contenant les parametres de la fonction ;
37 le type jeveux (FONCTION, FONCT_C, NAPPE) n'est pas retourne,
38 le dictionnaire peut ainsi etre fourni a CALC_FONC_INTERP tel quel.
40 from Utilitai.Utmess import UTMESS
41 if not self.par_lot():
42 TypeProl={'E':'EXCLU', 'L':'LINEAIRE', 'C':'CONSTANT' }
43 objev = '%-19s.PROL' % self.get_name()
44 prol = aster.getvectjev(objev)
46 UTMESS('F', 'SDVERI_2', valk=[objev])
48 'INTERPOL' : [prol[1][0:3],prol[1][4:7]],
49 'NOM_PARA' : prol[2][0:16].strip(),
50 'NOM_RESU' : prol[3][0:16].strip(),
51 'PROL_DROITE' : TypeProl[prol[4][1]],
52 'PROL_GAUCHE' : TypeProl[prol[4][0]],
54 elif hasattr(self,'etape') and self.etape.nom=='DEFI_FONCTION' :
56 'INTERPOL' : self.etape['INTERPOL'],
57 'NOM_PARA' : self.etape['NOM_PARA'],
58 'NOM_RESU' : self.etape['NOM_RESU'],
59 'PROL_DROITE' : self.etape['PROL_DROITE'],
60 'PROL_GAUCHE' : self.etape['PROL_GAUCHE'],
62 if type(dico['INTERPOL']) == tuple:
63 dico['INTERPOL']=list(dico['INTERPOL'])
64 elif type(dico['INTERPOL']) == str:
65 dico['INTERPOL']=[dico['INTERPOL'],]
66 if len(dico['INTERPOL'])==1 :
67 dico['INTERPOL']=dico['INTERPOL']*2
69 raise Accas.AsException("Erreur dans fonction.Parametres en PAR_LOT='OUI'")
71 def Trace(self,FORMAT='TABLEAU',**kargs):
72 """Tracé d'une fonction"""
74 raise Accas.AsException("Erreur dans fonction.Trace en PAR_LOT='OUI'")
75 from Utilitai.Graph import Graph
77 gr.AjoutCourbe(Val=self.Valeurs(),
78 Lab=[self.Parametres()['NOM_PARA'],self.Parametres()['NOM_RESU']],
79 Leg=os.linesep.join(self.TITR.get()) )
80 gr.Trace(FORMAT=FORMAT,**kargs)
82 # -----------------------------------------------------------------------------
83 class fonction_sdaster(fonction_class, sd_fonction_aster):
84 def convert(self,arg='real'):
86 Retourne un objet de la classe t_fonction
87 représentation python de la fonction
89 from Utilitai.t_fonction import t_fonction,t_fonction_c
91 return t_fonction(self.Absc(),
96 return t_fonction_c(self.Absc(),
102 Retourne deux listes de valeurs : abscisses et ordonnees
104 from Utilitai.Utmess import UTMESS
105 if not self.par_lot():
106 vale = '%-19s.VALE' % self.get_name()
107 lbl = aster.getvectjev(vale)
109 UTMESS('F', 'SDVERI_2', valk=[vale])
114 elif hasattr(self, 'etape') and self.etape.nom == 'DEFI_FONCTION' :
115 if self.etape['VALE'] != None:
116 lbl = list(self.etape['VALE'])
118 lx = [lbl[i] for i in range(0,dim,2)]
119 ly = [lbl[i] for i in range(1,dim,2)]
120 elif self.etape['VALE_PARA']!=None:
121 lx = self.etape['VALE_PARA'].Valeurs()
122 ly = self.etape['VALE_FONC'].Valeurs()
124 raise Accas.AsException("Erreur (fonction.Valeurs) : ne fonctionne en " \
125 "PAR_LOT='OUI' que sur des fonctions produites par DEFI_FONCTION " \
126 "dans le jdc courant.")
129 """Retourne la liste des abscisses"""
130 return self.Valeurs()[0]
132 """Retourne la liste des ordonnées"""
133 return self.Valeurs()[1]
134 def __call__(self,val):
135 ### Pour EFICAS : substitution de l'instance de classe
136 ### parametre par sa valeur
137 if isinstance(val, ASSD):
143 # -----------------------------------------------------------------------------
144 class para_sensi(fonction_sdaster):
147 # -----------------------------------------------------------------------------
148 class fonction_c(fonction_class, sd_fonction_aster):
149 def convert(self,arg='real'):
151 Retourne un objet de la classe t_fonction ou t_fonction_c,
152 représentation python de la fonction complexe
154 from Utilitai.t_fonction import t_fonction,t_fonction_c
156 return t_fonction(self.Absc(),
161 return t_fonction(self.Absc(),
166 modul=Numeric.sqrt(Numeric.array(self.Ordo())**2+Numeric.array(self.OrdoImg())**2)
167 return t_fonction(self.Absc(),
172 phase=Numeric.arctan2(Numeric.array(self.OrdoImg()),Numeric.array(self.Ordo()))
174 return t_fonction(self.Absc(),
178 elif arg=='complex' :
179 return t_fonction_c(self.Absc(),
180 map(complex,self.Ordo(),self.OrdoImg()),
185 Retourne trois listes de valeurs : abscisses, parties reelles et imaginaires.
187 from Utilitai.Utmess import UTMESS
188 if not self.par_lot():
189 vale = '%-19s.VALE' % self.get_name()
190 lbl = aster.getvectjev(vale)
192 UTMESS('F', 'SDVERI_2', valk=[vale])
199 lr.append(lbl[dim+2*i])
200 li.append(lbl[dim+2*i+1])
201 elif hasattr(self, 'etape') and self.etape.nom == 'DEFI_FONCTION':
202 lbl=list(self.etape['VALE_C'])
204 lx=[lbl[i] for i in range(0,dim,3)]
205 lr=[lbl[i] for i in range(1,dim,3)]
206 li=[lbl[i] for i in range(2,dim,3)]
208 raise Accas.AsException("Erreur (fonction_c.Valeurs) : ne fonctionne en " \
209 "PAR_LOT='OUI' que sur des fonctions produites par DEFI_FONCTION " \
210 "dans le jdc courant.")
213 """Retourne la liste des abscisses"""
214 return self.Valeurs()[0]
216 """Retourne la liste des parties réelles des ordonnées"""
217 return self.Valeurs()[1]
219 """Retourne la liste des parties imaginaires des ordonnées"""
220 return self.Valeurs()[2]
221 def Trace(self,FORMAT='TABLEAU',**kargs):
222 """Tracé d'une fonction complexe"""
224 raise Accas.AsException("Erreur dans fonction_c.Trace en PAR_LOT='OUI'")
225 from Utilitai.Graph import Graph
226 para = self.Parametres()
228 gr.AjoutCourbe(Val=self.Valeurs(),
229 Lab=[para['NOM_PARA'], '%s_R' % para['NOM_RESU'], '%s_I' % para['NOM_RESU']],
230 Leg=os.linesep.join(self.TITR.get()) )
231 gr.Trace(FORMAT=FORMAT,**kargs)
232 def __call__(self,val):
233 ### Pour EFICAS : substitution de l'instance de classe
234 ### parametre par sa valeur
235 if isinstance(val, ASSD):
238 __ff=self.convert(arg='complex')
241 # -----------------------------------------------------------------------------
242 class nappe_sdaster(fonction_class, sd_fonction_aster):
245 Retourne un objet de la classe t_nappe, représentation python de la nappe
247 from Utilitai.t_fonction import t_fonction,t_nappe
248 para=self.Parametres()
253 para_f={'INTERPOL' : pf['INTERPOL_FONC'],
254 'PROL_DROITE' : pf['PROL_DROITE_FONC'],
255 'PROL_GAUCHE' : pf['PROL_GAUCHE_FONC'],
256 'NOM_PARA' : para[0]['NOM_PARA_FONC'],
257 'NOM_RESU' : para[0]['NOM_RESU'],
259 l_fonc.append(t_fonction(vale[1][i][0],vale[1][i][1],para_f))
261 return t_nappe(vale[0],
267 Retourne la liste des valeurs du parametre,
268 et une liste de couples (abscisses,ordonnees) de chaque fonction.
270 from Utilitai.Utmess import UTMESS
272 raise Accas.AsException("Erreur dans nappe.Valeurs en PAR_LOT='OUI'")
273 nsd = '%-19s' % self.get_name()
274 dicv=aster.getcolljev(nsd+'.VALE')
275 # les cles de dicv sont 1,...,N (indice du parametre)
276 lpar=aster.getvectjev(nsd+'.PARA')
278 UTMESS('F', 'SDVERI_2', valk=[nsd+'.PARA'])
280 for k in range(len(dicv)):
283 lval.append([lbl[0:dim],lbl[dim:2*dim]])
284 return [list(lpar),lval]
285 def Parametres(self):
287 Retourne un dictionnaire contenant les parametres de la nappe,
288 le type jeveux (NAPPE) n'est pas retourne,
289 le dictionnaire peut ainsi etre fourni a CALC_FONC_INTERP tel quel,
290 et une liste de dictionnaire des parametres de chaque fonction.
292 from Utilitai.Utmess import UTMESS
294 raise Accas.AsException("Erreur dans nappe.Parametres en PAR_LOT='OUI'")
295 TypeProl={'E':'EXCLU', 'L':'LINEAIRE', 'C':'CONSTANT' }
296 objev = '%-19s.PROL' % self.get_name()
297 prol=aster.getvectjev(objev)
299 UTMESS('F', 'SDVERI_2', valk=[objev])
301 'INTERPOL' : [prol[1][0:3],prol[1][4:7]],
302 'NOM_PARA' : prol[2][0:16].strip(),
303 'NOM_RESU' : prol[3][0:16].strip(),
304 'PROL_DROITE' : TypeProl[prol[4][1]],
305 'PROL_GAUCHE' : TypeProl[prol[4][0]],
306 'NOM_PARA_FONC' : prol[6][0:4].strip(),
312 'INTERPOL_FONC' : [prol[7+i*2][0:3],prol[7+i*2][4:7]],
313 'PROL_DROITE_FONC' : TypeProl[prol[8+i*2][1]],
314 'PROL_GAUCHE_FONC' : TypeProl[prol[8+i*2][0]],
319 """Retourne la liste des abscisses"""
320 return self.Valeurs()[0]
321 def Trace(self,FORMAT='TABLEAU',**kargs):
322 """Tracé d'une nappe"""
324 raise Accas.AsException("Erreur dans nappe.Trace en PAR_LOT='OUI'")
325 from Utilitai.Graph import Graph
328 dp=self.Parametres()[0]
330 gr.AjoutCourbe(Val=[lx,ly], Lab=[dp['NOM_PARA_FONC'],dp['NOM_RESU']],
331 Leg=os.linesep.join(self.TITR.get()) )
332 gr.Trace(FORMAT=FORMAT,**kargs)