Aster/Cata/cataSTA9/Macro/info_fonction_ops.py

   1 #@ MODIF info_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 def info_fonction_ops(self,RMS,NOCI_SEISME,MAX,NORME,ECART_TYPE,INFO,**args):
  21   """
  22      Ecriture de la macro INFO_FONCTION
  23   """
  24   ier=0
  25   import string
  26   from Utilitai.t_fonction import t_fonction,t_fonction_c,t_nappe
  27   import math
  28   from Accas import _F
  29   from Utilitai.Utmess import  UTMESS
  30   import types
  31   from types import ListType, TupleType
  32   EnumTypes = (ListType, TupleType)
  33
  34   ### On importe les definitions des commandes a utiliser dans la macro
  35   CREA_TABLE     = self.get_cmd('CREA_TABLE')
  36   CALC_TABLE     = self.get_cmd('CALC_TABLE')
  37   IMPR_TABLE     = self.get_cmd('IMPR_TABLE')
  38   CALC_FONCTION  = self.get_cmd('CALC_FONCTION')
  39
  40   ### Comptage commandes + déclaration concept sortant
  41   self.set_icmd(1)
  42   self.DeclareOut('C_out',self.sd)
  43
  44   ### type de traitement
  45
  46   ###
  47   if (MAX != None):
  48      if type(MAX['FONCTION']) not in EnumTypes : l_fonc=[MAX['FONCTION'],]
  49      else                                       : l_fonc=MAX['FONCTION']
  50      __tmfonc=[None]*3
  51      k=0
  52      mfact=[]
  53      ltyfo=[]
  54      lpara=[]
  55      lresu=[]
  56      lfnom=[]
  57      for fonc in l_fonc :
  58         __ff=fonc.convert()
  59         __ex=__ff.extreme()
  60         ltyfo.append(__ff.__class__)
  61         lpara.append(__ff.para['NOM_PARA'])
  62         lresu.append(__ff.para['NOM_RESU'])
  63         lfnom.append(fonc.nom)
  64         n_mini=len(__ex['min'])
  65         n_maxi=len(__ex['max'])
  66         listeMCF=[_F(LISTE_K=[fonc.nom]*(n_mini+n_maxi),PARA='FONCTION'),
  67                   _F(LISTE_K=['MINI',]*n_mini+['MAXI',]*n_maxi,PARA='TYPE'),]
  68         n_resu=__ff.para['NOM_RESU']
  69         if isinstance(__ff,t_nappe) :
  70            listeMCF=listeMCF+[\
  71               _F(LISTE_R=[i[0] for i in __ex['min']]+[i[0] for i in __ex['max']],PARA=__ff.para['NOM_PARA']),\
  72               _F(LISTE_R=[i[1] for i in __ex['min']]+[i[1] for i in __ex['max']],PARA=__ff.para['NOM_PARA_FONC']),\
  73               _F(LISTE_R=[i[2] for i in __ex['min']]+[i[2] for i in __ex['max']],PARA=__ff.para['NOM_RESU'])]
  74         else :
  75            listeMCF=listeMCF+[\
  76                   _F(LISTE_R=[i[0] for i in __ex['min']]+[i[0] for i in __ex['max']],PARA=__ff.para['NOM_PARA']),\
  77                   _F(LISTE_R=[i[1] for i in __ex['min']]+[i[1] for i in __ex['max']],PARA=__ff.para['NOM_RESU'])]
  78         __tmfonc[k]=CREA_TABLE(LISTE=listeMCF)
  79         if k!=0 :
  80            mfact.append(_F(OPERATION = 'COMB',TABLE=__tmfonc[k]))
  81         k=k+1
  82      ltyfo=dict([(i,0) for i in ltyfo]).keys()
  83      lpara=dict([(i,0) for i in lpara]).keys()
  84      lresu=dict([(i,0) for i in lresu]).keys()
  85      if len(ltyfo)>1 :
  86 # n'est pas homogène en type (fonctions et nappes) ''')
  87         UTMESS('F','FONCT0_37')
  88      if len(lpara)>1 :
  89 # n'est pas homogène en label NOM_PARA :'''+' '.join(lpara))
  90         UTMESS('F','FONCT0_38',valk=' '.join(lpara))
  91      if len(lresu)>1 :
  92 # n'est pas homogène en label NOM_RESU : '''+' '.join(lresu))
  93         UTMESS('F','FONCT0_39',valk=' '.join(lresu))
  94      __tab=CALC_TABLE(TABLE  = __tmfonc[0],
  95                       ACTION = mfact        )
  96      __min=CALC_TABLE(TABLE  = __tab,
  97                       ACTION = _F(OPERATION = 'FILTRE',
  98                                   CRIT_COMP = 'MINI',
  99                                   NOM_PARA  = lresu[0]  ), )
 100      __max=CALC_TABLE(TABLE  = __tab,
 101                       ACTION = _F(OPERATION = 'FILTRE',
 102                                   CRIT_COMP = 'MAXI',
 103                                   NOM_PARA  = lresu[0]  ), )
 104      print __min.EXTR_TABLE()
 105      print __max.EXTR_TABLE()
 106      C_out=CALC_TABLE(TABLE  = __min,
 107                       TITRE  = 'Calcul des extrema sur fonction '+' '.join(lfnom),
 108                       ACTION = _F(OPERATION = 'COMB',
 109                                   TABLE=__max  ), )
 110      print C_out.EXTR_TABLE()
 111
 112   ###
 113   if (ECART_TYPE  != None):
 114      __ff=ECART_TYPE['FONCTION'].convert()
 115      if ECART_TYPE['INST_INIT']!=None : tini=ECART_TYPE['INST_INIT']
 116      else                             : tini=__ff.vale_x[0]
 117      if ECART_TYPE['INST_FIN' ]!=None : tfin=ECART_TYPE['INST_FIN' ]
 118      else                             : tfin=__ff.vale_x[-1]
 119      __ff=__ff.cut(tini,__ff.vale_x[-1],ECART_TYPE['PRECISION'],ECART_TYPE['CRITERE'])
 120      __ff=__ff.cut(__ff.vale_x[0],tfin,ECART_TYPE['PRECISION'],ECART_TYPE['CRITERE'])
 121      if ECART_TYPE['METHODE'  ]=='SIMPSON' : __ex=__ff.simpson(0.)
 122      if ECART_TYPE['METHODE'  ]=='TRAPEZE' : __ex=__ff.trapeze(0.)
 123      fmoy=__ex.vale_y[-1]/(__ff.vale_x[-1]-__ff.vale_x[0])
 124      __ff=__ff+(-1*fmoy)
 125      __ff=__ff*__ff
 126      if ECART_TYPE['METHODE'  ]=='SIMPSON' : __ez=__ff.simpson(0.)
 127      if ECART_TYPE['METHODE'  ]=='TRAPEZE' : __ez=__ff.trapeze(0.)
 128      sigma=math.sqrt(__ez.vale_y[-1]/(__ff.vale_x[-1]-__ff.vale_x[0]))
 129      C_out=CREA_TABLE(LISTE=(_F(LISTE_K=ECART_TYPE['FONCTION'].nom,PARA='FONCTION'),
 130                              _F(LISTE_K=ECART_TYPE['METHODE']     ,PARA='METHODE'),
 131                              _F(LISTE_R=fmoy                      ,PARA='MOYENNE'),
 132                              _F(LISTE_R=sigma                     ,PARA='ECART_TYPE'),
 133                              _F(LISTE_R=tini                      ,PARA='INST_INIT'),
 134                              _F(LISTE_R=tfin                      ,PARA='INST_FIN'),)
 135                      )
 136
 137   ###
 138   if (RMS != None):
 139      RMS  =list(RMS)
 140      sigm =[]
 141      tmpi =[]
 142      tmpf =[]
 143      nomf =[]
 144      meth =[]
 145      for i_rms in RMS :
 146          __ff=i_rms['FONCTION'].convert()
 147          if i_rms['INST_INIT']!=None : tini=i_rms['INST_INIT']
 148          else                        : tini=__ff.vale_x[0]
 149          if i_rms['INST_FIN' ]!=None : tfin=i_rms['INST_FIN' ]
 150          else                        : tfin=__ff.vale_x[-1]
 151          __ff=__ff.cut(tini,__ff.vale_x[-1],i_rms['PRECISION'],i_rms['CRITERE'])
 152          __ff=__ff.cut(__ff.vale_x[0],tfin,i_rms['PRECISION'],i_rms['CRITERE'])
 153          __ff=__ff*__ff
 154          if i_rms['METHODE'  ]=='SIMPSON' : __ez=__ff.simpson(0.)
 155          if i_rms['METHODE'  ]=='TRAPEZE' :
 156             __ez=__ff.trapeze(0.)
 157          sigm.append(math.sqrt(__ez.vale_y[-1]/(__ff.vale_x[-1]-__ff.vale_x[0])))
 158          tmpi.append(tini)
 159          tmpf.append(tfin)
 160          nomf.append(i_rms['FONCTION'].nom)
 161          meth.append(i_rms['METHODE'])
 162      C_out=CREA_TABLE(LISTE=(_F(LISTE_K=nomf ,PARA='FONCTION'),
 163                              _F(LISTE_K=meth ,PARA='METHODE'),
 164                              _F(LISTE_R=tmpi ,PARA='INST_INIT'),
 165                              _F(LISTE_R=tmpf ,PARA='INST_FIN'),
 166                              _F(LISTE_R=sigm ,PARA='RMS'), )
 167                      )
 168
 169   ###
 170   if (NORME != None):
 171      __ff=NORME['FONCTION'].convert()
 172      norme=[]
 173      for __fi in __ff.l_fonc :
 174          norme.append(__fi.normel2())
 175      nom=[NORME['FONCTION'].nom,]*len(norme)
 176      C_out=CREA_TABLE(LISTE=(_F(LISTE_R=norme ,PARA='NORME'),
 177                              _F(LISTE_K=nom   ,PARA='FONCTION'), )
 178                      )
 179
 180   ###
 181   if (NOCI_SEISME != None):
 182      l_table=[]
 183      if NOCI_SEISME['SPEC_OSCI'] !=None :
 184         ### cas intensité spectrale d'une nappe de SRO
 185         ### la seule option licite est INTE_SPEC
 186 #intensite spectrale, il est prudent de verifier la norme de la nappe sur laquelle \
 187 #porte le calcul, ceci peut etre une source d erreurs.''')
 188         UTMESS('I','FONCT0_40')
 189         amor=NOCI_SEISME['AMOR_REDUIT']
 190         fini=NOCI_SEISME['FREQ_INIT'  ]
 191         ffin=NOCI_SEISME['FREQ_FIN'   ]
 192         __sp  =NOCI_SEISME['SPEC_OSCI'].convert()
 193         vale_x=__sp.l_fonc[0].vale_x
 194         vale_y=[__sp(amor,f) for f in vale_x]
 195         para  =__sp.l_fonc[0].para
 196         __srov=t_fonction(vale_x,vale_y,para)
 197         if   NOCI_SEISME['NATURE']=='DEPL' :
 198              __srov.vale_y=(__srov.vale_y/__srov.vale_x)*2.*math.pi
 199         elif NOCI_SEISME['NATURE']=='VITE' :
 200              __srov.vale_y=__srov.vale_y/__srov.vale_x/__srov.vale_x
 201         elif NOCI_SEISME['NATURE']=='ACCE' :
 202              __srov.vale_y=__srov.vale_y/__srov.vale_x/__srov.vale_x
 203              __srov.vale_y=__srov.vale_y/__srov.vale_x/2./math.pi
 204         __srov=__srov.cut(fini,ffin,NOCI_SEISME['PRECISION'],NOCI_SEISME['CRITERE'])
 205         insp=__srov.trapeze(0.).vale_y[-1]
 206         l_table.append(_F(LISTE_R=fini ,PARA='FREQ_INIT'  ))
 207         l_table.append(_F(LISTE_R=ffin ,PARA='FREQ_FIN'   ))
 208         l_table.append(_F(LISTE_R=amor ,PARA='AMOR_REDUIT'))
 209         l_table.append(_F(LISTE_R=insp ,PARA='INTE_SPECT' ))
 210      if NOCI_SEISME['FONCTION'] !=None :
 211         ### cas fonction
 212         l_table.append(_F(LISTE_K=NOCI_SEISME['FONCTION'].nom,PARA='FONCTION'))
 213         __ac=NOCI_SEISME['FONCTION'].convert()
 214         option= NOCI_SEISME['OPTION']
 215         if   NOCI_SEISME['INST_INIT']!=None : tdeb=NOCI_SEISME['INST_INIT']
 216         else                                : tdeb=__ac.vale_x[0]
 217         if   NOCI_SEISME['INST_FIN' ]!=None : tfin=NOCI_SEISME['INST_FIN' ]
 218         else                                : tfin=__ac.vale_x[-1]
 219         # calcul de la vitesse :
 220         __vi=__ac.trapeze(NOCI_SEISME['COEF'])
 221         # calcul du déplacement :
 222         __de=__vi.trapeze(NOCI_SEISME['COEF'])
 223         # calcul de |acceleration| :
 224         __aa=__ac.abs()
 225         # calcul de integrale(|acceleration|) :
 226         ### on "coupe" la fonction entre tdeb et tfin
 227         __ac=__ac.cut(tdeb,tfin,NOCI_SEISME['PRECISION'],NOCI_SEISME['CRITERE'])
 228         __vi=__vi.cut(tdeb,tfin,NOCI_SEISME['PRECISION'],NOCI_SEISME['CRITERE'])
 229         __de=__de.cut(tdeb,tfin,NOCI_SEISME['PRECISION'],NOCI_SEISME['CRITERE'])
 230         __aa=__aa.cut(tdeb,tfin,NOCI_SEISME['PRECISION'],NOCI_SEISME['CRITERE'])
 231         if   NOCI_SEISME['FREQ'     ]!=None : l_freq=NOCI_SEISME['FREQ']
 232         elif NOCI_SEISME['LIST_FREQ']!=None : l_freq=NOCI_SEISME['LIST_FREQ'].Valeurs()
 233         else                                :
 234            # fréquences par défaut
 235            l_freq=[]
 236            for i in range(56) : l_freq.append( 0.2+0.050*i)
 237            for i in range( 8) : l_freq.append( 3.0+0.075*i)
 238            for i in range(14) : l_freq.append( 3.6+0.100*i)
 239            for i in range(24) : l_freq.append( 5.0+0.125*i)
 240            for i in range(28) : l_freq.append( 8.0+0.250*i)
 241            for i in range( 6) : l_freq.append(15.0+0.500*i)
 242            for i in range( 4) : l_freq.append(18.0+1.000*i)
 243            for i in range(10) : l_freq.append(22.0+1.500*i)
 244         if option in('TOUT','MAXI','ACCE_SUR_VITE') :
 245            #   calcul du max des valeurs absolues
 246            maxa_ac=__ac.abs().extreme()['max'][0][1]
 247            maxa_vi=__vi.abs().extreme()['max'][0][1]
 248            maxa_de=__de.abs().extreme()['max'][0][1]
 249            l_table.append(_F(LISTE_R=maxa_ac,PARA='ACCE_MAX'))
 250            l_table.append(_F(LISTE_R=maxa_vi,PARA='VITE_MAX'))
 251            l_table.append(_F(LISTE_R=maxa_de,PARA='DEPL_MAX'))
 252            l_table.append(_F(LISTE_R=maxa_ac/maxa_vi,PARA='ACCE_SUR_VITE'))
 253         if option in('TOUT','INTE_ARIAS') :
 254            __a2=__ac*__ac
 255            inte_arias=__a2.trapeze(0.).vale_y[-1]
 256            inte_arias=inte_arias*math.pi/NOCI_SEISME['PESANTEUR']/2.
 257            l_table.append(_F(LISTE_R=inte_arias,PARA='INTE_ARIAS'))
 258         if option in('TOUT','POUV_DEST') :
 259            __v2=__vi*__vi
 260            pouv_dest=__v2.trapeze(0.).vale_y[-1]
 261            pouv_dest=pouv_dest*(math.pi)**3/NOCI_SEISME['PESANTEUR']/2.
 262            l_table.append(_F(LISTE_R=pouv_dest,PARA='POUV_DEST'))
 263         if option in('TOUT','VITE_ABSO_CUMU') :
 264            __vc=__aa.trapeze(0.)
 265            vite_abso=__vc.vale_y[-1]
 266            l_table.append(_F(LISTE_R=vite_abso,PARA='VITE_ABSO_CUMU'))
 267         if option in('TOUT','INTE_SPEC') :
 268            amor=NOCI_SEISME['AMOR_REDUIT']
 269            fini=NOCI_SEISME['FREQ_INIT'  ]
 270            ffin=NOCI_SEISME['FREQ_FIN'   ]
 271            __so= CALC_FONCTION(SPEC_OSCI=_F(
 272                                       NATURE     ='VITE',
 273                                       NATURE_FONC='ACCE',
 274                                       FONCTION   =NOCI_SEISME['FONCTION'],
 275                                       METHODE    ='NIGAM',
 276                                       NORME      =NOCI_SEISME['NORME'],
 277                                       FREQ       =l_freq,
 278                                       AMOR_REDUIT=(amor,)
 279                                       ), )
 280            __srov=__so.convert().l_fonc[0]
 281            __srov=__srov.cut(fini,ffin,NOCI_SEISME['PRECISION'],NOCI_SEISME['CRITERE'])
 282            __srov.vale_y=__srov.vale_y/__srov.vale_x/__srov.vale_x
 283            insp=__srov.trapeze(0.).vale_y[-1]
 284            l_table.append(_F(LISTE_R=fini ,PARA='FREQ_INIT'  ))
 285            l_table.append(_F(LISTE_R=ffin ,PARA='FREQ_FIN'   ))
 286            l_table.append(_F(LISTE_R=amor ,PARA='AMOR_REDUIT'))
 287            l_table.append(_F(LISTE_R=insp ,PARA='INTE_SPECT' ))
 288         if option in('TOUT','DUREE_PHAS_FORT') :
 289            __a2=__ac*__ac
 290            __i2=__a2.trapeze(0.)
 291            arias = __i2.vale_y[-1]*math.pi/NOCI_SEISME['PESANTEUR']/2.
 292            valinf = arias * NOCI_SEISME['BORNE_INF']
 293            valsup = arias * NOCI_SEISME['BORNE_SUP']
 294            for i in range(len(__i2.vale_x)) :
 295                ariask = __i2.vale_y[i]*math.pi/NOCI_SEISME['PESANTEUR']/2.
 296                if ariask>=valinf : break
 297            for j in range(len(__i2.vale_x)-1,-1,-1) :
 298                ariask = __i2.vale_y[j]*math.pi/NOCI_SEISME['PESANTEUR']/2.
 299                if ariask<=valsup : break
 300            dphfor = __i2.vale_x[j] - __i2.vale_x[i]
 301            l_table.append(_F(LISTE_R=dphfor,PARA='DUREE_PHAS_FORT'))
 302      C_out=CREA_TABLE(LISTE=l_table)
 303
 304   if INFO > 1:
 305      IMPR_TABLE(UNITE=6,
 306                 TABLE=C_out)
 307   return ier