Aster/Cata/cataSTA9/SD/co_fonction.py

   1 #@ MODIF co_fonction SD  DATE 30/05/2007   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
  24
  25 import Numeric
  26 from math import pi
  27
  28 # -----------------------------------------------------------------------------
  29 # types 'fonction' :
  30 class fonction_class(ASSD):
  31    def Valeurs(self):
  32       pass
  33    def Parametres(self):
  34       """
  35       Retourne un dictionnaire contenant les parametres de la fonction ;
  36       le type jeveux (FONCTION, FONCT_C, NAPPE) n'est pas retourne,
  37       le dictionnaire peut ainsi etre fourni a CALC_FONC_INTERP tel quel.
  38       """
  39       from Utilitai.Utmess import UTMESS
  40       if not self.par_lot():
  41         TypeProl={'E':'EXCLU', 'L':'LINEAIRE', 'C':'CONSTANT' }
  42         objev = '%-19s.PROL' % self.get_name()
  43         prol = aster.getvectjev(objev)
  44         if prol == None:
  45            UTMESS('F', 'fonction.Parametres', "Objet '%s' inexistant" % objev)
  46         dico={
  47          'INTERPOL'    : [prol[1][0:3],prol[1][4:7]],
  48          'NOM_PARA'    : prol[2][0:16].strip(),
  49          'NOM_RESU'    : prol[3][0:16].strip(),
  50          'PROL_DROITE' : TypeProl[prol[4][1]],
  51          'PROL_GAUCHE' : TypeProl[prol[4][0]],
  52         }
  53       elif hasattr(self,'etape') and self.etape.nom=='DEFI_FONCTION' :
  54         dico={
  55          'INTERPOL'    : self.etape['INTERPOL'],
  56          'NOM_PARA'    : self.etape['NOM_PARA'],
  57          'NOM_RESU'    : self.etape['NOM_RESU'],
  58          'PROL_DROITE' : self.etape['PROL_DROITE'],
  59          'PROL_GAUCHE' : self.etape['PROL_GAUCHE'],
  60         }
  61         if   type(dico['INTERPOL']) == tuple:
  62                   dico['INTERPOL']=list(dico['INTERPOL'])
  63         elif type(dico['INTERPOL']) == str:
  64                   dico['INTERPOL']=[dico['INTERPOL'],]
  65         if len(dico['INTERPOL'])==1 :
  66            dico['INTERPOL']=dico['INTERPOL']*2
  67       else:
  68          raise Accas.AsException("Erreur dans fonction.Parametres en PAR_LOT='OUI'")
  69       return dico
  70    def Trace(self,FORMAT='TABLEAU',**kargs):
  71       """Tracé d'une fonction"""
  72       if self.par_lot() :
  73          raise Accas.AsException("Erreur dans fonction.Trace en PAR_LOT='OUI'")
  74       from Utilitai.Graph import Graph
  75       gr=Graph()
  76       gr.AjoutCourbe(Val=self.Valeurs(),
  77             Lab=[self.Parametres()['NOM_PARA'],self.Parametres()['NOM_RESU']])
  78       gr.Trace(FORMAT=FORMAT,**kargs)
  79
  80 # -----------------------------------------------------------------------------
  81 class fonction_sdaster(fonction_class, sd_fonction):
  82    def convert(self,arg='real'):
  83       """
  84       Retourne un objet de la classe t_fonction
  85       représentation python de la fonction
  86       """
  87       from Utilitai.t_fonction import t_fonction,t_fonction_c
  88       if arg=='real' :
  89         return t_fonction(self.Absc(),
  90                           self.Ordo(),
  91                           self.Parametres(),
  92                           nom=self.nom)
  93       elif arg=='complex' :
  94         return t_fonction_c(self.Absc(),
  95                             self.Ordo(),
  96                             self.Parametres(),
  97                             nom=self.nom)
  98    def Valeurs(self) :
  99       """
 100       Retourne deux listes de valeurs : abscisses et ordonnees
 101       """
 102       from Utilitai.Utmess import UTMESS
 103       if not self.par_lot():
 104         vale = '%-19s.VALE' % self.get_name()
 105         lbl = aster.getvectjev(vale)
 106         if lbl == None:
 107            UTMESS('F', 'fonction.Valeurs', "Objet '%s' inexistant" % vale)
 108         lbl = list(lbl)
 109         dim = len(lbl)/2
 110         lx = lbl[0:dim]
 111         ly = lbl[dim:2*dim]
 112       elif hasattr(self, 'etape') and self.etape.nom == 'DEFI_FONCTION' :
 113          if self.etape['VALE'] != None:
 114             lbl = list(self.etape['VALE'])
 115             dim = len(lbl)
 116             lx = [lbl[i] for i in range(0,dim,2)]
 117             ly = [lbl[i] for i in range(1,dim,2)]
 118          elif self.etape['VALE_PARA']!=None:
 119             lx = self.etape['VALE_PARA'].Valeurs()
 120             ly = self.etape['VALE_FONC'].Valeurs()
 121       else:
 122          raise Accas.AsException("Erreur (fonction.Valeurs) : ne fonctionne en " \
 123                "PAR_LOT='OUI' que sur des fonctions produites par DEFI_FONCTION " \
 124                "dans le jdc courant.")
 125       return [lx, ly]
 126    def Absc(self):
 127       """Retourne la liste des abscisses"""
 128       return self.Valeurs()[0]
 129    def Ordo(self):
 130       """Retourne la liste des ordonnées"""
 131       return self.Valeurs()[1]
 132    def __call__(self,val):
 133       ### Pour EFICAS : substitution de l'instance de classe
 134       ### parametre par sa valeur
 135       if isinstance(val, ASSD):
 136          val=val.valeur
 137       ###
 138       __ff=self.convert()
 139       return __ff(val)
 140
 141 # -----------------------------------------------------------------------------
 142 class para_sensi(fonction_sdaster):
 143    pass
 144
 145 # -----------------------------------------------------------------------------
 146 class fonction_c(fonction_class, sd_fonction):
 147    def convert(self,arg='real'):
 148       """
 149       Retourne un objet de la classe t_fonction ou t_fonction_c,
 150       représentation python de la fonction complexe
 151       """
 152       from Utilitai.t_fonction import t_fonction,t_fonction_c
 153       if arg=='real' :
 154         return t_fonction(self.Absc(),
 155                           self.Ordo(),
 156                           self.Parametres(),
 157                           nom=self.nom)
 158       elif arg=='imag' :
 159         return t_fonction(self.Absc(),
 160                           self.OrdoImg(),
 161                           self.Parametres(),
 162                           nom=self.nom)
 163       elif arg=='modul' :
 164         modul=Numeric.sqrt(Numeric.array(self.Ordo())**2+Numeric.array(self.OrdoImg())**2)
 165         return t_fonction(self.Absc(),
 166                           modul,
 167                           self.Parametres(),
 168                           nom=self.nom)
 169       elif arg=='phase' :
 170         phase=Numeric.arctan2(Numeric.array(self.OrdoImg()),Numeric.array(self.Ordo()))
 171         phase=phase*180./pi
 172         return t_fonction(self.Absc(),
 173                           phase,
 174                           self.Parametres(),
 175                           nom=self.nom)
 176       elif arg=='complex' :
 177         return t_fonction_c(self.Absc(),
 178                             map(complex,self.Ordo(),self.OrdoImg()),
 179                             self.Parametres(),
 180                           nom=self.nom)
 181    def Valeurs(self) :
 182       """
 183       Retourne trois listes de valeurs : abscisses, parties reelles et imaginaires.
 184       """
 185       from Utilitai.Utmess import UTMESS
 186       if not self.par_lot():
 187          vale = '%-19s.VALE' % self.get_name()
 188          lbl = aster.getvectjev(vale)
 189          if lbl == None:
 190             UTMESS('F', 'fonction.Valeurs', "Objet '%s' inexistant" % vale)
 191          lbl = list(lbl)
 192          dim=len(lbl)/3
 193          lx=lbl[0:dim]
 194          lr=[]
 195          li=[]
 196          for i in range(dim):
 197             lr.append(lbl[dim+2*i])
 198             li.append(lbl[dim+2*i+1])
 199       elif hasattr(self, 'etape') and self.etape.nom == 'DEFI_FONCTION':
 200          lbl=list(self.etape['VALE_C'])
 201          dim=len(lbl)
 202          lx=[lbl[i] for i in range(0,dim,3)]
 203          lr=[lbl[i] for i in range(1,dim,3)]
 204          li=[lbl[i] for i in range(2,dim,3)]
 205       else:
 206          raise Accas.AsException("Erreur (fonction_c.Valeurs) : ne fonctionne en " \
 207                "PAR_LOT='OUI' que sur des fonctions produites par DEFI_FONCTION " \
 208                "dans le jdc courant.")
 209       return [lx, lr, li]
 210    def Absc(self):
 211       """Retourne la liste des abscisses"""
 212       return self.Valeurs()[0]
 213    def Ordo(self):
 214       """Retourne la liste des parties réelles des ordonnées"""
 215       return self.Valeurs()[1]
 216    def OrdoImg(self):
 217       """Retourne la liste des parties imaginaires des ordonnées"""
 218       return self.Valeurs()[2]
 219    def Trace(self,FORMAT='TABLEAU',**kargs):
 220       """Tracé d'une fonction complexe"""
 221       if self.par_lot() :
 222          raise Accas.AsException("Erreur dans fonction_c.Trace en PAR_LOT='OUI'")
 223       from Utilitai.Graph import Graph
 224       gr=Graph()
 225       gr.AjoutCourbe(Val=self.Valeurs(),
 226        Lab=[self.Parametres()['NOM_PARA'],self.Parametres()['NOM_RESU'],'IMAG'])
 227       gr.Trace(FORMAT=FORMAT,**kargs)
 228    def __call__(self,val):
 229       ### Pour EFICAS : substitution de l'instance de classe
 230       ### parametre par sa valeur
 231       if isinstance(val, ASSD):
 232          val=val.valeur
 233       ###
 234       __ff=self.convert()
 235       return __ff(val)
 236
 237 # -----------------------------------------------------------------------------
 238 class nappe_sdaster(fonction_class, sd_fonction):
 239    def convert(self):
 240       """
 241       Retourne un objet de la classe t_nappe, représentation python de la nappe
 242       """
 243       from Utilitai.t_fonction import t_fonction,t_nappe
 244       para=self.Parametres()
 245       vale=self.Valeurs()
 246       l_fonc=[]
 247       i=0
 248       for pf in para[1] :
 249           para_f={'INTERPOL'    : pf['INTERPOL_FONC'],
 250                   'PROL_DROITE' : pf['PROL_DROITE_FONC'],
 251                   'PROL_GAUCHE' : pf['PROL_GAUCHE_FONC'],
 252                   'NOM_PARA'    : para[0]['NOM_PARA_FONC'],
 253                   'NOM_RESU'    : para[0]['NOM_RESU'],
 254                  }
 255           l_fonc.append(t_fonction(vale[1][i][0],vale[1][i][1],para_f))
 256           i+=1
 257       return t_nappe(vale[0],
 258                      l_fonc,
 259                      para[0],
 260                      nom=self.nom)
 261    def Valeurs(self):
 262       """
 263       Retourne la liste des valeurs du parametre,
 264       et une liste de couples (abscisses,ordonnees) de chaque fonction.
 265       """
 266       from Utilitai.Utmess import UTMESS
 267       if self.par_lot():
 268          raise Accas.AsException("Erreur dans nappe.Valeurs en PAR_LOT='OUI'")
 269       nsd = '%-19s' % self.get_name()
 270       dicv=aster.getcolljev(nsd+'.VALE')
 271       # les cles de dicv sont 1,...,N (indice du parametre)
 272       lpar=aster.getvectjev(nsd+'.PARA')
 273       if lpar == None:
 274          UTMESS('F', 'fonction.Valeurs', "Objet '%s' inexistant" % (nsd+'.PARA'))
 275       lval=[]
 276       for k in range(len(dicv)):
 277          lbl=dicv[k+1]
 278          dim=len(lbl)/2
 279          lval.append([lbl[0:dim],lbl[dim:2*dim]])
 280       return [list(lpar),lval]
 281    def Parametres(self):
 282       """
 283       Retourne un dictionnaire contenant les parametres de la nappe,
 284       le type jeveux (NAPPE) n'est pas retourne,
 285       le dictionnaire peut ainsi etre fourni a CALC_FONC_INTERP tel quel,
 286       et une liste de dictionnaire des parametres de chaque fonction.
 287       """
 288       from Utilitai.Utmess import UTMESS
 289       if self.par_lot():
 290          raise Accas.AsException("Erreur dans nappe.Parametres en PAR_LOT='OUI'")
 291       TypeProl={'E':'EXCLU', 'L':'LINEAIRE', 'C':'CONSTANT' }
 292       objev = '%-19s.PROL' % self.get_name()
 293       prol=aster.getvectjev(objev)
 294       if prol == None:
 295          UTMESS('F', 'fonction.Parametres', "Objet '%s' inexistant" % objev)
 296       dico={
 297          'INTERPOL'      : [prol[1][0:3],prol[1][4:7]],
 298          'NOM_PARA'      : prol[2][0:16].strip(),
 299          'NOM_RESU'      : prol[3][0:16].strip(),
 300          'PROL_DROITE'   : TypeProl[prol[4][1]],
 301          'PROL_GAUCHE'   : TypeProl[prol[4][0]],
 302          'NOM_PARA_FONC' : prol[5][0:4].strip(),
 303       }
 304       lparf=[]
 305       nbf=(len(prol)-6)/2
 306       for i in range(nbf):
 307          dicf={
 308             'INTERPOL_FONC'    : [prol[6+i*2][0:3],prol[6+i*2][4:7]],
 309             'PROL_DROITE_FONC' : TypeProl[prol[7+i*2][1]],
 310             'PROL_GAUCHE_FONC' : TypeProl[prol[7+i*2][0]],
 311          }
 312          lparf.append(dicf)
 313       return [dico,lparf]
 314    def Absc(self):
 315       """Retourne la liste des abscisses"""
 316       return self.Valeurs()[0]
 317    def Trace(self,FORMAT='TABLEAU',**kargs):
 318       """Tracé d'une nappe"""
 319       if self.par_lot():
 320          raise Accas.AsException("Erreur dans nappe.Trace en PAR_LOT='OUI'")
 321       from Utilitai.Graph import Graph
 322       gr=Graph()
 323       lv=self.Valeurs()[1]
 324       dp=self.Parametres()[0]
 325       for lx,ly in lv:
 326          gr.AjoutCourbe(Val=[lx,ly], Lab=[dp['NOM_PARA_FONC'],dp['NOM_RESU']])
 327       gr.Trace(FORMAT=FORMAT,**kargs)