1 #@ MODIF calc_precont_ops Macro DATE 05/07/2005 AUTEUR DURAND C.DURAND
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.
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.
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 # ======================================================================
22 # RESPONSABLE ASSIRE A.ASSIRE
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):
32 Ecriture de la macro CALC_PRECONT
39 from Noyau.N_utils import AsType
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')
55 # La macro compte pour 1 dans la numerotation des commandes
58 # Le concept sortant (de type evol_noli) est nomme RES dans
59 # le contexte de la macro
61 self.DeclareOut('RES',self.sd)
63 # -------------------------------------------------------------
64 # 1. CREATION DES MOTS-CLES ET CONCEPTS POUR LES STAT_NON_LINE
65 # ------------------------------------------------------------
68 # 1.1 Recuperation de la liste d'instants, de l'instant initial et final
69 # Creation de la nouvelle liste d'instants
70 # ----------------------------------------------------------
72 dIncrement=INCREMENT[0].cree_dict_valeurs(INCREMENT[0].mc_liste)
74 __prec = dIncrement['PRECISION']
75 __L0 = dIncrement['LIST_INST']
78 # Traitement de l'etat initial
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]
84 __EVINIT = dEtatInit['EVOL_NOLI']
88 # Test de la presence de reuse=
89 if self.reuse == None:
94 # Teste si INST_INIT est donné ou bien recalcule __TMIN
95 if dIncrement['INST_INIT'] == None:
96 if self.reuse == None:
99 __dico = __EVINIT.LIST_VARI_ACCES()
100 __TMIN = __dico['INST'][-1]
102 __TMIN = dIncrement['INST_INIT']
104 # Teste si INST_FIN est donné ou bien recalcule __TMAX
105 if dIncrement['INST_FIN'] == None:
108 __TMAX = dIncrement['INST_FIN']
110 # Teste si INST_INIT est bien plus petit que INST_FIN
113 self.cr.fatal("""<F> <CALC_PRECONT> ERREUR : INST_FIN PLUS PETIT QUE INST_INIT""")
116 # Cree la liste d'instant __L2 allant de __TMIN a __TMAX et contenant
117 # un instant supplementaire __TINT
120 if m>=__TMIN and m<=__TMAX:
123 __TINT = (9.*__L2[-1] + __L2[-2])/10.
124 __L2[-1:-1] = [__TINT]
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),)
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'),
134 VALE=(__TMIN,0.0,__TINT,1.0,__TMAX,1.0),);
136 for i in dIncrement.keys():
137 if dIncrement[i]==None : del dIncrement[i]
138 dIncrement['LIST_INST']= __LST
139 dIncrement['INST_FIN'] = __TINT
143 # 1.2 Recuperation des parametres pour STAT_NON_LINE
144 # -------------------------------------------------------
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]
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]
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]
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]
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]
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]
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:
189 CABLE_BP.append ( CABLE_BP0 )
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 )
198 motscles['RELA_CINE_BP']=[]
200 motscle2['RELA_CINE_BP']=[]
202 motscle3['RELA_CINE_BP']=[]
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,
209 RELA_CINE = 'NON',) )
210 motscle2['RELA_CINE_BP'].append(_F(CABLE_BP=mcabl,
212 RELA_CINE = 'OUI',) )
213 motscle3['RELA_CINE_BP'].append(_F(CABLE_BP=mcabl,
215 RELA_CINE = 'OUI',) )
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');
223 Result[__nb][0] = __TCAB['NOM_CABLE',__nb+1]
224 __CAB = __TCAB['NOM_CABLE',__nb+1]
226 __GROUP_MA_A.append(__CAB)
229 # enlève les doublons
230 for m in __GROUP_MA_A:
234 if i == len(__GROUP_MA_A):
235 __GROUP_MA_A.append(__CAB)
238 Result.append([None]*1)
239 # Si on a lu toutes les valeurs alors on sort de la boucle
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
250 for mcabl in CABLE_BP_INACTIF:
251 __TCA0 = RECU_TABLE(CO=mcabl,NOM_TABLE='CABLE_BP');
255 Result[__nb][0] = __TCA0['NOM_CABLE',__nb+1]
256 __CA0 = __TCA0['NOM_CABLE',__nb+1]
258 __GROUP_MA_I.append(__CA0)
261 # enlève les doublons
262 for m in __GROUP_MA_I:
266 if i == len(__GROUP_MA_I):
267 __GROUP_MA_I.append(__CA0)
270 Result.append([None]*1)
271 # Si on a lu toutes les valeurs alors on sort de la boucle
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,
280 RELA_CINE = 'OUI',) )
282 __GROUP_MA_CABLES = __GROUP_MA_A + __GROUP_MA_I
285 # 1.4 Creation des mots-clés facteurs COMP_INCR
286 # pour étape 2 (dComp_incr0) et étape 3 (dComp_incr1)
287 # ------------------------------------------------------
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]
295 dComp_incr0=copy.copy(dComp_incr)
296 dComp_incr1=copy.copy(dComp_incr)
298 dComp_incr0.append(_F(RELATION='SANS',GROUP_MA=__GROUP_MA_CABLES) )
300 dComp_incr1.append(_F(RELATION='SANS',GROUP_MA=__GROUP_MA_I) )
303 # 1.5 Modele contenant uniquement les cables de precontrainte
304 # ---------------------------------------------------------
306 __MOD = string.ljust(MODELE.nom,8)
307 __MOD =__MOD+'.MODELE .NOMA '
308 __LMAIL = aster.getvectjev(__MOD)
309 __MAIL = string.strip(__LMAIL[0])
311 objma=self.get_sd_avant_etape(__MAIL,self)
313 __M_CA=AFFE_MODELE( MAILLAGE=objma,
314 AFFE =_F( GROUP_MA = __GROUP_MA_A,
315 PHENOMENE = 'MECANIQUE',
316 MODELISATION = 'BARRE') )
319 # 1.6 Blocage de tous les noeuds des cables actifs
320 # --------------------------------------------------
322 _B_CA=AFFE_CHAR_MECA(MODELE=__M_CA,
323 DDL_IMPO= _F( GROUP_MA = __GROUP_MA_A,
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)
335 _C_CI=AFFE_CHAR_MECA(MODELE=MODELE,**motscle6)
339 # -------------------------------------------------------------
341 # ------------------------------------------------------------
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 #-------------------------------------------------------------------
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',
359 INCREMENT =_F(LIST_INST = __LST0,
362 PARM_THETA = PARM_THETA,
366 __EV1 = CALC_NO( reuse = __EV1,
368 GROUP_MA = __GROUP_MA_A,
369 OPTION = 'FORC_NODA' )
372 TYPE_CHAM = 'NOEU_DEPL_R',
375 NOM_CHAM = 'FORC_NODA',
378 __REAC = CREA_CHAMP (TYPE_CHAM='NOEU_DEPL_R',
381 ASSE= _F(GROUP_MA=__GROUP_MA_A,
385 _F_CA=AFFE_CHAR_MECA(MODELE=__M_CA,
390 #-----------------------------------------------------------------------
391 # 2.2 Deuxieme etape : application de la precontrainte sur le beton
392 # en desactivant les cables
393 #-----------------------------------------------------------------------
395 # Regeneration des mots-cles EXCIT passés en argument de la macro
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]
403 dExcit.append(_F(CHARGE=_C_CI),)
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,
413 CARA_ELEM =CARA_ELEM,
414 CHAM_MATER = CHAM_MATER,
415 COMP_INCR=dComp_incr0,
416 INCREMENT=dIncrement,
417 ETAT_INIT = dEtatInit,
419 CONVERGENCE=dConvergence,
420 RECH_LINEAIRE = dRech_lin,
422 SOLV_NON_LOCAL = dSolv_nonloc,
423 LAGR_NON_LOCAL = dLagr_nonloc,
424 ARCHIVAGE = _F(INST = __TINT),
425 PARM_THETA = PARM_THETA,
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]
436 #-----------------------------------------------------------------------
437 # 2.2 Troisieme etape : on remet la tension dans les cables
438 #-----------------------------------------------------------------------
440 # Creation du mots-cles EXCIT pour le STAT_NON_LINE
441 dExcit2=copy.copy(dExcit)
442 dExcit2.append(_F(CHARGE=_C_CT,) )
444 # Calcul sur un seul pas (de __TINT a __TMAX)
445 RES=STAT_NON_LINE( reuse = RES,
446 ETAT_INIT = _F(EVOL_NOLI =RES),
448 CHAM_MATER = CHAM_MATER,
449 CARA_ELEM = CARA_ELEM,
450 COMP_INCR=dComp_incr1,
451 INCREMENT=_F(LIST_INST = __LST,
454 RECH_LINEAIRE = dRech_lin,
455 CONVERGENCE=dConvergence,
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,