Aster/Cata/cataSTA9/SD/co_fonction.py

   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.
  10 #
  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.
  15 #
  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 # ======================================================================
  20
  21 import Accas
  22 from SD import *
  23 from sd_fonction import sd_fonction_aster
  24
  25 import os
  26 import Numeric
  27 from math import pi
  28
  29 # -----------------------------------------------------------------------------
  30 # types 'fonction' :
  31 class fonction_class(ASSD):
  32    def Valeurs(self):
  33       pass
  34    def Parametres(self):
  35       """
  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.
  39       """
  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)
  45         if prol == None:
  46            UTMESS('F', 'SDVERI_2', valk=[objev])
  47         dico={
  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]],
  53         }
  54       elif hasattr(self,'etape') and self.etape.nom=='DEFI_FONCTION' :
  55         dico={
  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'],
  61         }
  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
  68       else:
  69          raise Accas.AsException("Erreur dans fonction.Parametres en PAR_LOT='OUI'")
  70       return dico
  71    def Trace(self,FORMAT='TABLEAU',**kargs):
  72       """Tracé d'une fonction"""
  73       if self.par_lot() :
  74          raise Accas.AsException("Erreur dans fonction.Trace en PAR_LOT='OUI'")
  75       from Utilitai.Graph import Graph
  76       gr=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)
  81
  82 # -----------------------------------------------------------------------------
  83 class fonction_sdaster(fonction_class, sd_fonction_aster):
  84    def convert(self,arg='real'):
  85       """
  86       Retourne un objet de la classe t_fonction
  87       représentation python de la fonction
  88       """
  89       from Utilitai.t_fonction import t_fonction,t_fonction_c
  90       if arg=='real' :
  91         return t_fonction(self.Absc(),
  92                           self.Ordo(),
  93                           self.Parametres(),
  94                           nom=self.nom)
  95       elif arg=='complex' :
  96         return t_fonction_c(self.Absc(),
  97                             self.Ordo(),
  98                             self.Parametres(),
  99                             nom=self.nom)
 100    def Valeurs(self) :
 101       """
 102       Retourne deux listes de valeurs : abscisses et ordonnees
 103       """
 104       from Utilitai.Utmess import UTMESS
 105       if not self.par_lot():
 106         vale = '%-19s.VALE' % self.get_name()
 107         lbl = aster.getvectjev(vale)
 108         if lbl == None:
 109           UTMESS('F', 'SDVERI_2', valk=[vale])
 110         lbl = list(lbl)
 111         dim = len(lbl)/2
 112         lx = lbl[0:dim]
 113         ly = lbl[dim:2*dim]
 114       elif hasattr(self, 'etape') and self.etape.nom == 'DEFI_FONCTION' :
 115          if self.etape['VALE'] != None:
 116             lbl = list(self.etape['VALE'])
 117             dim = len(lbl)
 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()
 123       else:
 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.")
 127       return [lx, ly]
 128    def Absc(self):
 129       """Retourne la liste des abscisses"""
 130       return self.Valeurs()[0]
 131    def Ordo(self):
 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):
 138          val=val.valeur
 139       ###
 140       __ff=self.convert()
 141       return __ff(val)
 142
 143 # -----------------------------------------------------------------------------
 144 class para_sensi(fonction_sdaster):
 145    pass
 146
 147 # -----------------------------------------------------------------------------
 148 class fonction_c(fonction_class, sd_fonction_aster):
 149    def convert(self,arg='real'):
 150       """
 151       Retourne un objet de la classe t_fonction ou t_fonction_c,
 152       représentation python de la fonction complexe
 153       """
 154       from Utilitai.t_fonction import t_fonction,t_fonction_c
 155       if arg=='real' :
 156         return t_fonction(self.Absc(),
 157                           self.Ordo(),
 158                           self.Parametres(),
 159                           nom=self.nom)
 160       elif arg=='imag' :
 161         return t_fonction(self.Absc(),
 162                           self.OrdoImg(),
 163                           self.Parametres(),
 164                           nom=self.nom)
 165       elif arg=='modul' :
 166         modul=Numeric.sqrt(Numeric.array(self.Ordo())**2+Numeric.array(self.OrdoImg())**2)
 167         return t_fonction(self.Absc(),
 168                           modul,
 169                           self.Parametres(),
 170                           nom=self.nom)
 171       elif arg=='phase' :
 172         phase=Numeric.arctan2(Numeric.array(self.OrdoImg()),Numeric.array(self.Ordo()))
 173         phase=phase*180./pi
 174         return t_fonction(self.Absc(),
 175                           phase,
 176                           self.Parametres(),
 177                           nom=self.nom)
 178       elif arg=='complex' :
 179         return t_fonction_c(self.Absc(),
 180                             map(complex,self.Ordo(),self.OrdoImg()),
 181                             self.Parametres(),
 182                           nom=self.nom)
 183    def Valeurs(self) :
 184       """
 185       Retourne trois listes de valeurs : abscisses, parties reelles et imaginaires.
 186       """
 187       from Utilitai.Utmess import UTMESS
 188       if not self.par_lot():
 189          vale = '%-19s.VALE' % self.get_name()
 190          lbl = aster.getvectjev(vale)
 191          if lbl == None:
 192            UTMESS('F', 'SDVERI_2', valk=[vale])
 193          lbl = list(lbl)
 194          dim=len(lbl)/3
 195          lx=lbl[0:dim]
 196          lr=[]
 197          li=[]
 198          for i in range(dim):
 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'])
 203          dim=len(lbl)
 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)]
 207       else:
 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.")
 211       return [lx, lr, li]
 212    def Absc(self):
 213       """Retourne la liste des abscisses"""
 214       return self.Valeurs()[0]
 215    def Ordo(self):
 216       """Retourne la liste des parties réelles des ordonnées"""
 217       return self.Valeurs()[1]
 218    def OrdoImg(self):
 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"""
 223       if self.par_lot() :
 224          raise Accas.AsException("Erreur dans fonction_c.Trace en PAR_LOT='OUI'")
 225       from Utilitai.Graph import Graph
 226       para = self.Parametres()
 227       gr=Graph()
 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):
 236          val=val.valeur
 237       ###
 238       __ff=self.convert(arg='complex')
 239       return __ff(val)
 240
 241 # -----------------------------------------------------------------------------
 242 class nappe_sdaster(fonction_class, sd_fonction_aster):
 243    def convert(self):
 244       """
 245       Retourne un objet de la classe t_nappe, représentation python de la nappe
 246       """
 247       from Utilitai.t_fonction import t_fonction,t_nappe
 248       para=self.Parametres()
 249       vale=self.Valeurs()
 250       l_fonc=[]
 251       i=0
 252       for pf in para[1] :
 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'],
 258                  }
 259           l_fonc.append(t_fonction(vale[1][i][0],vale[1][i][1],para_f))
 260           i+=1
 261       return t_nappe(vale[0],
 262                      l_fonc,
 263                      para[0],
 264                      nom=self.nom)
 265    def Valeurs(self):
 266       """
 267       Retourne la liste des valeurs du parametre,
 268       et une liste de couples (abscisses,ordonnees) de chaque fonction.
 269       """
 270       from Utilitai.Utmess import UTMESS
 271       if self.par_lot():
 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')
 277       if lpar == None:
 278          UTMESS('F', 'SDVERI_2', valk=[nsd+'.PARA'])
 279       lval=[]
 280       for k in range(len(dicv)):
 281          lbl=dicv[k+1]
 282          dim=len(lbl)/2
 283          lval.append([lbl[0:dim],lbl[dim:2*dim]])
 284       return [list(lpar),lval]
 285    def Parametres(self):
 286       """
 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.
 291       """
 292       from Utilitai.Utmess import UTMESS
 293       if self.par_lot():
 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)
 298       if prol == None:
 299          UTMESS('F', 'SDVERI_2', valk=[objev])
 300       dico={
 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(),
 307       }
 308       lparf=[]
 309       nbf=(len(prol)-7)/2
 310       for i in range(nbf):
 311          dicf={
 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]],
 315          }
 316          lparf.append(dicf)
 317       return [dico,lparf]
 318    def Absc(self):
 319       """Retourne la liste des abscisses"""
 320       return self.Valeurs()[0]
 321    def Trace(self,FORMAT='TABLEAU',**kargs):
 322       """Tracé d'une nappe"""
 323       if self.par_lot():
 324          raise Accas.AsException("Erreur dans nappe.Trace en PAR_LOT='OUI'")
 325       from Utilitai.Graph import Graph
 326       gr=Graph()
 327       lv=self.Valeurs()[1]
 328       dp=self.Parametres()[0]
 329       for lx,ly in lv:
 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)
 333