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.
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,
32 Ecriture de la macro CALC_PRECONT
39 from Noyau.N_utils import AsType
40 from Utilitai.Utmess import UTMESS
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')
56 # La macro compte pour 1 dans la numerotation des commandes
59 # Le concept sortant (de type evol_noli) est nomme RES dans
60 # le contexte de la macro
62 self.DeclareOut('RES',self.sd)
64 # -------------------------------------------------------------
65 # 1. CREATION DES MOTS-CLES ET CONCEPTS POUR LES STAT_NON_LINE
66 # ------------------------------------------------------------
69 # 1.1 Recuperation de la liste d'instants, de l'instant initial et final
70 # Creation de la nouvelle liste d'instants
71 # ----------------------------------------------------------
73 dIncrement=INCREMENT[0].cree_dict_valeurs(INCREMENT[0].mc_liste)
75 __prec = dIncrement['PRECISION']
76 __L0 = dIncrement['LIST_INST']
79 # Traitement de l'etat initial
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]
85 __EVINIT = dEtatInit['EVOL_NOLI']
89 # Test de la presence de reuse=
90 if self.reuse == None:
95 # Teste si INST_INIT est donné ou bien recalcule __TMIN
96 if dIncrement['INST_INIT'] == None:
97 if self.reuse == None:
100 __dico = __EVINIT.LIST_VARI_ACCES()
101 __TMIN = __dico['INST'][-1]
103 __TMIN = dIncrement['INST_INIT']
105 # Teste si INST_FIN est donné ou bien recalcule __TMAX
106 if dIncrement['INST_FIN'] == None:
109 __TMAX = dIncrement['INST_FIN']
111 # Teste si INST_INIT est bien plus petit que INST_FIN
113 UTMESS('F','CABLE0_1')
115 # Cree la liste d'instant __L2 allant de __TMIN a __TMAX et contenant
116 # un instant supplementaire __TINT
119 if m>=__TMIN and m<=__TMAX:
122 __TINT = (9.*__L2[-1] + __L2[-2])/10.
123 __L2[-1:-1] = [__TINT]
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),)
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'),
133 VALE=(__TMIN,0.0,__TINT,1.0,__TMAX,1.0),);
135 for i in dIncrement.keys():
136 if dIncrement[i]==None : del dIncrement[i]
137 dIncrement['LIST_INST']= __LST
138 dIncrement['INST_FIN'] = __TINT
142 # 1.2 Recuperation des parametres pour STAT_NON_LINE
143 # -------------------------------------------------------
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]
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]
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]
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]
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:
173 CABLE_BP.append ( CABLE_BP0 )
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 )
182 motscles['RELA_CINE_BP']=[]
184 motscle2['RELA_CINE_BP']=[]
186 motscle3['RELA_CINE_BP']=[]
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,
193 RELA_CINE = 'NON',) )
194 motscle2['RELA_CINE_BP'].append(_F(CABLE_BP=mcabl,
196 RELA_CINE = 'OUI',) )
197 motscle3['RELA_CINE_BP'].append(_F(CABLE_BP=mcabl,
199 RELA_CINE = 'OUI',) )
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');
207 Result[__nb][0] = __TCAB['NOM_CABLE',__nb+1]
208 __CAB = __TCAB['NOM_CABLE',__nb+1]
210 __GROUP_MA_A.append(__CAB)
213 # enlève les doublons
214 for m in __GROUP_MA_A:
218 if i == len(__GROUP_MA_A):
219 __GROUP_MA_A.append(__CAB)
222 Result.append([None]*1)
223 # Si on a lu toutes les valeurs alors on sort de la boucle
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
234 for mcabl in CABLE_BP_INACTIF:
235 __TCA0 = RECU_TABLE(CO=mcabl,NOM_TABLE='CABLE_BP');
239 Result[__nb][0] = __TCA0['NOM_CABLE',__nb+1]
240 __CA0 = __TCA0['NOM_CABLE',__nb+1]
242 __GROUP_MA_I.append(__CA0)
245 # enlève les doublons
246 for m in __GROUP_MA_I:
250 if i == len(__GROUP_MA_I):
251 __GROUP_MA_I.append(__CA0)
254 Result.append([None]*1)
255 # Si on a lu toutes les valeurs alors on sort de la boucle
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,
264 RELA_CINE = 'OUI',) )
266 __GROUP_MA_CABLES = __GROUP_MA_A + __GROUP_MA_I
269 # 1.4 Creation des mots-clés facteurs COMP_INCR
270 # pour étape 2 (dComp_incr0) et étape 3 (dComp_incr1)
271 # ------------------------------------------------------
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]
280 for j in range(len(COMP_INCR)) :
281 if dComp_incr[j]['RELATION'] == 'ELAS':
282 PARM_THETA=dComp_incr[j]['PARM_THETA']
285 PARM_THETA=dComp_incr[0]['PARM_THETA']
287 dComp_incr0=copy.copy(dComp_incr)
288 dComp_incr1=copy.copy(dComp_incr)
290 dComp_incr0.append(_F(RELATION='SANS',GROUP_MA=__GROUP_MA_CABLES,) )
292 dComp_incr1.append(_F(RELATION='SANS',GROUP_MA=__GROUP_MA_I,) )
295 # 1.5 Modele contenant uniquement les cables de precontrainte
296 # ---------------------------------------------------------
298 __MOD = string.ljust(MODELE.nom,8)
299 __MOD =__MOD+'.MODELE .LGRF '
300 __LMAIL = aster.getvectjev(__MOD)
301 __MAIL = string.strip(__LMAIL[0])
303 objma=self.get_sd_avant_etape(__MAIL,self)
305 __M_CA=AFFE_MODELE( MAILLAGE=objma,
306 AFFE =_F( GROUP_MA = __GROUP_MA_A,
307 PHENOMENE = 'MECANIQUE',
308 MODELISATION = 'BARRE') )
311 # 1.6 Blocage de tous les noeuds des cables actifs
312 # --------------------------------------------------
314 _B_CA=AFFE_CHAR_MECA(MODELE=__M_CA,
315 DDL_IMPO= _F( GROUP_MA = __GROUP_MA_A,
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)
327 _C_CI=AFFE_CHAR_MECA(MODELE=MODELE,**motscle6)
331 # -------------------------------------------------------------
333 # ------------------------------------------------------------
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 #-------------------------------------------------------------------
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,
352 INCREMENT =_F(LIST_INST = __LST0,
358 __EV1 = CALC_NO( reuse = __EV1,
360 GROUP_MA = __GROUP_MA_A,
361 OPTION = 'FORC_NODA' )
364 TYPE_CHAM = 'NOEU_DEPL_R',
367 NOM_CHAM = 'FORC_NODA',
370 __REAC = CREA_CHAMP (TYPE_CHAM='NOEU_DEPL_R',
373 ASSE= _F(GROUP_MA=__GROUP_MA_A,
377 _F_CA=AFFE_CHAR_MECA(MODELE=__M_CA,
382 #-----------------------------------------------------------------------
383 # 2.2 Deuxieme etape : application de la precontrainte sur le beton
384 # en desactivant les cables
385 #-----------------------------------------------------------------------
387 # Regeneration des mots-cles EXCIT passés en argument de la macro
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]
395 dExcit.append(_F(CHARGE=_C_CI),)
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,
404 if dReuse: motscle4['reuse']=[]
405 else: motscle4['reuse']=dReuse
410 CARA_ELEM =CARA_ELEM,
411 CHAM_MATER = CHAM_MATER,
412 COMP_INCR=dComp_incr0,
413 INCREMENT=dIncrement,
414 ETAT_INIT = dEtatInit,
416 CONVERGENCE=dConvergence,
417 RECH_LINEAIRE = dRech_lin,
419 ARCHIVAGE = _F(INST = __TINT),
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]
430 #-----------------------------------------------------------------------
431 # 2.2 Troisieme etape : on remet la tension dans les cables
432 #-----------------------------------------------------------------------
434 # Creation du mots-cles EXCIT pour le STAT_NON_LINE
435 dExcit2=copy.copy(dExcit)
436 dExcit2.append(_F(CHARGE=_C_CT,) )
438 # Calcul sur un seul pas (de __TINT a __TMAX)
439 RES=STAT_NON_LINE( reuse = RES,
440 ETAT_INIT = _F(EVOL_NOLI =RES),
442 CHAM_MATER = CHAM_MATER,
443 CARA_ELEM = CARA_ELEM,
444 COMP_INCR=dComp_incr1,
445 INCREMENT=_F(LIST_INST = __LST,
448 RECH_LINEAIRE = dRech_lin,
449 CONVERGENCE=dConvergence,
451 ARCHIVAGE = _F(NUME_INIT = __no,
452 DETR_NUME_SUIV = 'OUI' ),