Aster/Cata/cataSTA9/SD/co_fonction.py

   1 #@ MODIF co_fonction SD  DATE 05/01/2010   AUTEUR MACOCCO K.MACOCCO
   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'] is not 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'] is not None:
 121             lx = self.etape['VALE_PARA'].Valeurs()
 122             ly = self.etape['VALE_FONC'].Valeurs()
 123          elif self.etape['ABSCISSE'] is not None:
 124             lx = self.etape['ABSCISSE']
 125             ly = self.etape['ORDONNEE']
 126          else:
 127             raise Accas.AsException("Erreur (fonction.Valeurs) : ne fonctionne en " \
 128                "PAR_LOT='OUI' que sur des fonctions produites par DEFI_FONCTION " \
 129                "dans le fichier de commandes courant.")
 130       else:
 131          raise Accas.AsException("Erreur (fonction.Valeurs) : ne fonctionne en " \
 132                "PAR_LOT='OUI' que sur des fonctions produites par DEFI_FONCTION " \
 133                "dans le fichier de commandes courant.")
 134       return [lx, ly]
 135    def Absc(self):
 136       """Retourne la liste des abscisses"""
 137       return self.Valeurs()[0]
 138    def Ordo(self):
 139       """Retourne la liste des ordonnées"""
 140       return self.Valeurs()[1]
 141    def __call__(self,val):
 142       ### Pour EFICAS : substitution de l'instance de classe
 143       ### parametre par sa valeur
 144       if isinstance(val, ASSD):
 145          val=val.valeur
 146       ###
 147       __ff=self.convert()
 148       return __ff(val)
 149
 150 # -----------------------------------------------------------------------------
 151 class para_sensi(fonction_sdaster):
 152    pass
 153
 154 # -----------------------------------------------------------------------------
 155 class fonction_c(fonction_class, sd_fonction_aster):
 156    def convert(self,arg='real'):
 157       """
 158       Retourne un objet de la classe t_fonction ou t_fonction_c,
 159       représentation python de la fonction complexe
 160       """
 161       from Utilitai.t_fonction import t_fonction,t_fonction_c
 162       if arg=='real' :
 163         return t_fonction(self.Absc(),
 164                           self.Ordo(),
 165                           self.Parametres(),
 166                           nom=self.nom)
 167       elif arg=='imag' :
 168         return t_fonction(self.Absc(),
 169                           self.OrdoImg(),
 170                           self.Parametres(),
 171                           nom=self.nom)
 172       elif arg=='modul' :
 173         modul=Numeric.sqrt(Numeric.array(self.Ordo())**2+Numeric.array(self.OrdoImg())**2)
 174         return t_fonction(self.Absc(),
 175                           modul,
 176                           self.Parametres(),
 177                           nom=self.nom)
 178       elif arg=='phase' :
 179         phase=Numeric.arctan2(Numeric.array(self.OrdoImg()),Numeric.array(self.Ordo()))
 180         phase=phase*180./pi
 181         return t_fonction(self.Absc(),
 182                           phase,
 183                           self.Parametres(),
 184                           nom=self.nom)
 185       elif arg=='complex' :
 186         return t_fonction_c(self.Absc(),
 187                             map(complex,self.Ordo(),self.OrdoImg()),
 188                             self.Parametres(),
 189                           nom=self.nom)
 190    def Valeurs(self) :
 191       """
 192       Retourne trois listes de valeurs : abscisses, parties reelles et imaginaires.
 193       """
 194       from Utilitai.Utmess import UTMESS
 195       if not self.par_lot():
 196          vale = '%-19s.VALE' % self.get_name()
 197          lbl = aster.getvectjev(vale)
 198          if lbl == None:
 199            UTMESS('F', 'SDVERI_2', valk=[vale])
 200          lbl = list(lbl)
 201          dim=len(lbl)/3
 202          lx=lbl[0:dim]
 203          lr=[]
 204          li=[]
 205          for i in range(dim):
 206             lr.append(lbl[dim+2*i])
 207             li.append(lbl[dim+2*i+1])
 208       elif hasattr(self, 'etape') and self.etape.nom == 'DEFI_FONCTION' \
 209             and self.etape['VALE_C'] is not None:
 210          lbl=list(self.etape['VALE_C'])
 211          dim=len(lbl)
 212          lx=[lbl[i] for i in range(0,dim,3)]
 213          lr=[lbl[i] for i in range(1,dim,3)]
 214          li=[lbl[i] for i in range(2,dim,3)]
 215       else:
 216          raise Accas.AsException("Erreur (fonction_c.Valeurs) : ne fonctionne en " \
 217                "PAR_LOT='OUI' que sur des fonctions produites par DEFI_FONCTION " \
 218                "dans le jdc courant.")
 219       return [lx, lr, li]
 220    def Absc(self):
 221       """Retourne la liste des abscisses"""
 222       return self.Valeurs()[0]
 223    def Ordo(self):
 224       """Retourne la liste des parties réelles des ordonnées"""
 225       return self.Valeurs()[1]
 226    def OrdoImg(self):
 227       """Retourne la liste des parties imaginaires des ordonnées"""
 228       return self.Valeurs()[2]
 229    def Trace(self,FORMAT='TABLEAU',**kargs):
 230       """Tracé d'une fonction complexe"""
 231       if self.par_lot() :
 232          raise Accas.AsException("Erreur dans fonction_c.Trace en PAR_LOT='OUI'")
 233       from Utilitai.Graph import Graph
 234       para = self.Parametres()
 235       gr=Graph()
 236       gr.AjoutCourbe(Val=self.Valeurs(),
 237          Lab=[para['NOM_PARA'], '%s_R' % para['NOM_RESU'], '%s_I' % para['NOM_RESU']],
 238          Leg=os.linesep.join(self.TITR.get()) )
 239       gr.Trace(FORMAT=FORMAT,**kargs)
 240    def __call__(self,val):
 241       ### Pour EFICAS : substitution de l'instance de classe
 242       ### parametre par sa valeur
 243       if isinstance(val, ASSD):
 244          val=val.valeur
 245       ###
 246       __ff=self.convert(arg='complex')
 247       return __ff(val)
 248
 249 # -----------------------------------------------------------------------------
 250 class nappe_sdaster(fonction_class, sd_fonction_aster):
 251    def convert(self):
 252       """
 253       Retourne un objet de la classe t_nappe, représentation python de la nappe
 254       """
 255       from Utilitai.t_fonction import t_fonction,t_nappe
 256       para=self.Parametres()
 257       vale=self.Valeurs()
 258       l_fonc=[]
 259       i=0
 260       for pf in para[1] :
 261           para_f={'INTERPOL'    : pf['INTERPOL_FONC'],
 262                   'PROL_DROITE' : pf['PROL_DROITE_FONC'],
 263                   'PROL_GAUCHE' : pf['PROL_GAUCHE_FONC'],
 264                   'NOM_PARA'    : para[0]['NOM_PARA_FONC'],
 265                   'NOM_RESU'    : para[0]['NOM_RESU'],
 266                  }
 267           l_fonc.append(t_fonction(vale[1][i][0],vale[1][i][1],para_f))
 268           i+=1
 269       return t_nappe(vale[0],
 270                      l_fonc,
 271                      para[0],
 272                      nom=self.nom)
 273    def Valeurs(self):
 274       """
 275       Retourne la liste des valeurs du parametre,
 276       et une liste de couples (abscisses,ordonnees) de chaque fonction.
 277       """
 278       from Utilitai.Utmess import UTMESS
 279       if self.par_lot():
 280          raise Accas.AsException("Erreur dans nappe.Valeurs en PAR_LOT='OUI'")
 281       nsd = '%-19s' % self.get_name()
 282       dicv=aster.getcolljev(nsd+'.VALE')
 283       # les cles de dicv sont 1,...,N (indice du parametre)
 284       lpar=aster.getvectjev(nsd+'.PARA')
 285       if lpar == None:
 286          UTMESS('F', 'SDVERI_2', valk=[nsd+'.PARA'])
 287       lval=[]
 288       for k in range(len(dicv)):
 289          lbl=dicv[k+1]
 290          dim=len(lbl)/2
 291          lval.append([lbl[0:dim],lbl[dim:2*dim]])
 292       return [list(lpar),lval]
 293    def Parametres(self):
 294       """
 295       Retourne un dictionnaire contenant les parametres de la nappe,
 296       le type jeveux (NAPPE) n'est pas retourne,
 297       le dictionnaire peut ainsi etre fourni a CALC_FONC_INTERP tel quel,
 298       et une liste de dictionnaire des parametres de chaque fonction.
 299       """
 300       from Utilitai.Utmess import UTMESS
 301       if self.par_lot():
 302          raise Accas.AsException("Erreur dans nappe.Parametres en PAR_LOT='OUI'")
 303       TypeProl={'E':'EXCLU', 'L':'LINEAIRE', 'C':'CONSTANT' }
 304       objev = '%-19s.PROL' % self.get_name()
 305       prol=aster.getvectjev(objev)
 306       if prol == None:
 307          UTMESS('F', 'SDVERI_2', valk=[objev])
 308       dico={
 309          'INTERPOL'      : [prol[1][0:3],prol[1][4:7]],
 310          'NOM_PARA'      : prol[2][0:16].strip(),
 311          'NOM_RESU'      : prol[3][0:16].strip(),
 312          'PROL_DROITE'   : TypeProl[prol[4][1]],
 313          'PROL_GAUCHE'   : TypeProl[prol[4][0]],
 314          'NOM_PARA_FONC' : prol[6][0:4].strip(),
 315       }
 316       lparf=[]
 317       nbf=(len(prol)-7)/2
 318       for i in range(nbf):
 319          dicf={
 320             'INTERPOL_FONC'    : [prol[7+i*2][0:3],prol[7+i*2][4:7]],
 321             'PROL_DROITE_FONC' : TypeProl[prol[8+i*2][1]],
 322             'PROL_GAUCHE_FONC' : TypeProl[prol[8+i*2][0]],
 323          }
 324          lparf.append(dicf)
 325       return [dico,lparf]
 326    def Absc(self):
 327       """Retourne la liste des abscisses"""
 328       return self.Valeurs()[0]
 329    def Trace(self,FORMAT='TABLEAU',**kargs):
 330       """Tracé d'une nappe"""
 331       if self.par_lot():
 332          raise Accas.AsException("Erreur dans nappe.Trace en PAR_LOT='OUI'")
 333       from Utilitai.Graph import Graph
 334       gr=Graph()
 335       lv=self.Valeurs()[1]
 336       dp=self.Parametres()[0]
 337       for lx,ly in lv:
 338          gr.AjoutCourbe(Val=[lx,ly], Lab=[dp['NOM_PARA_FONC'],dp['NOM_RESU']],
 339             Leg=os.linesep.join(self.TITR.get()) )
 340       gr.Trace(FORMAT=FORMAT,**kargs)
 341