Aster/Cata/cataSTA9/Macro/post_k_trans_ops.py

   1 #@ MODIF post_k_trans_ops Macro  DATE 22/01/2008   AUTEUR REZETTE C.REZETTE
   2 # -*- coding: iso-8859-1 -*-
   3 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   4 # ======================================================================
   5 # COPYRIGHT (C) 1991 - 2006  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 def post_k_trans_ops(self,RESU_TRANS,K_MODAL,TOUT_ORDRE, NUME_ORDRE, LIST_ORDRE,
  22                  INST, LIST_INST,INFO,**args):
  23   """
  24      Ecriture de la macro post_k_trans
  25   """
  26   import aster
  27   import string
  28   from Accas import _F
  29   from Utilitai.Utmess     import  UTMESS
  30   from types import ListType, TupleType
  31   from Utilitai.Table      import Table, merge
  32   EnumTypes = (ListType, TupleType)
  33
  34   macro = 'POST_K_TRANS'
  35   ier=0
  36 #------------------------------------------------------------------
  37   # On importe les definitions des commandes a utiliser dans la macro
  38   CALC_G           =self.get_cmd('CALC_G'  )
  39   IMPR_TABLE       =self.get_cmd('IMPR_TABLE'      )
  40   CREA_TABLE       =self.get_cmd('CREA_TABLE'      )
  41
  42   # La macro compte pour 1 dans la numerotation des commandes
  43   self.set_icmd(1)
  44
  45   # Le concept sortant (de type table_sdaster ou dérivé) est tab
  46   self.DeclareOut('tabout', self.sd)
  47
  48 #------------------------------------------------------------------
  49   TABK = K_MODAL['TABL_K_MODA']
  50   F2D = K_MODAL['FOND_FISS']
  51   F3D = K_MODAL['FISSURE']
  52 #
  53 # Calcul du tableau des K modaux
  54 #
  55   if TABK == None :
  56     montit = 'Calcul des K modaux'
  57     resumod = K_MODAL['RESU_MODA']
  58     thet = K_MODAL['THETA']
  59
  60     motscles={}
  61     motscles2={}
  62     motscles['THETA'] = []
  63     mcthet = {}
  64     if F2D != None :    mcthet['FOND_FISS'] = F2D
  65     if thet != None :   mcthet['THETA'] = thet
  66     if F3D != None :   mcthet['FISSURE'] = F3D
  67     if K_MODAL['DIRECTION']!=None :  mcthet['DIRECTION'] = K_MODAL['DIRECTION']
  68     if K_MODAL['DIRE_THETA']!=None: mcthet['DIRE_THETA'] = K_MODAL['DIRE_THETA']
  69     if K_MODAL['R_SUP']!=None : mcthet['R_SUP'] = K_MODAL['R_SUP']
  70     if K_MODAL['R_SUP_FO']!=None : mcthet['R_SUP_FO'] = K_MODAL['R_SUP_FO']
  71     if K_MODAL['R_INF']!=None : mcthet['R_INF'] = K_MODAL['R_INF']
  72     if K_MODAL['R_INF_FO']!=None : mcthet['R_INF_FO'] = K_MODAL['R_INF_FO']
  73     if K_MODAL['MODULE']!=None : mcthet['MODULE'] = K_MODAL['MODULE']
  74     if K_MODAL['MODULE']==None and  F2D : mcthet['MODULE'] = 1
  75     if K_MODAL['MODULE_FO']!=None : mcthet['MODULE_FO'] = K_MODAL['MODULE_FO']
  76
  77     if thet == None and F3D :
  78         motscles2['LISSAGE'] = []
  79         if K_MODAL['LISSAGE_G'] == None :  K_MODAL['LISSAGE_G']='LEGENDRE'
  80         if K_MODAL['LISSAGE_THETA'] == None :  K_MODAL['LISSAGE_THETA']='LEGENDRE'
  81         if K_MODAL['DEGRE'] :   K_MODAL['DEGRE'] = 5
  82         motscles2['LISSAGE'].append(_F(LISSAGE_G =K_MODAL['LISSAGE_G'],
  83                         LISSAGE_THETA =K_MODAL['LISSAGE_G'],
  84                         DEGRE = K_MODAL['DEGRE'] ))
  85
  86     __kgtheta = CALC_G(       RESULTAT   = resumod,
  87                             OPTION = 'K_G_MODA',
  88                             TOUT_MODE = 'OUI',
  89                             INFO       = INFO,
  90                             TITRE      = montit,
  91                             THETA=mcthet,
  92                             **motscles2)
  93
  94
  95 #
  96 # Recuperation du tableau des K modaux
  97 #
  98   else :
  99     __kgtheta=TABK
 100
 101 #-----------------------------------------
 102 #
 103 # Verification de cohérence sur le nombre de modes
 104 #
 105 # RESULTAT TRANSITOIRE
 106   nomresu=RESU_TRANS.nom
 107   coef=aster.getvectjev(nomresu.ljust(19)+'.DEPL')
 108   nmodtr=aster.getvectjev(nomresu.ljust(19)+'.DESC')[1]
 109 # BASE MODALE
 110   if F2D :
 111     n_mode = len((__kgtheta.EXTR_TABLE())['K1'])
 112     nbno = 1
 113   if F3D :
 114     n_mode = max((__kgtheta.EXTR_TABLE())['NUME_MODE'].values()['NUME_MODE'])
 115     nbno = max((__kgtheta.EXTR_TABLE())['NUM_PT'].values()['NUM_PT'])
 116     labsc = (__kgtheta.EXTR_TABLE())['ABS_CURV'].values()['ABS_CURV'][0:nbno]
 117
 118   if nmodtr != n_mode :
 119       n_mode = min(nmodtr,n_mode)
 120       UTMESS('A','RUPTURE0_50',valk=nomresu,vali=n_mode)
 121
 122 #
 123 # Traitement des mots clés ORDRE/INST/LIST_INST et LIST_ORDRE
 124 #
 125   l0_inst = aster.getvectjev(nomresu.ljust(19)+'.INST')
 126   l0_ord = aster.getvectjev(nomresu.ljust(19)+'.ORDR')
 127   nbtrans = len(l0_ord)
 128   li =  [[l0_ord[i],l0_inst[i]] for i in range(nbtrans)]
 129   ln =  [[l0_ord[i],i] for i in range(nbtrans)]
 130   lo =  [[l0_inst[i],l0_ord[i]] for i in range(nbtrans)]
 131   li = [(i[0],i[1:]) for i in li]
 132   ln = [(i[0],i[1:]) for i in ln]
 133   lo = [(i[0],i[1:]) for i in lo]
 134   d_ord = dict(lo)
 135   d_ins = dict(li)
 136   d_num = dict(ln)
 137
 138
 139   l_ord =[]
 140   l_inst =[]
 141   if LIST_ORDRE or NUME_ORDRE :
 142     if  NUME_ORDRE  :
 143       if type(NUME_ORDRE) not in EnumTypes : NUME_ORDRE=(NUME_ORDRE,)
 144       ltmp = list(NUME_ORDRE)
 145     elif LIST_ORDRE :
 146       ltmp = aster.getvectjev(string.ljust(LIST_ORDRE.nom,19)+'.VALE')
 147     for ord in ltmp :
 148       if ord in l0_ord :
 149          l_ord.append(ord)
 150          l_inst.append(d_ins[ord][0])
 151       else :
 152          UTMESS('A','RUPTURE0_51',vali=ord,valk=nomresu)
 153   elif LIST_INST or INST :
 154     CRITERE = args['CRITERE']
 155     PRECISION = args['PRECISION']
 156     if INST :
 157       if type(INST) not in EnumTypes : INST=(INST,)
 158       ltmp = list(INST)
 159     elif LIST_INST :
 160       ltmp = aster.getvectjev(string.ljust(LIST_INST.nom,19)+'.VALE')
 161     for ins in ltmp :
 162       if CRITERE=='RELATIF' and ins!=0.: match=[x for x in l0_inst if abs((ins-x)/ins)<PRECISION]
 163       else                             : match=[x for x in l0_inst if abs(ins-x)<PRECISION]
 164       if len(match)==0 :
 165          UTMESS('A','RUPTURE0_38',valr=ins)
 166       elif len(match)>=2 :
 167          UTMESS('A','RUPTURE0_39',valr=ins)
 168       else :
 169          l_inst.append(match[0])
 170          l_ord.append(d_ord[match[0]][0])
 171   else :
 172       l_ord = l0_ord
 173       l_inst = l0_inst
 174   nbarch = len(l_ord)
 175   if nbarch ==0 : UTMESS('F','RUPTURE0_54')
 176
 177
 178 #
 179 # Calcul des K(t)
 180 #
 181
 182   K1mod = [None]*n_mode*nbno
 183   K2mod = [None]*n_mode*nbno
 184   K1t = [None]*nbarch*nbno
 185   K2t = [None]*nbarch*nbno
 186   if F3D :
 187     K3mod = [None]*n_mode*nbno
 188     K3t = [None]*nbarch*nbno
 189     k1 = 'K1_LOCAL'
 190     k2 = 'K2_LOCAL'
 191     k3 = 'K3_LOCAL'
 192   else :
 193     k1 = 'K1'
 194     k2 = 'K2'
 195
 196
 197   for x in range(0,nbno) :
 198     for k in range(0,n_mode) :
 199       K1mod[k*nbno + x] = __kgtheta[k1,k*nbno + x+1]
 200       K2mod[k*nbno + x] = __kgtheta[k2,k*nbno + x+1]
 201       if F3D : K3mod[k*nbno + x] = __kgtheta[k3,k*nbno + x+1]
 202
 203     for num in range(0,nbarch) :
 204       K1t[num*nbno + x] = 0.0
 205       K2t[num*nbno + x] = 0.0
 206       if F3D : K3t[num*nbno + x] = 0.0
 207       for k in range(0,n_mode) :
 208         num_ord = d_num[l_ord[num]][0]
 209         alpha = coef[n_mode*num_ord+k]
 210         K1t[num*nbno + x] = K1t[num*nbno + x] + alpha*K1mod[k*nbno + x]
 211         K2t[num*nbno + x] = K2t[num*nbno + x] + alpha*K2mod[k*nbno + x]
 212         if F3D : K3t[num*nbno + x] = K3t[num*nbno + x] + alpha*K3mod[k*nbno + x]
 213
 214   v = aster.__version__
 215   titre = 'ASTER %s - CONCEPT CALCULE PAR POST_K_TRANS LE &DATE A &HEURE \n'%v
 216   if F2D :
 217     tabout = CREA_TABLE(LISTE = (_F(LISTE_I =l_ord, PARA = 'NUME_ORDRE'),
 218                            _F(LISTE_R =l_inst, PARA = 'INST'),
 219                            _F(LISTE_R =K1t, PARA = k1),
 220                            _F(LISTE_R =K2t, PARA = k2),),
 221                         TITRE = titre,  );
 222   if F3D :
 223    lo = []
 224    li = []
 225    for i in range(nbarch) :
 226      for j in range(nbno) :
 227         lo.append(l_ord[i])
 228         li.append(l_inst[i])
 229    tabout = CREA_TABLE(LISTE = (_F(LISTE_I =lo, PARA = 'NUME_ORDRE'),
 230                            _F(LISTE_R =li, PARA = 'INST'),
 231                            _F(LISTE_I =range(nbno)*nbarch, PARA ='NUM_PT' ),
 232                            _F(LISTE_R =labsc*nbarch, PARA = 'ABS_CURV'),
 233                            _F(LISTE_R =K1t, PARA = k1),
 234                            _F(LISTE_R =K2t, PARA = k2),
 235                            _F(LISTE_R =K3t, PARA = k3),),
 236                         TITRE = titre,
 237                   );
 238
 239 #------------------------------------------------------------------
 240   return ier