Aster/Cata/cataSTA9/Macro/macro_elas_mult_ops.py

   1 #@ MODIF macro_elas_mult_ops Macro  DATE 03/02/2010   AUTEUR MACOCCO K.MACOCCO
   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
 123      if ifour:
 124         motscles={}
 125         if   CHAR_MECA_GLOBAL: motscles['CHARGE']       =CHAR_MECA_GLOBAL
 126         if   CHAM_MATER      : motscles['CHAM_MATER']   =CHAM_MATER
 127         if   CARA_ELEM       : motscles['CARA_ELEM']    =CARA_ELEM
 128         motscles['MODE_FOURIER'] =m['MODE_FOURIER']
 129         __nomrig=CALC_MATR_ELEM(OPTION='RIGI_MECA',MODELE=MODELE,**motscles)
 130
 131         if lnume:
 132            _num=NUME_DDL(MATR_RIGI=__nomrig,METHODE=SOLVEUR['METHODE'],RENUM=SOLVEUR['RENUM'])
 133            num=_num
 134            lnume=0
 135
 136         __nomras=ASSE_MATRICE(MATR_ELEM=__nomrig,NUME_DDL=num)
 137
 138         __nomraf=FACTORISER(MATR_ASSE=__nomras,NPREC=SOLVEUR['NPREC'],STOP_SINGULIER=SOLVEUR['STOP_SINGULIER'])
 139
 140
 141      if m['VECT_ASSE']==None :
 142         motscles={}
 143         if   CHAM_MATER      : motscles['CHAM_MATER']   =CHAM_MATER
 144         if   CARA_ELEM       : motscles['CARA_ELEM']    =CARA_ELEM
 145         if   ifour           : motscles['MODE_FOURIER'] =m['MODE_FOURIER']
 146         if   len(lchar1) > 0 : motscles['CHARGE']       =lchar1
 147         __nomvel=CALC_VECT_ELEM(OPTION='CHAR_MECA',**motscles)
 148         __nomasv=ASSE_VECTEUR(VECT_ELEM=__nomvel,NUME_DDL=num)
 149      else :
 150         __nomasv=m['VECT_ASSE']
 151
 152
 153      __nomchn=RESOUDRE(MATR=__nomraf,CHAM_NO=__nomasv,TITRE=m['SOUS_TITRE'])
 154      nomchn.append(__nomchn)
 155
 156 # fin de la boucle sur les items de CAS_CHARGE
 157 #####################################################################
 158
 159   motscles={}
 160   iocc=0
 161   motscle2={}
 162   if CHAM_MATER : motscle2['CHAM_MATER']=CHAM_MATER
 163   if CARA_ELEM  : motscle2['CARA_ELEM']=CARA_ELEM
 164   if CHAM_MATER or CARA_ELEM :
 165     if ielas :
 166        motscles['AFFE']=[]
 167        for m in CAS_CHARGE:
 168           motscles['AFFE'].append(_F(MODELE=MODELE,
 169                                      CHAM_GD=nomchn[iocc],
 170                                      NOM_CAS=m['NOM_CAS'],
 171                                      **motscle2) )
 172           iocc=iocc+1
 173     else :
 174        motscles['AFFE']=[]
 175        for m in CAS_CHARGE:
 176           motscles['AFFE'].append(_F(MODELE=MODELE,
 177                                      CHAM_GD=nomchn[iocc],
 178                                      NUME_MODE=m['MODE_FOURIER'],
 179                                      TYPE_MODE=m['TYPE_MODE'],
 180                                      **motscle2) )
 181           iocc=iocc+1
 182   else:
 183     if ielas :
 184        motscles['AFFE']=[]
 185        for m in CAS_CHARGE:
 186           motscles['AFFE'].append(_F(MODELE=MODELE,
 187                                      CHAM_GD=nomchn[iocc],
 188                                      NOM_CAS=m['NOM_CAS'],) )
 189           iocc=iocc+1
 190     else :
 191        motscles['AFFE']=[]
 192        for m in CAS_CHARGE:
 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           iocc=iocc+1
 198
 199
 200   nomres=CREA_RESU(OPERATION='AFFE',TYPE_RESU=tyresu,NOM_CHAM='DEPL',**motscles)
 201
 202 #####################################################################
 203 # boucle sur les items de CAS_CHARGE pour CALC_ELEM ete CALC_NO
 204
 205   iocc=0
 206   for m in CAS_CHARGE:
 207      lchar1=lcharg[iocc]
 208      iocc=iocc+1
 209
 210      if m['OPTION']:
 211         nbel=0
 212         nbno=0
 213         liste_el=[]
 214         liste_no=[]
 215         if type(m['OPTION'])==types.StringType:
 216            if m['OPTION'] in ('FORC_NODA','REAC_NODA',
 217                               'EPSI_NOEU_DEPL','SIGM_NOEU_DEPL','EFGE_NOEU_DEPL',
 218                               'EQUI_NOEU_SIGM','EQUI_NOEU_EPSI','FLUX_NOEU_TEMP',):
 219               nbno=nbno+1
 220               liste_no.append(m['OPTION'])
 221            else:
 222               nbel=nbel+1
 223               liste_el.append(m['OPTION'])
 224         else:
 225            for opt in m['OPTION']:
 226               if opt in ('FORC_NODA','REAC_NODA',
 227                          'EPSI_NOEU_DEPL','SIGM_NOEU_DEPL','EFGE_NOEU_DEPL',
 228                          'EQUI_NOEU_SIGM','EQUI_NOEU_EPSI','FLUX_NOEU_TEMP',):
 229                  nbno=nbno+1
 230                  liste_no.append(opt)
 231               else:
 232                  nbel=nbel+1
 233                  liste_el.append(opt)
 234
 235         lreac=0
 236         if nbel:
 237            motscles={}
 238            if   CHAM_MATER : motscles['CHAM_MATER'] =CHAM_MATER
 239            if   CARA_ELEM  : motscles['CARA_ELEM']  =CARA_ELEM
 240            if ielas:
 241               motscles['NOM_CAS']=m['NOM_CAS']
 242            else:
 243               motscles['NUME_MODE']=m['MODE_FOURIER']
 244            motscles['EXCIT']=[]
 245            for chargt in lchar1   : motscles['EXCIT'].append(_F(CHARGE=chargt))
 246            CALC_ELEM(reuse=nomres,
 247                      RESULTAT=nomres,
 248                      REPE_COQUE=_F(NIVE_COUCHE=m['NIVE_COUCHE'],
 249                                    NUME_COUCHE=m['NUME_COUCHE'],),
 250                      OPTION=tuple(liste_el),
 251                      **motscles)
 252         if nbno:
 253            motscles={}
 254            if   CHAM_MATER : motscles['CHAM_MATER'] =CHAM_MATER
 255            if   CARA_ELEM  : motscles['CARA_ELEM']  =CARA_ELEM
 256            if ielas:
 257               motscles['NOM_CAS']=m['NOM_CAS']
 258            else:
 259               motscles['NUME_MODE']=m['MODE_FOURIER']
 260            motscles['EXCIT']=[]
 261            for chargt in lchar1   : motscles['EXCIT'].append(_F(CHARGE=chargt))
 262            CALC_NO(reuse=nomres,
 263                    RESULTAT=nomres,
 264                    OPTION=tuple(liste_no),
 265                    **motscles)
 266
 267 # fin de la boucle sur les items de CAS_CHARGE
 268 #####################################################################
 269   return ier
 270