Aster/Cata/cataSTA9/Macro/calc_precont_ops.py

   1 #@ MODIF calc_precont_ops Macro  DATE 31/03/2008   AUTEUR ASSIRE A.ASSIRE
   2 # -*- coding: iso-8859-1 -*-
   3 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   4 # ======================================================================
   5 # COPYRIGHT (C) 1991 - 2003  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 # RESPONSABLE ASSIRE A.ASSIRE
  23
  24 def calc_precont_ops(self,reuse,MODELE,CHAM_MATER,CARA_ELEM,EXCIT,
  25                                 CABLE_BP,CABLE_BP_INACTIF,
  26                                 COMP_INCR,ETAT_INIT,NEWTON,RECH_LINEAIRE,
  27                                 CONVERGENCE,INCREMENT,SOLVEUR,
  28                                 INFO,TITRE,**args):
  29
  30
  31   """
  32      Ecriture de la macro CALC_PRECONT
  33   """
  34   import copy
  35   import aster
  36   import string
  37   import types
  38   from Accas import _F
  39   from Noyau.N_utils import AsType
  40   from Utilitai.Utmess     import  UTMESS
  41   ier=0
  42
  43   # On importe les definitions des commandes a utiliser dans la macro
  44   AFFE_MODELE      = self.get_cmd('AFFE_MODELE')
  45   CREA_CHAMP       = self.get_cmd('CREA_CHAMP')
  46   AFFE_CHAR_MECA   = self.get_cmd('AFFE_CHAR_MECA')
  47   DEFI_LIST_REEL   = self.get_cmd('DEFI_LIST_REEL')
  48   STAT_NON_LINE    = self.get_cmd('STAT_NON_LINE')
  49   CALC_NO          = self.get_cmd('CALC_NO')
  50   CREA_CHAMP       = self.get_cmd('CREA_CHAMP')
  51   DEFI_FONCTION    = self.get_cmd('DEFI_FONCTION')
  52   RECU_TABLE       = self.get_cmd('RECU_TABLE')
  53   DEFI_MATERIAU    = self.get_cmd('DEFI_MATERIAU')
  54   AFFE_MATERIAU    = self.get_cmd('AFFE_MATERIAU')
  55
  56   # La macro compte pour 1 dans la numerotation des commandes
  57   self.set_icmd(1)
  58
  59   # Le concept sortant (de type evol_noli) est nomme RES dans
  60   # le contexte de la macro
  61
  62   self.DeclareOut('RES',self.sd)
  63
  64   # -------------------------------------------------------------
  65   # 1. CREATION DES MOTS-CLES ET CONCEPTS POUR LES STAT_NON_LINE
  66   # ------------------------------------------------------------
  67
  68
  69   # 1.1 Recuperation de la liste d'instants, de l'instant initial et final
  70   #     Creation de la nouvelle liste d'instants
  71   # ----------------------------------------------------------
  72
  73   dIncrement=INCREMENT[0].cree_dict_valeurs(INCREMENT[0].mc_liste)
  74
  75   __prec = dIncrement['PRECISION']
  76   __L0   = dIncrement['LIST_INST']
  77   __L1   = __L0.Valeurs()
  78
  79   # Traitement de l'etat initial
  80   if ETAT_INIT:
  81       dEtatInit=ETAT_INIT[0].cree_dict_valeurs(ETAT_INIT[0].mc_liste)
  82       for i in dEtatInit.keys():
  83           if dEtatInit[i]==None : del dEtatInit[i]
  84
  85       __EVINIT = dEtatInit['EVOL_NOLI']
  86   else :
  87       dEtatInit=None
  88
  89   # Test de la presence de reuse=
  90   if self.reuse == None:
  91       dReuse=None
  92   else :
  93       dReuse='RES'
  94
  95   # Teste si INST_INIT est donné ou bien recalcule __TMIN
  96   if dIncrement['INST_INIT'] == None:
  97     if self.reuse == None:
  98       __TMIN = __L1[0]
  99     else:
 100       __dico = __EVINIT.LIST_VARI_ACCES()
 101       __TMIN = __dico['INST'][-1]
 102   else:
 103     __TMIN = dIncrement['INST_INIT']
 104
 105   # Teste si INST_FIN est donné ou bien recalcule __TMAX
 106   if dIncrement['INST_FIN'] == None:
 107     __TMAX = __L1[-1]
 108   else:
 109     __TMAX = dIncrement['INST_FIN']
 110
 111   # Teste si INST_INIT est bien plus petit que INST_FIN
 112   if __TMAX <= __TMIN:
 113     UTMESS('F','CABLE0_1')
 114
 115   # Cree la liste d'instant __L2 allant de __TMIN a __TMAX et contenant
 116   # un instant supplementaire __TINT
 117   __L2=[]
 118   for m in __L1:
 119     if m>=__TMIN and m<=__TMAX:
 120       __L2.append(m)
 121
 122   __TINT = (9.*__L2[-1] + __L2[-2])/10.
 123   __L2[-1:-1] = [__TINT]
 124
 125   # __LST0 est la liste d'instants utilisée pour l'etape 1
 126   __LST0=DEFI_LIST_REEL( DEBUT = __TMIN,
 127                         INTERVALLE = _F(JUSQU_A = __TMAX, NOMBRE = 1),)
 128
 129   # __LST et __FCT sont utilisés pour les etapes 2 et 3
 130   __LST=DEFI_LIST_REEL(VALE=__L2,);
 131   __FCT=DEFI_FONCTION(INTERPOL=('LIN','LIN'),
 132                          NOM_PARA='INST',
 133                          VALE=(__TMIN,0.0,__TINT,1.0,__TMAX,1.0),);
 134
 135   for i in dIncrement.keys():
 136       if dIncrement[i]==None : del dIncrement[i]
 137   dIncrement['LIST_INST']= __LST
 138   dIncrement['INST_FIN'] = __TINT
 139
 140
 141
 142   # 1.2 Recuperation des parametres pour STAT_NON_LINE
 143   # -------------------------------------------------------
 144
 145   dNewton=NEWTON[0].cree_dict_valeurs(NEWTON[0].mc_liste)
 146   for i in dNewton.keys():
 147       if dNewton[i]==None : del dNewton[i]
 148
 149   dConvergence=CONVERGENCE[0].cree_dict_valeurs(CONVERGENCE[0].mc_liste)
 150   for i in dConvergence.keys():
 151       if dConvergence[i]==None : del dConvergence[i]
 152
 153   dSolveur=SOLVEUR[0].cree_dict_valeurs(SOLVEUR[0].mc_liste)
 154   for i in dSolveur.keys():
 155       if dSolveur[i]==None : del dSolveur[i]
 156
 157   if RECH_LINEAIRE:
 158     dRech_lin=RECH_LINEAIRE[0].cree_dict_valeurs(RECH_LINEAIRE[0].mc_liste)
 159     for i in dRech_lin.keys():
 160         if dRech_lin[i]==None : del dRech_lin[i]
 161   else :
 162     dRech_lin=None
 163
 164
 165   # 1.3 Creation des mots-cles pour les 3 AFFE_CHAR_MECA
 166   #     Recuperation des cables dans les concepts CABLE_BP
 167   #     et CABLE_BP_INACTIF
 168   # ------------------------------------------------------
 169   if type(CABLE_BP) is not types.NoneType:
 170     if type(CABLE_BP) is not types.TupleType:
 171       CABLE_BP0 = CABLE_BP
 172       CABLE_BP = []
 173       CABLE_BP.append ( CABLE_BP0 )
 174
 175   if type(CABLE_BP_INACTIF) is not types.NoneType:
 176     if type(CABLE_BP_INACTIF) is not types.TupleType:
 177       CABLE_BP_INACTIF0 = CABLE_BP_INACTIF
 178       CABLE_BP_INACTIF = []
 179       CABLE_BP_INACTIF.append ( CABLE_BP_INACTIF0 )
 180
 181   motscles={}
 182   motscles['RELA_CINE_BP']=[]
 183   motscle2={}
 184   motscle2['RELA_CINE_BP']=[]
 185   motscle3={}
 186   motscle3['RELA_CINE_BP']=[]
 187   __GROUP_MA_A=[]
 188   Result = [[None]*1]
 189   for mcabl in CABLE_BP:
 190     # Creation de mots-cles pour les AFFE_CHAR_MECA
 191     motscles['RELA_CINE_BP'].append(_F(CABLE_BP=mcabl,
 192                                        SIGM_BPEL = 'OUI',
 193                                        RELA_CINE = 'NON',) )
 194     motscle2['RELA_CINE_BP'].append(_F(CABLE_BP=mcabl,
 195                                        SIGM_BPEL = 'NON',
 196                                        RELA_CINE = 'OUI',) )
 197     motscle3['RELA_CINE_BP'].append(_F(CABLE_BP=mcabl,
 198                                        SIGM_BPEL = 'OUI',
 199                                        RELA_CINE = 'OUI',) )
 200
 201     # Creation de __GROUP_MA_A : liste des noms des cables contenus
 202     # dans chaque concept CABLE_BP = cables  a activer
 203     __TCAB = RECU_TABLE(CO=mcabl,NOM_TABLE='CABLE_BP');
 204     __nb = 0
 205     while 1:
 206       try:
 207           Result[__nb][0] = __TCAB['NOM_CABLE',__nb+1]
 208           __CAB = __TCAB['NOM_CABLE',__nb+1]
 209           if __nb == 0:
 210             __GROUP_MA_A.append(__CAB)
 211           else:
 212             i = 0
 213             # enlève les doublons
 214             for m in __GROUP_MA_A:
 215               i=i+1
 216               if __CAB == m:
 217                 break
 218               if i == len(__GROUP_MA_A):
 219                 __GROUP_MA_A.append(__CAB)
 220
 221           __nb = __nb + 1
 222           Result.append([None]*1)
 223     #   Si on a lu toutes les valeurs alors on sort de la boucle
 224       except KeyError:
 225         break
 226
 227   # Creation de __GROUP_MA_I : liste des noms des cables contenus
 228   # dans chaque CABLE_BP_INACTIF
 229   # __GROUP_MA_CABLE = liste des cables actifs et inactifs
 230   Result = [[None]*1]
 231   __GROUP_MA_I=[]
 232
 233   if CABLE_BP_INACTIF:
 234     for mcabl in CABLE_BP_INACTIF:
 235       __TCA0 = RECU_TABLE(CO=mcabl,NOM_TABLE='CABLE_BP');
 236       __nb = 0
 237       while 1:
 238         try:
 239             Result[__nb][0] = __TCA0['NOM_CABLE',__nb+1]
 240             __CA0 = __TCA0['NOM_CABLE',__nb+1]
 241             if __nb == 0:
 242               __GROUP_MA_I.append(__CA0)
 243             else:
 244               i = 0
 245               # enlève les doublons
 246               for m in __GROUP_MA_I:
 247                 i=i+1
 248                 if __CA0 == m:
 249                   break
 250                 if i == len(__GROUP_MA_I):
 251                   __GROUP_MA_I.append(__CA0)
 252
 253             __nb = __nb + 1
 254             Result.append([None]*1)
 255       #   Si on a lu toutes les valeurs alors on sort de la boucle
 256         except KeyError:
 257           break
 258     motscle6={}
 259     motscle6['RELA_CINE_BP']=[]
 260     for mcabl in CABLE_BP_INACTIF:
 261       # Creation de mots-cles pour les AFFE_CHAR_MECA
 262       motscle6['RELA_CINE_BP'].append(_F(CABLE_BP=mcabl,
 263                                          SIGM_BPEL = 'NON',
 264                                          RELA_CINE = 'OUI',) )
 265
 266   __GROUP_MA_CABLES = __GROUP_MA_A + __GROUP_MA_I
 267
 268
 269   # 1.4 Creation des mots-clés facteurs COMP_INCR
 270   # pour étape 2 (dComp_incr0) et étape 3 (dComp_incr1)
 271   # ------------------------------------------------------
 272
 273   dComp_incr=[]
 274   for j in COMP_INCR :
 275       dComp_incr.append(j.cree_dict_valeurs(j.mc_liste))
 276       for i in dComp_incr[-1].keys():
 277           if dComp_incr[-1][i]==None : del dComp_incr[-1][i]
 278
 279   PARM_THETA=0.
 280   for j in range(len(COMP_INCR)) :
 281      if dComp_incr[j]['RELATION'] == 'ELAS':
 282         PARM_THETA=dComp_incr[j]['PARM_THETA']
 283
 284   if PARM_THETA == 0:
 285     PARM_THETA=dComp_incr[0]['PARM_THETA']
 286
 287   dComp_incr0=copy.copy(dComp_incr)
 288   dComp_incr1=copy.copy(dComp_incr)
 289
 290   dComp_incr0.append(_F(RELATION='SANS',GROUP_MA=__GROUP_MA_CABLES,) )
 291   if __GROUP_MA_I:
 292     dComp_incr1.append(_F(RELATION='SANS',GROUP_MA=__GROUP_MA_I,) )
 293
 294
 295   # 1.5 Modele contenant uniquement les cables de precontrainte
 296   # ---------------------------------------------------------
 297
 298   __MOD = string.ljust(MODELE.nom,8)
 299   __MOD =__MOD+'.MODELE    .LGRF        '
 300   __LMAIL = aster.getvectjev(__MOD)
 301   __MAIL  = string.strip(__LMAIL[0])
 302
 303   objma=self.get_sd_avant_etape(__MAIL,self)
 304
 305   __M_CA=AFFE_MODELE( MAILLAGE=objma,
 306                        AFFE    =_F( GROUP_MA     = __GROUP_MA_A,
 307                                     PHENOMENE    = 'MECANIQUE',
 308                                     MODELISATION = 'BARRE') )
 309
 310
 311   # 1.6 Blocage de tous les noeuds des cables actifs
 312   # --------------------------------------------------
 313
 314   _B_CA=AFFE_CHAR_MECA(MODELE=__M_CA,
 315                         DDL_IMPO= _F( GROUP_MA = __GROUP_MA_A,
 316                                       DX = 0.,
 317                                       DY = 0.,
 318                                       DZ = 0.),)
 319
 320
 321   # 1.7 Chargements concernant les cables
 322   # -------------------------------------
 323   _C_CN=AFFE_CHAR_MECA(MODELE=__M_CA,**motscles)
 324   _C_CA=AFFE_CHAR_MECA(MODELE=MODELE,**motscle2)
 325   _C_CT=AFFE_CHAR_MECA(MODELE=MODELE,**motscle3)
 326   if CABLE_BP_INACTIF:
 327     _C_CI=AFFE_CHAR_MECA(MODELE=MODELE,**motscle6)
 328
 329
 330
 331   # -------------------------------------------------------------
 332   # 2. CALCULS
 333   # ------------------------------------------------------------
 334
 335
 336   #-------------------------------------------------------------------
 337   # 2.1 Premiere etape : calcul sur le(s) cable(s) et
 338   #     recuperation des _F_CAs aux noeuds
 339   #     on travaile entre tmin et tmax
 340   #-------------------------------------------------------------------
 341
 342   __EV1=STAT_NON_LINE(
 343                          MODELE     = __M_CA,
 344                          CHAM_MATER = CHAM_MATER,
 345                          CARA_ELEM  = CARA_ELEM,
 346                          EXCIT      =(_F(CHARGE = _B_CA),
 347                                       _F(CHARGE = _C_CN),),
 348                          COMP_INCR  =_F( RELATION = 'ELAS',
 349                                          DEFORMATION = 'PETIT',
 350                                          PARM_THETA = PARM_THETA,
 351                                          TOUT = 'OUI'),
 352                          INCREMENT  =_F(LIST_INST = __LST0,
 353                                         PRECISION = __prec),
 354                          SOLVEUR = dSolveur,
 355                          INFO     =INFO,
 356                          TITRE = TITRE,  )
 357
 358   __EV1 = CALC_NO( reuse    = __EV1,
 359                    RESULTAT = __EV1,
 360                    GROUP_MA = __GROUP_MA_A,
 361                    OPTION = 'FORC_NODA' )
 362
 363   __REA = CREA_CHAMP (
 364                      TYPE_CHAM = 'NOEU_DEPL_R',
 365                      OPERATION = 'EXTR',
 366                      RESULTAT  =  __EV1,
 367                      NOM_CHAM  = 'FORC_NODA',
 368                      INST      = __TMAX);
 369
 370   __REAC = CREA_CHAMP (TYPE_CHAM='NOEU_DEPL_R',
 371                      OPERATION = 'ASSE',
 372                      MODELE    = MODELE,
 373                      ASSE= _F(GROUP_MA=__GROUP_MA_A,
 374                               CHAM_GD=__REA,
 375                               COEF_R = -1.), )
 376
 377   _F_CA=AFFE_CHAR_MECA(MODELE=__M_CA,
 378                           VECT_ASSE = __REAC )
 379
 380
 381
 382   #-----------------------------------------------------------------------
 383   # 2.2 Deuxieme etape : application de la precontrainte sur le beton
 384   #     en desactivant les cables
 385   #-----------------------------------------------------------------------
 386
 387   # Regeneration des mots-cles EXCIT passés en argument de la macro
 388   dExcit=[]
 389   for j in EXCIT :
 390       dExcit.append(j.cree_dict_valeurs(j.mc_liste))
 391       for i in dExcit[-1].keys():
 392           if dExcit[-1][i]==None : del dExcit[-1][i]
 393
 394   if CABLE_BP_INACTIF:
 395     dExcit.append(_F(CHARGE=_C_CI),)
 396
 397   # Creation du mots-cle EXCIT pour le STAT_NON_LINE
 398   dExcit1=copy.copy(dExcit)
 399   dExcit1.append(_F(CHARGE=_C_CA),)
 400   dExcit1.append(_F(CHARGE = _F_CA,
 401                     FONC_MULT=__FCT ),)
 402
 403   motscle4={}
 404   if dReuse: motscle4['reuse']=[]
 405   else:      motscle4['reuse']=dReuse
 406
 407
 408   RES=STAT_NON_LINE(
 409                      MODELE      =MODELE,
 410                      CARA_ELEM   =CARA_ELEM,
 411                      CHAM_MATER  = CHAM_MATER,
 412                      COMP_INCR=dComp_incr0,
 413                      INCREMENT=dIncrement,
 414                      ETAT_INIT = dEtatInit,
 415                      NEWTON =dNewton,
 416                      CONVERGENCE=dConvergence,
 417                      RECH_LINEAIRE = dRech_lin,
 418                      SOLVEUR = dSolveur,
 419                      ARCHIVAGE = _F(INST = __TINT),
 420                      INFO     =INFO,
 421                      TITRE = TITRE,
 422                      EXCIT = dExcit1,
 423                      **motscle4)
 424
 425   # Recuperation du dernier numero d'ordre pour pouvoir  l'écraser dans RES
 426   __dico2 = RES.LIST_VARI_ACCES()
 427   __no = __dico2['NUME_ORDRE'][-1]
 428
 429
 430   #-----------------------------------------------------------------------
 431   # 2.2 Troisieme etape : on remet la tension dans les cables
 432   #-----------------------------------------------------------------------
 433
 434   # Creation du mots-cles EXCIT pour le STAT_NON_LINE
 435   dExcit2=copy.copy(dExcit)
 436   dExcit2.append(_F(CHARGE=_C_CT,) )
 437
 438   # Calcul sur un seul pas (de __TINT a __TMAX)
 439   RES=STAT_NON_LINE( reuse      = RES,
 440                      ETAT_INIT  = _F(EVOL_NOLI =RES),
 441                      MODELE     = MODELE,
 442                      CHAM_MATER = CHAM_MATER,
 443                      CARA_ELEM  = CARA_ELEM,
 444                      COMP_INCR=dComp_incr1,
 445                      INCREMENT=_F(LIST_INST = __LST,
 446                                   PRECISION = __prec),
 447                      NEWTON =dNewton,
 448                      RECH_LINEAIRE = dRech_lin,
 449                      CONVERGENCE=dConvergence,
 450                      SOLVEUR = dSolveur,
 451                      ARCHIVAGE = _F(NUME_INIT = __no,
 452                                     DETR_NUME_SUIV = 'OUI' ),
 453                      INFO  =INFO,
 454                      TITRE = TITRE,
 455                      EXCIT =dExcit2,
 456                      )
 457
 458   return ier
 459