Aster/Cata/cataSTA73/Macro/calc_precont_ops.py

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