Aster/Cata/cataSTA9/Macro/calc_fonction_ops.py

   1 #@ MODIF calc_fonction_ops Macro  DATE 16/10/2007   AUTEUR REZETTE C.REZETTE
   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.
  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 copy
  22 import traceback
  23 import os
  24 from math import pi
  25
  26
  27 # -----------------------------------------------------------------------------
  28 def tocomplex(arg):
  29     if arg[0]=='RI' : return complex(arg[1],arg[2])
  30     if arg[0]=='MP' : return complex(arg[1]*cos(arg[2]),arg[1]*sin(arg[2]))
  31
  32
  33 # -----------------------------------------------------------------------------
  34 def calc_fonction_ops(self,FFT,DERIVE,INTEGRE,LISS_ENVELOP,
  35                       SPEC_OSCI,ABS,COMB,COMB_C,COMPOSE,EXTRACTION,
  36                       ENVELOPPE,FRACTILE,ASSE,CORR_ACCE,PUISSANCE,INVERSE,
  37                       NOM_PARA,NOM_RESU,INTERPOL,PROL_DROITE,
  38                       PROL_GAUCHE,NOM_PARA_FONC,INTERPOL_FONC,PROL_DROITE_FONC,
  39                       PROL_GAUCHE_FONC,INFO,**args):
  40    """
  41       Ecriture de la macro CALC_FONCTION
  42    """
  43    ier=0
  44    from Utilitai.t_fonction import t_fonction, t_fonction_c, t_nappe, homo_support_nappe, \
  45             FonctionError, ParametreError, InterpolationError, ProlongementError, enveloppe, fractile
  46    from Utilitai import liss_enveloppe
  47    from Accas import _F
  48    from Cata.cata import nappe_sdaster,fonction_sdaster,fonction_c
  49    from Utilitai.Utmess import  UTMESS
  50    from Numeric import alltrue,less,array,reshape,cos,sin,exp,sqrt
  51    from Numeric import choose,zeros,Float
  52    import aster_fonctions
  53    EnumTypes = (list, tuple)
  54
  55    ### On importe les definitions des commandes a utiliser dans la macro
  56    DEFI_FONCTION  = self.get_cmd('DEFI_FONCTION')
  57    IMPR_FONCTION  = self.get_cmd('IMPR_FONCTION')
  58    DEFI_NAPPE     = self.get_cmd('DEFI_NAPPE')
  59
  60    ### Comptage commandes + déclaration concept sortant
  61    self.set_icmd(1)
  62    self.DeclareOut('C_out',self.sd)
  63
  64    # éléments de contexte
  65    ctxt = Context()
  66    ### l'ensemble est dans un try/except pour recuperer les erreurs du module t_fonction
  67    try:
  68       ###
  69       if (INTEGRE     != None):
  70          __ff=INTEGRE['FONCTION'].convert()
  71          ctxt.f = __ff.nom
  72          if INTEGRE['METHODE']=='TRAPEZE' :
  73             __ex=__ff.trapeze(INTEGRE['COEF'])
  74          elif INTEGRE['METHODE']=='SIMPSON' :
  75             __ex=__ff.simpson(INTEGRE['COEF'])
  76       ###
  77       if (DERIVE      != None):
  78          __ff=DERIVE['FONCTION'].convert()
  79          ctxt.f = __ff.nom
  80          __ex=__ff.derive()
  81       ###
  82       if (INVERSE     != None):
  83          __ff=INVERSE['FONCTION'].convert()
  84          ctxt.f = __ff.nom
  85          __ex=__ff.inverse()
  86       ###
  87       if (ABS         != None):
  88          __ff=ABS['FONCTION'].convert()
  89          ctxt.f = __ff.nom
  90          __ex=__ff.abs()
  91       ###
  92       if (COMPOSE     != None):
  93          __ff=COMPOSE['FONC_RESU'].convert()
  94          __fg=COMPOSE['FONC_PARA'].convert()
  95          ctxt.f = [__ff.nom, __fg.nom]
  96          __ex=__ff[__fg]
  97       ###
  98       if (ASSE        != None):
  99          __f0=ASSE['FONCTION'][0].convert()
 100          __f1=ASSE['FONCTION'][1].convert()
 101          ctxt.f = [__f0.nom, __f1.nom]
 102          __ex=__f0.cat(__f1,ASSE['SURCHARGE'])
 103       ###
 104       if (COMB != None):
 105          list_fonc=[]
 106          if isinstance(self.sd,nappe_sdaster):
 107             for mcfact in COMB :
 108                list_fonc.append(mcfact['FONCTION'].convert())
 109             ctxt.f = [f.nom for f in list_fonc]
 110             list_fonc = homo_support_nappe(list_fonc)
 111          elif isinstance(self.sd,fonction_sdaster):
 112             for mcfact in COMB :
 113                __ex=mcfact['FONCTION'].convert()
 114                list_fonc.append(__ex)
 115
 116          __ex = 0.
 117          for item, comb in zip(list_fonc, COMB):
 118             ctxt.f = item.nom
 119             __ex = item * comb['COEF'] + __ex
 120          # on prend les paramètres de la 1ère fonction
 121          __ex.para = copy.copy(list_fonc[0].para)
 122       ###
 123       if (COMB_C != None):
 124          list_fonc=[]
 125          if isinstance(self.sd,nappe_sdaster):
 126             for mcfact in COMB_C:
 127                list_fonc.append(mcfact['FONCTION'].convert())
 128             ctxt.f = [f.nom for f in list_fonc]
 129             list_fonc = homo_support_nappe(list_fonc)
 130          elif isinstance(self.sd,fonction_sdaster) or isinstance(self.sd,fonction_c):
 131             for mcfact in COMB_C :
 132                __ex=mcfact['FONCTION'].convert(arg='complex')
 133                list_fonc.append(__ex)
 134
 135          __ex = 0.
 136          for item, comb in zip(list_fonc, COMB_C):
 137             if comb['COEF_R'] != None:
 138                coef = complex(comb['COEF_R'])
 139             elif comb['COEF_C'] != None:
 140                if type(comb['COEF_C']) in EnumTypes:
 141                   coef = tocomplex(comb['COEF_C'])
 142                else:
 143                   coef = comb['COEF_C']
 144             ctxt.f = item.nom
 145             __ex = item * coef + __ex
 146          # on prend les paramètres de la 1ère fonction
 147          __ex.para = copy.copy(list_fonc[0].para)
 148
 149       ### mot clé LIST_PARA uniquement présent si COMB ou COMB_C
 150       if (COMB != None) or (COMB_C != None) :
 151          if (args['LIST_PARA'] != None) :
 152             __ex=__ex.evalfonc(args['LIST_PARA'].Valeurs())
 153       ###
 154       if (PUISSANCE   != None):
 155          __ff=PUISSANCE['FONCTION'].convert()
 156          ctxt.f = __ff.nom
 157          __ex=__ff
 158          for i in range(PUISSANCE['EXPOSANT']-1):
 159             __ex=__ex*__ff
 160       ###
 161       if (EXTRACTION  != None):
 162          if EXTRACTION['PARTIE']=='REEL':
 163             __ex=EXTRACTION['FONCTION'].convert(arg='real')
 164          if EXTRACTION['PARTIE']=='IMAG':
 165             __ex=EXTRACTION['FONCTION'].convert(arg='imag')
 166          if EXTRACTION['PARTIE']=='MODULE':
 167             __ex=EXTRACTION['FONCTION'].convert(arg='modul')
 168          if EXTRACTION['PARTIE']=='PHASE':
 169             __ex=EXTRACTION['FONCTION'].convert(arg='phase')
 170       ###
 171       if (ENVELOPPE   != None):
 172          list_fonc=[]
 173          l_env=ENVELOPPE['FONCTION']
 174          if type(l_env) not in EnumTypes:
 175             l_env=(l_env,)
 176          if isinstance(self.sd,nappe_sdaster):
 177             for f in l_env:
 178                list_fonc.append(f.convert())
 179             ctxt.f = [f.nom for f in list_fonc]
 180             list_fonc = homo_support_nappe(list_fonc)
 181             vale_para=list_fonc[0].vale_para
 182             para     =list_fonc[0].para
 183             l_fonc_f =[]
 184             for i in range(len(vale_para)):
 185                __ff=list_fonc[0].l_fonc[i]
 186                for nap in list_fonc[1:] :
 187                   ctxt.f = nap.l_fonc[i].nom
 188                   __ff=enveloppe([__ff,nap.l_fonc[i]], ENVELOPPE['CRITERE'])
 189                l_fonc_f.append(__ff)
 190             __ex=t_nappe(vale_para,l_fonc_f,para)
 191          elif isinstance(self.sd,fonction_sdaster):
 192             for f in l_env:
 193                list_fonc.append(f.convert())
 194             ctxt.f = [f.nom for f in list_fonc]
 195             __ex = enveloppe(list_fonc, ENVELOPPE['CRITERE'])
 196       ###
 197       if (FRACTILE   != None):
 198          list_fonc=[]
 199          l_frac=FRACTILE['FONCTION']
 200          if type(l_frac) not in EnumTypes:
 201             l_frac=(l_frac,)
 202          if isinstance(self.sd,nappe_sdaster):
 203             for f in l_frac:
 204                list_fonc.append(f.convert())
 205             ctxt.f = [f.nom for f in list_fonc]
 206             list_fonc = homo_support_nappe(list_fonc)
 207             vale_para=list_fonc[0].vale_para
 208             para     =list_fonc[0].para
 209             l_fonc_f =[]
 210             for i in range(len(vale_para)):
 211                ctxt.f = [nap.l_fonc[i].nom for nap in list_fonc]
 212                __ff=fractile([nap.l_fonc[i] for nap in list_fonc], FRACTILE['FRACT'])
 213                l_fonc_f.append(__ff)
 214             __ex=t_nappe(vale_para,l_fonc_f,para)
 215          elif isinstance(self.sd,fonction_sdaster):
 216             for f in l_frac:
 217                list_fonc.append(f.convert())
 218             __ex=list_fonc[0]
 219             for f in list_fonc[1:]:
 220                ctxt.f = [__ex.nom, f.nom]
 221                __ex = fractile(list_fonc, FRACTILE['FRACT'])
 222       ###
 223       if (CORR_ACCE   != None):
 224          __ex=CORR_ACCE['FONCTION'].convert()
 225          ctxt.f = __ex.nom
 226          para=copy.copy(__ex.para)
 227          # suppression de la tendance de l accelero
 228          __ex=__ex.suppr_tend()
 229          # calcul de la vitesse
 230          __ex=__ex.trapeze(0.)
 231          # calcul de la tendance de la vitesse : y = a1*x +a0
 232          __ex=__ex.suppr_tend()
 233          if CORR_ACCE['CORR_DEPL']=='OUI':
 234             # suppression de la tendance deplacement
 235             # calcul du deplacement : integration
 236             __ex=__ex.trapeze(0.)
 237             # calcul de la tendance du déplacement : y = a1*x +a0
 238             __ex=__ex.suppr_tend()
 239             # regeneration de la vitesse : derivation
 240             __ex=__ex.derive()
 241          # regeneration de l accelero : derivation
 242          __ex=__ex.derive()
 243          __ex.para=para
 244       ###
 245       if (FFT         != None):
 246          if isinstance(self.sd,fonction_c):
 247             __ff=FFT['FONCTION'].convert()
 248             ctxt.f = __ff.nom
 249             __ex=__ff.fft(FFT['METHODE'])
 250          if isinstance(self.sd,fonction_sdaster):
 251             __ff=FFT['FONCTION'].convert(arg='complex')
 252             ctxt.f = __ff.nom
 253             __ex=__ff.fft(FFT['METHODE'],FFT['SYME'])
 254       ###
 255       if (SPEC_OSCI   != None):
 256          if SPEC_OSCI['AMOR_REDUIT']==None:
 257             l_amor=[0.02, 0.05, 0.1]
 258             UTMESS('I','FONCT0_31',valr=l_amor)
 259          else:
 260             if type(SPEC_OSCI['AMOR_REDUIT']) not in EnumTypes :
 261                l_amor=[SPEC_OSCI['AMOR_REDUIT'],]
 262             else:
 263                l_amor= SPEC_OSCI['AMOR_REDUIT']
 264          if SPEC_OSCI['FREQ']==None and SPEC_OSCI['LIST_FREQ']==None:
 265             l_freq=[]
 266             for i in range(56):
 267                l_freq.append( 0.2+0.050*i)
 268             for i in range( 8):
 269                l_freq.append( 3.0+0.075*i)
 270             for i in range(14):
 271                l_freq.append( 3.6+0.100*i)
 272             for i in range(24):
 273                l_freq.append( 5.0+0.125*i)
 274             for i in range(28):
 275                l_freq.append( 8.0+0.250*i)
 276             for i in range( 6):
 277                l_freq.append(15.0+0.500*i)
 278             for i in range( 4):
 279                l_freq.append(18.0+1.000*i)
 280             for i in range(10):
 281                l_freq.append(22.0+1.500*i)
 282             texte=[]
 283             for i in range(len(l_freq)/5) :
 284                texte.append(' %f %f %f %f %f' %tuple(l_freq[i*5:i*5+5]))
 285             UTMESS('I','FONCT0_32',valk=os.linesep.join(texte))
 286          elif SPEC_OSCI['LIST_FREQ']!=None:
 287             l_freq=SPEC_OSCI['LIST_FREQ'].Valeurs()
 288          elif SPEC_OSCI['FREQ']!=None:
 289             if type(SPEC_OSCI['FREQ']) not in EnumTypes:
 290                l_freq=[SPEC_OSCI['FREQ'],]
 291             else:
 292                l_freq= SPEC_OSCI['FREQ']
 293          if min(l_freq)<1.E-10 :
 294             UTMESS('S','FONCT0_43')
 295          if abs(SPEC_OSCI['NORME'])<1.E-10 :
 296             UTMESS('S','FONCT0_33')
 297          if SPEC_OSCI['NATURE_FONC']!='ACCE' :
 298             UTMESS('S','FONCT0_34')
 299          if SPEC_OSCI['METHODE']!='NIGAM' :
 300             UTMESS('S','FONCT0_35')
 301          eps=1.e-6
 302          for amor in l_amor :
 303             if amor>(1-eps) :
 304               UTMESS('S','FONCT0_36')
 305          __ff=SPEC_OSCI['FONCTION'].convert()
 306          ctxt.f = __ff.nom
 307
 308          # appel à SPEC_OSCI
 309          spectr = aster_fonctions.SPEC_OSCI(__ff.vale_x, __ff.vale_y, l_freq, l_amor)
 310
 311          # construction de la nappe
 312          vale_para = l_amor
 313          para      = { 'INTERPOL'      : ['LIN','LOG'],
 314                        'NOM_PARA_FONC' : 'FREQ',
 315                        'NOM_PARA'      : 'AMOR',
 316                        'PROL_DROITE'   : 'EXCLU',
 317                        'PROL_GAUCHE'   : 'EXCLU',
 318                        'NOM_RESU'      : SPEC_OSCI['NATURE'] }
 319          para_fonc = { 'INTERPOL'      : ['LOG','LOG'],
 320                        'NOM_PARA'      : 'FREQ',
 321                        'PROL_DROITE'   : 'CONSTANT',
 322                        'PROL_GAUCHE'   : 'EXCLU',
 323                        'NOM_RESU'      : SPEC_OSCI['NATURE'] }
 324          if   SPEC_OSCI['NATURE']=='DEPL':
 325             ideb = 0
 326          elif SPEC_OSCI['NATURE']=='VITE':
 327             ideb = 1
 328          else:
 329             ideb = 2
 330          l_fonc = []
 331          for iamor in range(len(l_amor)) :
 332             l_fonc.append(t_fonction(l_freq,spectr[iamor,ideb,:]/SPEC_OSCI['NORME'],para_fonc))
 333          __ex=t_nappe(vale_para,l_fonc,para)
 334       ###
 335       if (LISS_ENVELOP!= None):
 336          __ff=LISS_ENVELOP['NAPPE'].convert()
 337          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="")
 338          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'])
 339          para_fonc=__ff.l_fonc[0].para
 340          l_fonc=[]
 341          for val in sp_lisse.listTable:
 342             l_fonc.append(t_fonction(sp_lisse.listFreq,val,para_fonc))
 343          __ex=t_nappe(vale_para=sp_lisse.listAmor,l_fonc=l_fonc,para=__ff.para)
 344
 345    except InterpolationError, msg:
 346       UTMESS('F', 'FONCT0_27', valk=(ctxt.f, str(msg)))
 347    except ParametreError, msg:
 348       UTMESS('F', 'FONCT0_28', valk=(ctxt.f, str(msg)))
 349    except ProlongementError, msg:
 350       UTMESS('F', 'FONCT0_29', valk=(ctxt.f, str(msg)))
 351    except FonctionError, msg:
 352       UTMESS('F', 'FONCT0_30', valk=(ctxt.f, str(msg), traceback.format_exc()))
 353
 354    ### creation de la fonction produite par appel à DEFI_FONCTION
 355    ### on récupère les paramètres issus du calcul de __ex
 356    ### et on les surcharge par ceux imposés par l'utilisateur
 357
 358    if isinstance(__ex,t_fonction) or isinstance(__ex,t_fonction_c):
 359       para=__ex.para
 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 INTERPOL   !=None : para['INTERPOL']   =INTERPOL
 365       if   isinstance(__ex,t_fonction_c): para['VALE_C'] = __ex.tabul()
 366       elif isinstance(__ex,t_fonction)  : para['VALE']   = __ex.tabul()
 367       C_out=DEFI_FONCTION(**para)
 368    elif isinstance(__ex,t_nappe):
 369       def_fonc=[]
 370       for f in __ex.l_fonc :
 371          para=f.para
 372          def_fonc.append(_F(VALE       =f.tabul(),
 373                             INTERPOL   =f.para['INTERPOL'],
 374                             PROL_DROITE=f.para['PROL_DROITE'],
 375                             PROL_GAUCHE=f.para['PROL_GAUCHE'],))
 376       para=__ex.para
 377       if NOM_PARA      !=None : para['NOM_PARA']   =NOM_PARA
 378       if NOM_RESU      !=None : para['NOM_RESU']   =NOM_RESU
 379       if PROL_DROITE   !=None : para['PROL_DROITE']=PROL_DROITE
 380       if PROL_GAUCHE   !=None : para['PROL_GAUCHE']=PROL_GAUCHE
 381       if NOM_PARA_FONC !=None : para['NOM_PARA_FONC']   =INTERPOL
 382       if INTERPOL_FONC !=None : para['INTERPOL']   =INTERPOL
 383       C_out=DEFI_NAPPE(PARA=__ex.vale_para.tolist(),DEFI_FONCTION=def_fonc,**para)
 384    if INFO > 1:
 385       IMPR_FONCTION(FORMAT='TABLEAU',
 386                     UNITE=6,
 387                     COURBE=_F(FONCTION=C_out),)
 388    return ier
 389
 390
 391 # -----------------------------------------------------------------------------
 392 class Context(object):
 393    """Permet de stocker des éléments de contexte pour aider au
 394    diagnostic lors de l'émission de message.
 395    usage :
 396       context = Context()
 397       context.f = 'nomfon'
 398       print context.f
 399    """
 400    def __init__(self):
 401       self.__nomf = None
 402
 403    def get_val(self):
 404       """Retourne le texte formatté.
 405       """
 406       nomf = self.__nomf
 407       if type(nomf) not in (list, tuple):
 408          nomf = [nomf,]
 409       pluriel = ''
 410       if len(nomf) > 1:
 411          pluriel = 's'
 412       try:
 413          res = """Fonction%(s)s concernée%(s)s : %(nomf)s""" % {
 414             's'    : pluriel,
 415             'nomf' : ', '.join(nomf),
 416          }
 417       except:
 418          res = 'erreur de programmation !'
 419       return res
 420
 421    def set_val(self, value):
 422       self.__nomf = value
 423
 424    def del_val(self):
 425       del self.__nomf
 426
 427    f = property(get_val, set_val, del_val, "")