Aster/Cata/cataSTA10/Macro/macro_elas_mult_ops.py

   1 #@ MODIF macro_elas_mult_ops Macro  DATE 23/03/2010   AUTEUR COURTOIS M.COURTOIS
   2 # -*- coding: iso-8859-1 -*-
   3 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   4 # ======================================================================
   5 # COPYRIGHT (C) 1991 - 2002  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
  22
  23 def macro_elas_mult_ops(self,MODELE,CHAM_MATER,CARA_ELEM,NUME_DDL,
  24                         CHAR_MECA_GLOBAL,LIAISON_DISCRET,
  25                         CAS_CHARGE,SOLVEUR,**args):
  26   """
  27      Ecriture de la macro MACRO_ELAS_MULT
  28   """
  29   ier=0
  30   import types
  31   from Accas import _F
  32   from Utilitai.Utmess     import UTMESS
  33
  34   # On met le mot cle NUME_DDL dans une variable locale pour le proteger
  35   numeddl=NUME_DDL
  36   # On importe les definitions des commandes a utiliser dans la macro
  37   CALC_MATR_ELEM  =self.get_cmd('CALC_MATR_ELEM')
  38   NUME_DDL        =self.get_cmd('NUME_DDL')
  39   ASSE_MATRICE    =self.get_cmd('ASSE_MATRICE')
  40   FACTORISER      =self.get_cmd('FACTORISER')
  41   CALC_VECT_ELEM  =self.get_cmd('CALC_VECT_ELEM')
  42   ASSE_VECTEUR    =self.get_cmd('ASSE_VECTEUR')
  43   RESOUDRE        =self.get_cmd('RESOUDRE')
  44   CREA_RESU       =self.get_cmd('CREA_RESU')
  45   CALC_ELEM       =self.get_cmd('CALC_ELEM')
  46   CALC_NO         =self.get_cmd('CALC_NO')
  47   # La macro compte pour 1 dans la numerotation des commandes
  48   self.set_icmd(1)
  49
  50   # Le concept sortant (de type mult_elas ou fourier_elas) est nommé
  51   # 'nomres' dans le contexte de la macro
  52
  53   self.DeclareOut('nomres',self.sd)
  54
  55   ielas = 0
  56   ifour = 0
  57   for m in CAS_CHARGE:
  58      if m['NOM_CAS']:
  59         ielas=1                 # mot clé NOM_CAS      présent sous CAS_CHARGE
  60         tyresu = 'MULT_ELAS'
  61      else:
  62         ifour=1                 # mot clé MODE_FOURIER présent sous CAS_CHARGE
  63         tyresu = 'FOURIER_ELAS'
  64   if ielas==1 and ifour==1:
  65      UTMESS('F','ELASMULT0_1')
  66
  67   if (numeddl in self.sdprods) or (numeddl==None):
  68     # Si le concept numeddl est dans self.sdprods ou n est pas nommé
  69     # il doit etre  produit par la macro
  70     # il faudra donc appeler la commande NUME_DDL
  71     lnume = 1
  72   else:
  73     lnume = 0
  74
  75   if ielas==1 :
  76      motscles={}
  77      if   CHAR_MECA_GLOBAL: motscles['CHARGE']    =CHAR_MECA_GLOBAL
  78      if   CHAM_MATER      : motscles['CHAM_MATER']=CHAM_MATER
  79      if   CARA_ELEM       : motscles['CARA_ELEM'] =CARA_ELEM
  80      __nomrig=CALC_MATR_ELEM(OPTION='RIGI_MECA',MODELE=MODELE,**motscles)
  81
  82      if lnume:
  83        # On peut passer des mots cles egaux a None. Ils sont ignores
  84        motscles={}
  85        if SOLVEUR:
  86           motscles['METHODE'] =SOLVEUR['METHODE']
  87           motscles['RENUM']   =SOLVEUR['RENUM']
  88        else:
  89           motscles['METHODE'] ='MULT_FRONT'
  90           motscles['RENUM']   ='METIS'
  91        if numeddl!=None:
  92           self.DeclareOut('num',numeddl)
  93           num=NUME_DDL(MATR_RIGI=__nomrig,**motscles)
  94        else:
  95           _num=NUME_DDL(MATR_RIGI=__nomrig,**motscles)
  96           num=_num
  97      else:
  98        num=numeddl
  99
 100      __nomras=ASSE_MATRICE(MATR_ELEM=__nomrig,NUME_DDL=num)
 101
 102      __nomraf=FACTORISER(MATR_ASSE=__nomras,NPREC=SOLVEUR['NPREC'],STOP_SINGULIER=SOLVEUR['STOP_SINGULIER'])
 103
 104 #####################################################################
 105 # boucle sur les items de CAS_CHARGE
 106
 107   nomchn=[]
 108   lcharg=[]
 109   iocc=0
 110   for m in CAS_CHARGE:
 111      iocc=iocc+1
 112
 113      # calcul de lcharg : liste des listes de char_meca (mots clé CHAR_MECA et CHAR_MECA_GLOBAL)
 114      xx1=m['CHAR_MECA']
 115      if type(xx1) != type((1,)) : xx1=(xx1,)
 116      xx2=CHAR_MECA_GLOBAL
 117      if type(xx2) != type((1,)) : xx2=(xx2,)
 118      lchar1=[]
 119      for chargt in (xx1+xx2) :
 120         if chargt : lchar1.append(chargt)
 121      lcharg.append(lchar1)
 122      assert len(lchar1) > 0
 123
 124
 125
 126      if ifour:
 127         motscles={}
 128         if   CHAR_MECA_GLOBAL: motscles['CHARGE']       =CHAR_MECA_GLOBAL
 129         if   CHAM_MATER      : motscles['CHAM_MATER']   =CHAM_MATER
 130         if   CARA_ELEM       : motscles['CARA_ELEM']    =CARA_ELEM
 131         motscles['MODE_FOURIER'] =m['MODE_FOURIER']
 132         __nomrig=CALC_MATR_ELEM(OPTION='RIGI_MECA',MODELE=MODELE,**motscles)
 133
 134         if lnume:
 135            _num=NUME_DDL(MATR_RIGI=__nomrig,METHODE=SOLVEUR['METHODE'],RENUM=SOLVEUR['RENUM'])
 136            num=_num
 137            lnume=0
 138
 139         __nomras=ASSE_MATRICE(MATR_ELEM=__nomrig,NUME_DDL=num)
 140
 141         __nomraf=FACTORISER(MATR_ASSE=__nomras,NPREC=SOLVEUR['NPREC'],STOP_SINGULIER=SOLVEUR['STOP_SINGULIER'])
 142
 143
 144      if m['VECT_ASSE']==None :
 145         motscles={}
 146         if   CHAM_MATER      : motscles['CHAM_MATER']   =CHAM_MATER
 147         if   CARA_ELEM       : motscles['CARA_ELEM']    =CARA_ELEM
 148         if   ifour           : motscles['MODE_FOURIER'] =m['MODE_FOURIER']
 149         if   len(lchar1) > 0 : motscles['CHARGE']       =lchar1
 150         __nomvel=CALC_VECT_ELEM(OPTION='CHAR_MECA',**motscles)
 151         __nomasv=ASSE_VECTEUR(VECT_ELEM=__nomvel,NUME_DDL=num)
 152      else :
 153         __nomasv=m['VECT_ASSE']
 154
 155
 156      __nomchn=RESOUDRE(MATR=__nomraf,CHAM_NO=__nomasv,TITRE=m['SOUS_TITRE'])
 157      nomchn.append(__nomchn)
 158
 159 # fin de la boucle sur les items de CAS_CHARGE
 160 #####################################################################
 161
 162   motscles={}
 163   iocc=0
 164   motscle2={}
 165   if CHAM_MATER : motscle2['CHAM_MATER']=CHAM_MATER
 166   if CARA_ELEM  : motscle2['CARA_ELEM']=CARA_ELEM
 167   if ielas :
 168      motscles['AFFE']=[]
 169      for m in CAS_CHARGE:
 170         if len(lcharg[iocc]) > 0 :
 171            motscles['AFFE'].append(_F(MODELE=MODELE,
 172                                       CHAM_GD=nomchn[iocc],
 173                                       NOM_CAS=m['NOM_CAS'],
 174                                       CHARGE=lcharg[iocc],
 175                                       **motscle2) )
 176         else :
 177            motscles['AFFE'].append(_F(MODELE=MODELE,
 178                                       CHAM_GD=nomchn[iocc],
 179                                       NOM_CAS=m['NOM_CAS'],
 180                                       **motscle2) )
 181         iocc=iocc+1
 182   else :
 183      motscles['AFFE']=[]
 184      for m in CAS_CHARGE:
 185         if len(lcharg[iocc]) > 0 :
 186            motscles['AFFE'].append(_F(MODELE=MODELE,
 187                                       CHAM_GD=nomchn[iocc],
 188                                       NUME_MODE=m['MODE_FOURIER'],
 189                                       TYPE_MODE=m['TYPE_MODE'],
 190                                       CHARGE=lcharg[iocc],
 191                                       **motscle2) )
 192         else :
 193            motscles['AFFE'].append(_F(MODELE=MODELE,
 194                                       CHAM_GD=nomchn[iocc],
 195                                       NUME_MODE=m['MODE_FOURIER'],
 196                                       TYPE_MODE=m['TYPE_MODE'],
 197                                       **motscle2) )
 198         iocc=iocc+1
 199
 200   if self.reuse:
 201     motscles['reuse'] = self.reuse
 202   nomres=CREA_RESU(OPERATION='AFFE',TYPE_RESU=tyresu,NOM_CHAM='DEPL',**motscles)
 203
 204 #####################################################################
 205 # boucle sur les items de CAS_CHARGE pour CALC_ELEM et CALC_NO
 206
 207   iocc=0
 208   for m in CAS_CHARGE:
 209      iocc=iocc+1
 210
 211      if m['OPTION']:
 212         nbel=0
 213         nbno=0
 214         liste_el=[]
 215         liste_no=[]
 216         if type(m['OPTION'])==types.StringType:
 217            liste_option=(m['OPTION'],)
 218         else :
 219            liste_option=m['OPTION']
 220         for option in liste_option :
 221            if option in (     'FORC_NODA','REAC_NODA',
 222                               'EPSI_NOEU_DEPL','SIGM_NOEU_DEPL','EFGE_NOEU_DEPL',
 223                               'EQUI_NOEU_SIGM','EQUI_NOEU_EPSI',):
 224               nbno=nbno+1
 225               liste_no.append(option)
 226            else:
 227               nbel=nbel+1
 228               liste_el.append(option)
 229
 230         if nbel:
 231            motscles={}
 232            if ielas:
 233               motscles['NOM_CAS']=m['NOM_CAS']
 234            else:
 235               motscles['NUME_MODE']=m['MODE_FOURIER']
 236            CALC_ELEM(reuse=nomres,
 237                      RESULTAT=nomres,
 238                      REPE_COQUE=_F(NIVE_COUCHE=m['NIVE_COUCHE'],
 239                                    NUME_COUCHE=m['NUME_COUCHE'],),
 240                      OPTION=tuple(liste_el),
 241                      **motscles)
 242         if nbno:
 243            motscles={}
 244            if ielas:
 245               motscles['NOM_CAS']=m['NOM_CAS']
 246            else:
 247               motscles['NUME_MODE']=m['MODE_FOURIER']
 248            CALC_NO(reuse=nomres,
 249                    RESULTAT=nomres,
 250                    OPTION=tuple(liste_no),
 251                      **motscles)
 252
 253 # fin de la boucle sur les items de CAS_CHARGE
 254 #####################################################################
 255   return ier
 256