-#@ MODIF calc_ecrevisse_ops Macro DATE 05/10/2009 AUTEUR ASSIRE A.ASSIRE
+#@ MODIF calc_ecrevisse_ops Macro DATE 05/05/2010 AUTEUR MACOCCO K.MACOCCO
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
-# Debut de la macro, on impose en parametre les donnees placer dans T_EC, l'appel a ecrevisse
+# ------------------OUTILS ------------------------------
+
+# Determination de la direction de la fissure
+# a partir du points initial et final :
+# theta : angle par rapport a la verticale ascendente (degres)
+# positif si sens horaire
+# -180< theta <=180
+# beta : angle par rapport a la horizontale (degres)
+# positif si sens anti-horaire
+# -180< beta <=180
+def dirfiss(Xa,Ya,Xb,Yb) :
+ from math import atan2, degrees
+
+ xia = Xa[0]
+ yia = Ya[0]
+ xea = Xa[-1]
+ yea = Ya[-1]
+ xib = Xb[0]
+ yib = Yb[0]
+ xeb = Xb[-1]
+ yeb = Yb[-1]
+
+ xi = (xia+xib)/2.
+ yi = (yia+yib)/2.
+ xe = (xea+xeb)/2.
+ ye = (yea+yeb)/2.
+
+ dx = xe -xi
+ dy = ye -yi
+
+ try :
+ tangA= dy/dx
+ except ZeroDivisionError :
+ if (dy>0.) :
+ theta = 0.
+ beta = 90.
+ else :
+ theta = 180.
+ beta = -90.
+ else :
+ beta = atan2(dy,dx)
+ beta = degrees(beta)
+ theta = 90.-beta
+ if (theta>180.):
+ theta=theta-360.
+
+ if (abs(beta)<45. or abs(beta)>135.) :
+ DIR_PREV = 'X'
+ else:
+ DIR_PREV = 'Y'
+
+ if (round(abs(beta))==0. or round(abs(beta))==180.):
+ DIR_FISS = 'X'
+ elif (round(abs(beta))==90.):
+ DIR_FISS = 'Y'
+ else :
+ DIR_FISS = 'GEN'
+
+ return DIR_FISS, DIR_PREV, beta, theta, xi, yi
+
+
+# Determination de l ouverture de la fissure
+def ouvFiss(DIR_FISS,beta,Xa,Ya,Xb,Yb) :
+ from math import sin, cos, sqrt, radians
+
+ if DIR_FISS=='X' :
+ Ouv = map(lambda y1,y2: abs(y2-y1),Ya,Yb)
+ Gli = map(lambda x1,x2: abs(x2-x1),Xa,Xb)
+ elif DIR_FISS=='Y' :
+ Ouv = map(lambda x1,x2: abs(x2-x1),Xa,Xb)
+ Gli = map(lambda y1,y2: abs(y2-y1),Ya,Yb)
+ else :
+ xi = (Xa[0]+Xb[0])*0.5
+ yi = (Ya[0]+Yb[0])*0.5
+ Xa1 = [x-y for (x,y) in zip(Xa,[xi]*len(Xa))]
+ Ya1 = [x-y for (x,y) in zip(Ya,[yi]*len(Ya))]
+ Xb1 = [x-y for (x,y) in zip(Xb,[xi]*len(Xb))]
+ Yb1 = [x-y for (x,y) in zip(Yb,[yi]*len(Yb))]
+ Xa2 = [ x*cos(radians(beta)) + y*sin(radians(beta)) for (x,y) in zip(Xa,Ya)]
+ Ya2 = [-x*sin(radians(beta)) + y*cos(radians(beta)) for (x,y) in zip(Xa,Ya)]
+ Xb2 = [ x*cos(radians(beta)) + y*sin(radians(beta)) for (x,y) in zip(Xb,Yb)]
+ Yb2 = [-x*sin(radians(beta)) + y*cos(radians(beta)) for (x,y) in zip(Xb,Yb)]
+ Ouv = map(lambda x,y: abs(y-x), Ya2, Yb2)
+ Gli = map(lambda x,y: abs(y-x), Xa2, Xb2)
+ return Ouv, Gli
+
+
+
+
+
+# ------------------DEBUT MACRO ------------------------------
+# Debut de la macro, on impose en parametre les donnees placer
+# dans T_EC, l'appel a ecrevisse
def calc_ecrevisse_ops(self,
CHARGE_MECA,
CHARGE_THER1,
"""
Procedure de couplage Aster-Ecrevisse
- Recuperation du profil de la fissure , appel de MACR_ECRE_CALC,
+ Recuperation du profil de la fissure , appel de MACR_ECRE_CALC,
creation des tableaux de resultats et des chargements pour AsterGeneration par Aster
"""
import aster
from Accas import _F
from Noyau.N_utils import AsType
- from Utilitai.Utmess import UTMESS
+ from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme
from Utilitai.Table import Table, merge
- from math import atan, pi, sqrt
+ from copy import copy
+ from math import atan, pi, sqrt, atan2, degrees, sin, cos
ier=0
self.DeclareOut('__ECR_P',CHARGE_MECA)
self.DeclareOut('__DEB',DEBIT)
-
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
- # Parametres Developpeur
+ # Parametres debug
+ debug = False
+
+ # Fonctionnalitees cachees :
+ # 1- oldVersion : "=True" permet de retourner un chargement thermique defini selon l'ancien mode (flux thermique)
+ # ATTENTION!! L'ancienne version ne marche que avec la fissure orientee dans la direction Y,
+ # et avec le point initila en y=0!!
+ # 2- chargeLin : "=True" permet d'appliquer le chargement d'Ecrevisse avec interpolation lineaire sur le mailles,
+ # et non constant par maille, comme c'est par defaut
+ oldVersion = False
+ chargeLin = False
+
+
+ # Parametres developpeur
tmp_ecrevisse = "tmp_ecrevisse"
- fichier_data = "data.dat"
- defaut = '00'
- # Niveaux de debug
- debug1 = (INFO>1)
- debug2 = (INFO>2)
- #
+
+ # Info
+ info2 = (INFO==2)
InfoAster = 1
- #
- oldVersion = False # Permet de retourner un chargement thermique defini selon l'ancien mode (flux thermique)
+ if debug :
+ info2=True
# IMPORTATION DE COMMANDES ASTER
DEFI_GROUP = self.get_cmd("DEFI_GROUP")
IMPR_CO = self.get_cmd("IMPR_CO")
DEFI_FONCTION = self.get_cmd("DEFI_FONCTION")
CREA_TABLE = self.get_cmd("CREA_TABLE")
+ IMPR_TABLE = self.get_cmd("IMPR_TABLE")
CO = self.get_cmd("CO")
AFFE_CHAR_THER_F = self.get_cmd("AFFE_CHAR_THER_F")
AFFE_CHAR_MECA_F = self.get_cmd("AFFE_CHAR_MECA_F")
DEFI_FICHIER = self.get_cmd("DEFI_FICHIER")
+ DEFI_CONSTANTE = self.get_cmd("DEFI_CONSTANTE")
# RECUPERATION DES MOTS-CLES FACTEURS
dRESULTAT=RESULTAT[0].cree_dict_valeurs(RESULTAT[0].mc_liste)
for i in dCONVERGENCE.keys():
if dCONVERGENCE[i]==None : del dCONVERGENCE[i]
- # Instants
+
+ # INSTANTS
_l_inst = dRESULTAT['MECANIQUE'].LIST_VARI_ACCES()
if dRESULTAT.has_key('INST'):
Inst_Ecrevisse = dRESULTAT['INST']
else:
pass
- # ancienne version
- # liste des mots cles facteurs de FLUX_REP pour le flux F1 de chaque fissure (sur GROUP_MA[0])
- l_FLUX_REP_F1 = []
- # liste des mots cles facteurs de PRES_REP pour le flux F2 de chaque fissure (sur GROUP_MA[1])
- l_FLUX_REP_F2 = []
-
- # nouvelle version
- # liste des mots cles facteurs de ECHANGE pour le flux F1 de chaque fissure (sur GROUP_MA[0])
- l_ECHANGE_F1 = []
- # liste des mots cles facteurs de ECHANGE pour le flux F2 de chaque fissure (sur GROUP_MA[1])
- l_ECHANGE_F2 = []
-
- # Toutes versions
- # liste des mots cles facteurs de PRES_REP pour chaque fissure
+
+ # INITIATION DES CHARGEMENTS ECREVISSE --> ASTER :
+ # liste des mots cles facteurs de PRES_REP pour chaque fissure
l_PRES_REP = []
+ if oldVersion :
+ # liste des mots cles facteurs de FLUX_REP pour le flux F1/F2
+ # de chaque fissure (soit sur les deux levres :GROUP_MA[0], GROUP_MA[1])
+ l_FLUX_REP_F1 = []
+ l_FLUX_REP_F2 = []
+ else :
+ # liste des mots cles facteurs de ECHANGE pour le flux F1/F2
+ # de chaque fissure (soit sur les deux levres :GROUP_MA[0], GROUP_MA[1])
+ l_ECHANGE_F1 = []
+ l_ECHANGE_F2 = []
+
- # Liste des noms des groupes de noeuds du maillage
+ # ON CREE LES GROUP_NO ORDONNES DES LEVRES DE FISSURE
+ # Liste des noms des groupes de noeuds du maillage :
_lgno = map(lambda x: x[0], MODELE_MECA['MAILLAGE'].LIST_GROUP_NO() )
for k, fissure in enumerate(FISSURE):
CREA_GROUP_NO=_F(GROUP_MA=(dFISSURE['GROUP_MA'][1]),),);
# Test sur le nombre de caracteres du nom des group_ma
- if len(dFISSURE['GROUP_MA'][0]) >7:
- sys.exit(1)
-
- if len(dFISSURE['GROUP_MA'])>1 and len(dFISSURE['GROUP_MA'][1]) >7:
+ if (len(dFISSURE['GROUP_MA'][0]) >7 or len(dFISSURE['GROUP_MA'][1]) >7):
sys.exit(1)
# Creation des group_no ordonnes des levres des fissures
GROUP_NO=dFISSURE['GROUP_MA'][0],
GROUP_NO_ORIG=dFISSURE['GROUP_NO_ORIG'][0],
GROUP_NO_EXTR=dFISSURE['GROUP_NO_EXTR'][0],
- PRECISION=0.001,
- CRITERE='ABSOLU',),
+ PRECISION=0.01,
+ CRITERE='RELATIF',),
INFO=InfoAster,);
+ _nom_gno_2 = '_' + dFISSURE['GROUP_MA'][1]
+ if not _nom_gno_2 in _lgno:
+ DEFI_GROUP(reuse = MODELE_MECA['MAILLAGE'],
+ MAILLAGE=MODELE_MECA['MAILLAGE'],
+ CREA_GROUP_NO=_F(OPTION='SEGM_DROI_ORDO',
+ NOM=_nom_gno_2,
+ GROUP_NO=dFISSURE['GROUP_MA'][1],
+ GROUP_NO_ORIG=dFISSURE['GROUP_NO_ORIG'][1],
+ GROUP_NO_EXTR=dFISSURE['GROUP_NO_EXTR'][1],
+ PRECISION=0.01,
+ CRITERE='RELATIF',),
+ INFO=InfoAster,);
+
+
- if len(dFISSURE['GROUP_MA'])>1:
- _nom_gno_2 = '_' + dFISSURE['GROUP_MA'][1]
- if not _nom_gno_2 in _lgno:
- DEFI_GROUP(reuse = MODELE_MECA['MAILLAGE'],
- MAILLAGE=MODELE_MECA['MAILLAGE'],
- CREA_GROUP_NO=_F(OPTION='SEGM_DROI_ORDO',
- NOM=_nom_gno_2,
- GROUP_NO=dFISSURE['GROUP_MA'][1],
- GROUP_NO_ORIG=dFISSURE['GROUP_NO_ORIG'][1],
- GROUP_NO_EXTR=dFISSURE['GROUP_NO_EXTR'][1],
- PRECISION=0.001,
- CRITERE='ABSOLU',),
- INFO=InfoAster,);
-
- _T_DY=POST_RELEVE_T(ACTION=_F(INTITULE='DEPL_FIS',
+ # EXTRACTIONS DE QUANTITES NECESSAIRES DES RESULTATS THERMIQUE ET MECANIQUE
+ # On cree les chargements Aster --> Ecrevisse :
+ # ouverture de fissure et temperature sur le materiau
+
+ # premiere levre de fissure
+ _T_DPL=POST_RELEVE_T(ACTION=_F(INTITULE='DEP_FIS1',
GROUP_NO=_nom_gno_1,
RESULTAT=dRESULTAT['MECANIQUE'],
NOM_CHAM='DEPL',
OPERATION='EXTRACTION',),
);
- if len(dFISSURE['GROUP_MA'])>1:
- # signifie que l'on prend en compte la deuxieme levre de la fissure, different de l'essai sur tranche ou une fissure est
- # represente par une seule levre et l'autre est fixe
- _T_DY_B=POST_RELEVE_T(ACTION=_F(INTITULE='DX_FIS',
- GROUP_NO=_nom_gno_2,
- RESULTAT=dRESULTAT['MECANIQUE'],
- NOM_CHAM='DEPL',
- NOM_CMP=('DX','DY',),
- INST = Inst_Ecrevisse,
- OPERATION='EXTRACTION',),);
-
- _T_TEMP=POST_RELEVE_T(ACTION=_F(INTITULE='TEMP',
+ _T_TEMP=POST_RELEVE_T(ACTION=_F(INTITULE='TEMP_FI1',
GROUP_NO=_nom_gno_1,
RESULTAT=dRESULTAT['THERMIQUE'],
NOM_CHAM='TEMP',
INST = Inst_Ecrevisse,
OPERATION='EXTRACTION',),);
- if len(dFISSURE['GROUP_MA'])>1:
- _T_TEMPB=POST_RELEVE_T(ACTION=_F(INTITULE='TEMP',
- GROUP_NO=_nom_gno_2,
- RESULTAT=dRESULTAT['THERMIQUE'],
- NOM_CHAM='TEMP',
- TOUT_CMP='OUI',
- INST = Inst_Ecrevisse,
- OPERATION='EXTRACTION',),);
-
- if ( debug2 ) :
- print '_T_DY ==================================================='
- print _T_DY.EXTR_TABLE()
+ # deuxieme levre de la fissure
+ _T_DPL_B=POST_RELEVE_T(ACTION=_F(INTITULE='DEP_FIS2',
+ GROUP_NO=_nom_gno_2,
+ RESULTAT=dRESULTAT['MECANIQUE'],
+ NOM_CHAM='DEPL',
+ NOM_CMP=('DX','DY',),
+ INST = Inst_Ecrevisse,
+ OPERATION='EXTRACTION',),);
+
+ _T_TEMPB=POST_RELEVE_T(ACTION=_F(INTITULE='TEMP_FI2',
+ GROUP_NO=_nom_gno_2,
+ RESULTAT=dRESULTAT['THERMIQUE'],
+ NOM_CHAM='TEMP',
+ TOUT_CMP='OUI',
+ INST = Inst_Ecrevisse,
+ OPERATION='EXTRACTION',),);
+
+ if ( debug ) :
+ print '_T_DPL ==================================================='
+ print _T_DPL.EXTR_TABLE()
+ print '_T_DPL_B ================================================='
+ print _T_DPL_B.EXTR_TABLE()
print '_T_TEMP ================================================='
print _T_TEMP.EXTR_TABLE()
-
+ print '_T_TEMP_B ==============================================='
+ print _T_TEMPB.EXTR_TABLE()
# Extraction des tables Temperatures + deplacement levres fissure
_tbl_temp = _T_TEMP.EXTR_TABLE()
- _tbl_dy = _T_DY.EXTR_TABLE()
- DETRUIRE(CONCEPT=_F(NOM=(_T_DY,_T_TEMP,)),INFO=1,ALARME='NON')
-
- # Determination de la direction de la fissure : limitee aux cas horizontal ou vertical a cause
- # de la creation des chargement pour aster
-
- _xih = _tbl_dy.values()['COOR_X'][0]
- _yih = _tbl_dy.values()['COOR_Y'][0]
- _xeh = _tbl_dy.values()['COOR_X'][-1]
- _yeh = _tbl_dy.values()['COOR_Y'][-1]
-
- if abs(_xeh -_xih)<1.E-6 : # fissure verticale
-
- if (_yeh-_yih)<0 : # fluide du haut vers le bas
- alpha = 180.
- else :
- alpha =0. # fluide du bas vers le haut
- DIR_FISS='Y'
- NORM_FISS='X'
- elif abs(_yih - _yeh)<1.E-6 : # fissure horizontale
- alpha = 90.
- DIR_FISS ='X'
- NORM_FISS = 'Y'
- else:
- UTMESS('F','ECREVISSE0_23')
-
-# Determination de l'ouverture de la fissure
-
- _l_dy1 = _tbl_dy.values()['ABSC_CURV']
- _l_dy2 = [ x + y for (x,y) in zip(_tbl_dy.values()['D%s' % NORM_FISS], _tbl_dy.values()['COOR_%s' % NORM_FISS]) ]
-
- # Listes des cotes et ouvertures (deuxieme groupe)
- if len(dFISSURE['GROUP_MA'])>1:
- # signifie que l'on prend en compte la deuxieme levre de la fissure,
- _tbl_dy_b = _T_DY_B.EXTR_TABLE()
- _tbl_temp_b = _T_TEMPB.EXTR_TABLE()
- DETRUIRE(CONCEPT=_F(NOM=(_T_DY_B,_T_TEMPB,)),INFO=1,ALARME='NON')
-
- _l_dy1_b = _tbl_dy_b.values()['ABSC_CURV']
- _l_dy2_b = [ x + y for (x,y) in zip(_tbl_dy_b.values()['D%s' % NORM_FISS], _tbl_dy_b.values()['COOR_%s' % NORM_FISS]) ]
-
- # Listes des cotes et temperatures (premier groupe)
- _l_t1 = _tbl_temp.values()['ABSC_CURV']
+ _tbl_dpl = _T_DPL.EXTR_TABLE()
+ DETRUIRE(CONCEPT=_F(NOM=(_T_DPL,_T_TEMP,)),INFO=1,ALARME='NON')
+ _tbl_dpl_b = _T_DPL_B.EXTR_TABLE()
+ _tbl_temp_b = _T_TEMPB.EXTR_TABLE()
+ DETRUIRE(CONCEPT=_F(NOM=(_T_DPL_B,_T_TEMPB,)),INFO=1,ALARME='NON')
+
+
+ # --Determination des cotes a donner a ecrevisse--
+ # a partir des resultats mecanique et thermique :
+ _l_tang = _tbl_dpl.values()['ABSC_CURV']
+ _l_tang_b = _tbl_dpl_b.values()['ABSC_CURV']
+ try :
+ _l_absz_m = map(lambda x,y: 0.5*(x+y), _l_tang,_l_tang_b)
+ except TypeError :
+ UTMESS('F','ECREVISSE0_40')
+ #
+ _l_tang_t = _tbl_temp.values()['ABSC_CURV']
+ _l_tang_t_b = _tbl_temp_b.values()['ABSC_CURV']
+ _l_absz_t = map(lambda x,y: 0.5*(x+y), _l_tang_t,_l_tang_t_b)
+
+
+ # Coordonnees des points des levres (initiales et a l instant actuel
+ _X0 = _tbl_dpl.values()['COOR_X']
+ _Y0 = _tbl_dpl.values()['COOR_Y']
+ _X0_b = _tbl_dpl_b.values()['COOR_X']
+ _Y0_b = _tbl_dpl_b.values()['COOR_Y']
+ _X = [x + y for (x,y) in zip(_tbl_dpl.values()['DX'],_X0)]
+ _Y = [x + y for (x,y) in zip(_tbl_dpl.values()['DY'],_Y0)]
+ _X_b = [x + y for (x,y) in zip(_tbl_dpl_b.values()['DX'],_X0_b)]
+ _Y_b = [x + y for (x,y) in zip(_tbl_dpl_b.values()['DY'],_Y0_b)]
+
+
+ # Determination de la direction de la fissure
+ (DIR_FISS, DIR_PREV, beta, theta, _xi, _yi) = dirfiss(_X,_Y,_X_b,_Y_b)
+ if oldVersion :
+ (DIR_FISS, DIR_PREV, beta, theta, _xi, _yi) = dirfiss(_X0,_Y0,_X0_b,_Y0_b)
+
+ if (DIR_FISS == 'GEN') and oldVersion :
+ UTMESS('F','ECREVISSE0_23', valr=[theta])
+
+ # --Calcul de l ouverture de fissure--
+ # une fissure refermee a une ouverture
+ # egale a l'ouverture remanente
+ (_l_ouv0,_l_gli0) = ouvFiss(DIR_FISS,beta,_X0,_Y0,_X0_b,_Y0_b)
+ for i in range(len(_l_ouv0)) :
+ if _l_ouv0[i] < dFISSURE['OUVERT_REMANENTE'] :
+ UTMESS('A','ECREVISSE0_39')
+
+
+ (_l_ouv,_l_gli) = ouvFiss(DIR_FISS,beta,_X,_Y,_X_b,_Y_b)
+ if dFISSURE['OUVERT_REMANENTE'] :
+ _l_ouv = map(lambda x: max(dFISSURE['OUVERT_REMANENTE'],x), _l_ouv)
+ if info2 :
+ nbOuvRem = _l_ouv.count(dFISSURE['OUVERT_REMANENTE'])
+ if nbOuvRem != 0 :
+ UTMESS('I', 'ECREVISSE0_41',valr=[nbOuvRem])
+
+
+
+ # Controle sur l entite du glissement entre les levres
+ DeltaMaille = [abs(y-x) for (x,y) in zip(_l_absz_m[1:len(_l_absz_m)], _l_absz_m[0:len(_l_absz_m)-1])]
+ for i in range(len(DeltaMaille)) :
+ deltamai = DeltaMaille[i]
+ if (deltamai <= _l_gli[i]) or (deltamai <= _l_gli[i+1]) :
+ UTMESS('A', 'ECREVISSE0_38')
+ break
+
+
+ # -- Calcul de la temperature sur le materiau (levres de la fissure) --
+ # on fait la moyenne des temperatures des deux levres
_l_t2 = _tbl_temp.values()['TEMP']
-
- # Listes des cotes et temperatures (deuxieme groupe)
- if len(dFISSURE['GROUP_MA'])>1:
- # signifie que l'on prend en compte la deuxieme levre de la fissure, different de l'essai sur tranche ou une fissure est
- # represente par une seule levre et l'autre est fixe
-
- _l_t1_b = _tbl_temp_b.values()['ABSC_CURV']
- _l_t2_b = _tbl_temp_b.values()['TEMP']
-
-
- if ( debug2 ):
- print "Informations de debug:\n"
- print 'Inst_Ecrevisse=', Inst_Ecrevisse
- print '_l_t1=', len(_l_t1),_l_t1
- print '_l_t2=', len(_l_t2),_l_t2
- print '_l_dy1=', len(_l_dy1),_l_dy1
- print '_l_dy2=', len(_l_dy2),_l_dy2
-
- if len(dFISSURE['GROUP_MA'])>1:
- print '_l_t1_b=', len(_l_t1_b),_l_t1_b
- print '_l_t2_b=', len(_l_t2_b),_l_t2_b
- print '_l_dy1_b=', len(_l_dy1_b),_l_dy1_b
- print '_l_dy2_b=', len(_l_dy2_b),_l_dy2_b
+ _l_t2_b = _tbl_temp_b.values()['TEMP']
+ _l_temp_aster = map(lambda x,y: 0.5*(x+y), _l_t2_b,_l_t2)
- # Affichage d'informations que l'on peut voir sur le fichier .mess ou .resu
+ # Infos / Debug : fichier .mess ou .resu
+ if (info2) :
+ UTMESS('I', 'ECREVISSE0_1', valk=["Premiere levre"],
+ valr=[Inst_Ecrevisse, min(_l_tang_t), max(_l_tang_t), min(_l_t2), max(_l_t2), min(_l_tang), max(_l_tang)])
+ UTMESS('I', 'ECREVISSE0_1',valk=["Deuxieme levre"],
+ valr=[Inst_Ecrevisse,min(_l_tang_t_b), max(_l_tang_t_b), min(_l_t2_b), max(_l_t2_b), min(_l_tang_b), max(_l_tang_b)])
+ UTMESS('I', 'ECREVISSE0_2',
+ valr=[Inst_Ecrevisse, min(_l_absz_t), max(_l_absz_t), min(_l_temp_aster), max(_l_temp_aster), min(_l_absz_m), max(_l_absz_m), min(_l_ouv), max(_l_ouv), min(_l_gli),max(_l_gli)])
- if (debug1):
- UTMESS('I', 'ECREVISSE0_1', valk=["Premiere levre"],
- valr=[Inst_Ecrevisse, min(_l_t1), max(_l_t1), min(_l_t2), max(_l_t2), min(_l_dy1), max(_l_dy1), min(_l_dy2), max(_l_dy2)])
- if len(dFISSURE['GROUP_MA'])>1:
- UTMESS('I', 'ECREVISSE0_1',valk=["Deuxieme levre"],
- valr=[Inst_Ecrevisse,min(_l_t1_b), max(_l_t1_b), min(_l_t2_b), max(_l_t2_b), min(_l_dy1_b), max(_l_dy1_b), min(_l_dy2_b), max(_l_dy2_b)])
-
-
- # ----------------------------------------------------------------------------------
- # Partie concernant la prise en compte des deux levres
- if len(dFISSURE['GROUP_MA'])>1:
-
- # Calcul de l'ouverture entre les deux levres
- _l_dy2 = map(lambda x,y: abs(y-x), _l_dy2, _l_dy2_b)
-
- # Pour la temperature, on fait la moyenne des temperatures des deux levres (points a ameliorer peut etre par un autre modele)
- _l_t2 = map(lambda x,y: 0.5*(x+y), _l_t2_b,_l_t2)
-
- # ----------------------------------------------------------------------------------
-
- if dFISSURE['OUVERT_REMANENTE']:
- # une fissure refermee a une ouverture egale a l'ouverture remanente
- _l_dy2 = map(lambda x: max(dFISSURE['OUVERT_REMANENTE'],x), _l_dy2)
-
- UTMESS('I', 'ECREVISSE0_2',
- valr=[Inst_Ecrevisse, min(_l_t1), max(_l_t1), min(_l_t2), max(_l_t2), min(_l_dy1), max(_l_dy1), min(_l_dy2), max(_l_dy2)])
-
-
- if ( debug2 ):
- print "Informations de debug:\n"
+ if ( debug ) :
+ print "\n INFORMATIONS DE DEBUG: "
print 'Inst_Ecrevisse=', Inst_Ecrevisse
- print '_l_t1=', len(_l_t1),_l_t1
- print '_l_t2=', len(_l_t2),_l_t2
- print '_l_dy1=', len(_l_dy1),_l_dy1
- print '_l_dy2=', len(_l_dy2),_l_dy2
-
- # Test de non divergence, les messages sont assez explicites
-
+ print 'theta:', theta
+ print 'beta:', beta
+ print 'DIR_FISS:', DIR_FISS
+ print 'DIR_PREV:', DIR_PREV
+ print 'point initial de la fissure: (xi,yi) :', _xi,_yi
+ print len(_X0), '_X0 =', _X0
+ print len(_X0_b), '_X0_b=', _X0_b
+ print len(_Y0), '_Y0 =', _Y0
+ print len(_Y0_b), '_Y0_b=', _Y0_b
+ print len(_X), '_X =', _X
+ print len(_Y), '_Y =', _Y
+ print len(_X_b), '_X_b =', _X_b
+ print len(_Y_b), '_Y_b =', _Y_b
+ print 'Controle sur les abszisses curvilignes (mecaniques/thermiques) '
+ print '_l_absz_m==_l_absz_t?', _l_absz_m==_l_absz_t
+ print '_l_absz_m=', len(_l_absz_m),_l_absz_m
+ print '_l_absz_t=', len(_l_absz_t),_l_absz_t
+ print '_l_temp_aster=', len(_l_temp_aster),_l_temp_aster
+ print '_l_ouv=', len(_l_ouv),_l_ouv
+ print '_l_gli=', len(_l_gli),_l_gli
+ print '_l_tang=', _l_tang
+ print '_l_tang_b=', _l_tang
+
+
+# ----------------------------------------------------------------------------
+# PREPARATION ET LANCEMENT D ECREVISSE
+
+ # TESTS de non divergence, les messages sont assez explicites :
# Si toutes les listes sont bien definies
- if len(_l_dy1)*len(_l_dy2)*len(_l_t1)*len(_l_t2) == 0:
+ if len(_l_absz_m)*len(_l_ouv)*len(_l_absz_t)*len(_l_temp_aster) == 0:
UTMESS('F','ECREVISSE0_3', valr=[Inst_Ecrevisse])
__TAB = None
break
-
# Si les ouvertures ne sont pas trop faibles
- elif min(_l_dy2) < 1e-20:
- UTMESS('F','ECREVISSE0_4', valr=[Inst_Ecrevisse, min(_l_dy2)])
+ elif min(_l_ouv) < 1e-20:
+ UTMESS('F','ECREVISSE0_4', valr=[Inst_Ecrevisse, min(_l_ouv)])
__TAB = None
break
-
elif max(_l_t2) > 700:
- UTMESS('F','ECREVISSE0_5', valr=[Inst_Ecrevisse, max(_l_t2 )])
+ UTMESS('F','ECREVISSE0_5', valr=[Inst_Ecrevisse, max(_l_t2)])
__TAB = None
break
-
elif max(_l_t2_b) > 700:
UTMESS('F','ECREVISSE0_5', valr=[Inst_Ecrevisse, max(_l_t2_b )])
__TAB = None
break
-
elif min(_l_t2) < 0:
UTMESS('F','ECREVISSE0_6', valr=[Inst_Ecrevisse, min(_l_t2 )])
__TAB = None
break
-
elif min(_l_t2_b) < 0:
UTMESS('F','ECREVISSE0_6', valr=[Inst_Ecrevisse, min(_l_t2_b )])
__TAB = None
break
-
elif abs( float(dECOULEMENT['PRES_ENTREE']) - float(dECOULEMENT['PRES_SORTIE']) )< 5:
UTMESS('F','ECREVISSE0_7', valr=[Inst_Ecrevisse, abs( float(dECOULEMENT['PRES_ENTREE']) - float(dECOULEMENT['PRES_SORTIE']) ) ] )
__TAB = None
break
-
- # On lance Ecrevisse
+ # On lance Ecrevisse!
else:
UTMESS('I','ECREVISSE0_8', valr=[Inst_Ecrevisse])
except:
pass
+ # Recalcul des cotes par rapport a la tortuoiste
+ tort = dFISSURE['TORTUOSITE']
+ try :
+ _l_absz_m = [x/tort for x in _l_absz_m]
+ _l_absz_t = [x/tort for x in _l_absz_t]
+ except ZeroDivisionError :
+ UTMESS('F','ECREVISSE0_42')
+
+
if dFISSURE.has_key('LISTE_COTES_BL'):
__LISTE_COTES_BL = dFISSURE['LISTE_COTES_BL']
else:
- __LISTE_COTES_BL = (0., max(_l_dy1))
+ __LISTE_COTES_BL = (0., max(_l_absz_m))
# Mot-cle ECOULEMENT
- txt={}
+ txt = {}
txt = { 'PRES_ENTREE' : dECOULEMENT['PRES_ENTREE'],
'PRES_SORTIE' : dECOULEMENT['PRES_SORTIE'],
'FLUIDE_ENTREE' : dECOULEMENT['FLUIDE_ENTREE'],
__TAB_i = CO('_TAB2')
__DEB_i = CO('_DEB2')
- MACR_ECRE_CALC(TABLE = __TAB_i,
- DEBIT = __DEB_i,
- ENTETE=ENTETE,
- COURBES=COURBES,
- IMPRESSION=IMPRESSION,
- INFO=INFO,
- LOGICIEL=LOGICIEL,
- VERSION=VERSION,
- FISSURE=_F(LONGUEUR = max(_l_dy1)/dFISSURE['TORTUOSITE'],
- ANGLE = alpha,
- RUGOSITE = dFISSURE['RUGOSITE'],
- ZETA = dFISSURE['ZETA'],
- SECTION = dFISSURE['SECTION'],
- LISTE_COTES_AH = _l_dy1,
- LISTE_VAL_AH = _l_dy2,
- LISTE_COTES_BL = __LISTE_COTES_BL,
- LISTE_VAL_BL = dFISSURE['LISTE_VAL_BL'],
- ),
+ MACR_ECRE_CALC(TABLE = __TAB_i,
+ DEBIT = __DEB_i,
+ ENTETE = ENTETE,
+ COURBES = COURBES,
+ IMPRESSION = IMPRESSION,
+ INFO = INFO,
+ LOGICIEL = LOGICIEL,
+ VERSION = VERSION,
+ FISSURE = _F(LONGUEUR = max(_l_absz_m),
+ ANGLE = theta,
+ RUGOSITE = dFISSURE['RUGOSITE'],
+ ZETA = dFISSURE['ZETA'],
+ SECTION = dFISSURE['SECTION'],
+ LISTE_COTES_AH = _l_absz_m,
+ LISTE_VAL_AH = _l_ouv,
+ LISTE_COTES_BL = __LISTE_COTES_BL,
+ LISTE_VAL_BL = dFISSURE['LISTE_VAL_BL'],
+ ),
TEMPERATURE=_F(GRADIENT = 'FOURNI',
- LISTE_COTES_TEMP = _l_t1,
- LISTE_VAL_TEMP = _l_t2,
+ LISTE_COTES_TEMP = _l_absz_t,
+ LISTE_VAL_TEMP = _l_temp_aster,
),
CONVERGENCE=_F(KGTEST = dCONVERGENCE['KGTEST'],
- ITER_GLOB_MAXI = dCONVERGENCE['ITER_GLOB_MAXI'],
- CRIT_CONV_DEBI = dCONVERGENCE['CRIT_CONV_DEBI'],
+ ITER_GLOB_MAXI = dCONVERGENCE['ITER_GLOB_MAXI'],
+ CRIT_CONV_DEBI = dCONVERGENCE['CRIT_CONV_DEBI'],
),
**motscle2
);
-
- # Creation de la table resultat sur toutes les fissures:
- # Nom de la fissure
- nom_fiss = dFISSURE['GROUP_MA'][0] + "-" + dFISSURE['GROUP_MA'][1]
+
+#-------------------------------------------------------------
+# EXTRACTION DES RESULTATS D ECREVISSE
+
+
+
# Creation de la table
__TABFISS_i = __TAB_i.EXTR_TABLE()
- __DEBFISS_i = __DEB_i.EXTR_TABLE()
- # Taille de la table
+
nb_lignes_table = len(__TABFISS_i["COTES"])
- # Ajout d'une colonne supplementaire
- __TABFISS_i["FISSURE"] = [nom_fiss] * nb_lignes_table
- __DEBFISS_i["FISSURE"] = [nom_fiss]
- if k==0:
- __TABFISS_tot = __TABFISS_i
- __DEBFISS_tot = __DEBFISS_i
- else:
- __TABFISS_tot = merge(__TABFISS_tot, __TABFISS_i)
- __DEBFISS_tot = merge(__DEBFISS_tot, __DEBFISS_i)
-
-
+ # Re-definition des cotes utilisateur (on elimine l effet de la tortuosite)
+ _lst_c = __TABFISS_i.COTES.values()
+ _l_cotes = [x*tort for x in _lst_c]
+ dictTab = __TABFISS_i.dict_CREA_TABLE()['LISTE']
+
+ __TABFISS_i = CREA_TABLE(LISTE = (
+ _F(PARA = "COTES", LISTE_R = _l_cotes,),
+ _F(PARA = "FLUX", LISTE_R = dictTab[1]['LISTE_R'],),
+ _F(PARA = "PRESSION", LISTE_R = dictTab[2]['LISTE_R'],),
+ _F(PARA = "TEMP", LISTE_R = dictTab[3]['LISTE_R'],),
+ _F(PARA = "COEF_CONV", LISTE_R = dictTab[4]['LISTE_R'],),
+ ),)
+
DETRUIRE(OBJET=_F(CHAINE = '__TAB_i' ),INFO=1,ALARME='NON')
DETRUIRE(OBJET=_F(CHAINE = '__DEB_i' ),INFO=1,ALARME='NON')
- if ( debug2 ):
+ if ( debug ):
os.system('ls -al ' + os.path.join(os.getcwd(),tmp_ecrevisse) )
- pref_fic = dFISSURE['PREFIXE_FICHIER']
-
- # Ecriture du fichier debits en fonction du temps:
- try:
- # on lit le fichier debit produit par ecrevisse
- f_ast = open(os.path.join(tmp_ecrevisse, 'debits'),'r')
- _txt = f_ast.read()
- f_ast.close()
- nomfic = str(pref_fic) + '_debits'
- # on concatene
- fw = open( os.getcwd() + os.sep + 'REPE_OUT' + os.sep + nomfic, 'a')
- fw.write( str(Inst_Ecrevisse) + ' ' + _txt )
- fw.close()
- # On recopie le fichier debits pour reprise ulterieure
- nomfic2 = 'debits_dernier'
- fw = open( os.getcwd() + os.sep + 'REPE_OUT' + os.sep + nomfic2, 'w')
- fw.write( _txt )
- fw.close()
- except Exception, e:
- print e
-
-
+ if dFISSURE['PREFIXE_FICHIER'] :
+ pref_fic = dFISSURE['PREFIXE_FICHIER']
+ else :
+ pref_fic = 'FISSURE'+str(k+1)
+
+ ## Ecriture du fichier debits en fonction du temps:
+ #try:
+ ## on lit le fichier debit produit par ecrevisse
+ #f_ast = open(os.path.join(tmp_ecrevisse, 'debits'),'r')
+ #_txt = f_ast.read()
+ #f_ast.close()
+ #nomfic = str(pref_fic) + '_debits'
+ ## on concatene
+ #fw = open( os.getcwd() + os.sep + 'REPE_OUT' + os.sep + nomfic, 'a')
+ #fw.write( str(Inst_Ecrevisse) + ' ' + _txt )
+ #fw.close()
+ ## On recopie le fichier debits pour reprise ulterieure
+ #nomfic2 = 'debits_dernier'
+ #fw = open( os.getcwd() + os.sep + 'REPE_OUT' + os.sep + nomfic2, 'w')
+ #fw.write( _txt )
+ #fw.close()
+ #except Exception, e:
+ #print e
+
+ # CREATION DES COURBES:
if COURBES != "AUCUNE":
- # Pour masquer certaines alarmes
- from Utilitai.Utmess import MasquerAlarme, RetablirAlarme
- MasquerAlarme('TABLE0_6')
-
- nomfic = os.path.join( os.getcwd(), 'REPE_OUT', str(pref_fic) + '_flux')
- if not os.path.isfile(nomfic): acces='NEW'
- else: acces='APPEND'
-
- DEFI_FICHIER(ACTION='ASSOCIER', UNITE=55, TYPE='ASCII', ACCES=acces, FICHIER=nomfic)
- IMPR_TABLE(FORMAT='XMGRACE',
- TABLE=__TAB_i,
- UNITE=55,
- PILOTE=COURBES,
- NOM_PARA=('COTES','FLUX',),
- TITRE='Flux de chaleur a l\'instant %s' % Inst_Ecrevisse,
- LEGENDE_X='Abscisse curviligne (m)',
- LEGENDE_Y='Flux (W/m2)',
- );
- DEFI_FICHIER(ACTION='LIBERER', UNITE=55)
-
- nomfic = os.path.join( os.getcwd(), 'REPE_OUT', str(pref_fic) + '_temperature')
- if not os.path.isfile(nomfic): acces='NEW'
- else: acces='APPEND'
-
- DEFI_FICHIER(ACTION='ASSOCIER', UNITE=55, TYPE='ASCII', ACCES=acces, FICHIER=nomfic)
- IMPR_TABLE(FORMAT='XMGRACE',
- TABLE=__TAB_i,
- UNITE=55,
- PILOTE=COURBES,
- NOM_PARA=('COTES','TEMP',),
- TITRE='Temperature a l\'instant %s' % Inst_Ecrevisse,
- LEGENDE_X='Abscisse curviligne (m)',
- LEGENDE_Y='Temperature (degres C)',
- );
- DEFI_FICHIER(ACTION='LIBERER', UNITE=55)
-
- nomfic = os.path.join( os.getcwd(), 'REPE_OUT', str(pref_fic) + '_coeffconv')
- if not os.path.isfile(nomfic): acces='NEW'
- else: acces='APPEND'
-
- DEFI_FICHIER(ACTION='ASSOCIER', UNITE=55, TYPE='ASCII', ACCES=acces, FICHIER=nomfic)
- IMPR_TABLE(FORMAT='XMGRACE',
- TABLE=__TAB_i,
- UNITE=55,
- PILOTE=COURBES,
- NOM_PARA=('COTES','COEF_CONV',),
- TITRE='Coefficient de convection a l\'instant %s' % Inst_Ecrevisse,
- LEGENDE_X='Abscisse curviligne (m)',
- LEGENDE_Y='Coefficient de convection (W/m2/K)',
- );
- DEFI_FICHIER(ACTION='LIBERER', UNITE=55)
-
- nomfic = os.path.join( os.getcwd(), 'REPE_OUT', str(pref_fic) + '_pression')
- if not os.path.isfile(nomfic): acces='NEW'
- else: acces='APPEND'
-
- DEFI_FICHIER(ACTION='ASSOCIER', UNITE=55, TYPE='ASCII', ACCES=acces, FICHIER=nomfic)
- IMPR_TABLE(FORMAT='XMGRACE',
- TABLE=__TAB_i,
- UNITE=55,
- PILOTE=COURBES,
- NOM_PARA=('COTES','PRESSION',),
- TITRE='Pression a l\'instant %s' % Inst_Ecrevisse,
- LEGENDE_X='Abscisse curviligne (m)',
- LEGENDE_Y='Pression (Pa)',
- );
- DEFI_FICHIER(ACTION='LIBERER', UNITE=55)
-
- # Pour la gestion des alarmes
- RetablirAlarme('TABLE0_6')
+ # Pour masquer certaines alarmes
+
+ MasquerAlarme('TABLE0_6')
+
+ nomfic = os.path.join( os.getcwd(), 'REPE_OUT', str(pref_fic) + '_flux'+ '_' + str(Inst_Ecrevisse))
+ if not os.path.isfile(nomfic): acces='NEW'
+ else: acces='APPEND'
+
+ DEFI_FICHIER(ACTION='ASSOCIER', UNITE=55, TYPE='ASCII', ACCES=acces, FICHIER=nomfic)
+ IMPR_TABLE(FORMAT='XMGRACE',
+ TABLE=__TABFISS_i,
+ UNITE=55,
+ PILOTE=COURBES,
+ NOM_PARA=('COTES','FLUX',),
+ TITRE='Flux de chaleur a l\'instant %s' % Inst_Ecrevisse,
+ LEGENDE_X='Abscisse curviligne (m)',
+ LEGENDE_Y='Flux (W/m2)',
+ COULEUR = 1,
+ MARQUEUR = 1,
+ );
+ DEFI_FICHIER(ACTION='LIBERER', UNITE=55)
+
+ nomfic = os.path.join( os.getcwd(), 'REPE_OUT', str(pref_fic) + '_temperature'+ '_' + str(Inst_Ecrevisse))
+ if not os.path.isfile(nomfic): acces='NEW'
+ else: acces='APPEND'
+
+ DEFI_FICHIER(ACTION='ASSOCIER', UNITE=55, TYPE='ASCII', ACCES=acces, FICHIER=nomfic)
+ IMPR_TABLE(FORMAT='XMGRACE',
+ TABLE=__TABFISS_i,
+ UNITE=55,
+ PILOTE=COURBES,
+ NOM_PARA=('COTES','TEMP',),
+ TITRE='Temperature a l\'instant %s' % Inst_Ecrevisse,
+ LEGENDE_X='Abscisse curviligne (m)',
+ LEGENDE_Y='Temperature (degres C)',
+ COULEUR = 2,
+ MARQUEUR = 2,
+ );
+ DEFI_FICHIER(ACTION='LIBERER', UNITE=55)
+
+ nomfic = os.path.join( os.getcwd(), 'REPE_OUT', str(pref_fic) + '_coeffconv'+ '_' + str(Inst_Ecrevisse))
+ if not os.path.isfile(nomfic): acces='NEW'
+ else: acces='APPEND'
+
+ DEFI_FICHIER(ACTION='ASSOCIER', UNITE=55, TYPE='ASCII', ACCES=acces, FICHIER=nomfic)
+ IMPR_TABLE(FORMAT='XMGRACE',
+ TABLE=__TABFISS_i,
+ UNITE=55,
+ PILOTE=COURBES,
+ NOM_PARA=('COTES','COEF_CONV',),
+ TITRE='Coefficient de convection a l\'instant %s' % Inst_Ecrevisse,
+ LEGENDE_X='Abscisse curviligne (m)',
+ LEGENDE_Y='Coefficient de convection (W/m2/K)',
+ COULEUR = 3,
+ MARQUEUR = 3,
+ );
+ DEFI_FICHIER(ACTION='LIBERER', UNITE=55)
+
+
+ nomfic = os.path.join( os.getcwd(), 'REPE_OUT', str(pref_fic) + '_pression'+ '_' + str(Inst_Ecrevisse))
+ if not os.path.isfile(nomfic): acces='NEW'
+ else: acces='APPEND'
+
+ DEFI_FICHIER(ACTION='ASSOCIER', UNITE=55, TYPE='ASCII', ACCES=acces, FICHIER=nomfic)
+ IMPR_TABLE(FORMAT='XMGRACE',
+ TABLE=__TABFISS_i,
+ UNITE=55,
+ PILOTE=COURBES,
+ NOM_PARA=('COTES','PRESSION',),
+ TITRE='Pression a l\'instant %s' % Inst_Ecrevisse,
+ LEGENDE_X='Abscisse curviligne (m)',
+ LEGENDE_Y='Pression (Pa)',
+ COULEUR = 4,
+ MARQUEUR = 4,
+ );
+ DEFI_FICHIER(ACTION='LIBERER', UNITE=55)
+
+ # Pour la gestion des alarmes
+ RetablirAlarme('TABLE0_6')
+
# On recopie dans REPE_OUT les fichiers resultats d'Ecrevisse
new_file = os.path.join(repe_out_absolu, str(pref_fic) + '_' + file + '_' + str(Inst_Ecrevisse))
shutil.copy(old_file, new_file)
- if ( debug2 ):
- os.system('ls -al ' + os.path.join(os.getcwd(),tmp_ecrevisse) )
+ # Creation de la table resultat sur toutes les fissures :
+ # Nom de la fissure
+ nom_fiss = dFISSURE['GROUP_MA'][0] + "-" + dFISSURE['GROUP_MA'][1]
+ __TABFISS_i = __TABFISS_i.EXTR_TABLE()
+ __DEBFISS_i = __DEB_i.EXTR_TABLE()
+ __TABFISS_i["FISSURE"] = [nom_fiss]*nb_lignes_table
+ __DEBFISS_i["FISSURE"] = [nom_fiss]
+ if k==0 :
+ __TABFISS_tot = __TABFISS_i
+ __DEBFISS_tot = __DEBFISS_i
+ else :
+ __TABFISS_tot = merge(__TABFISS_tot, __TABFISS_i)
+ __DEBFISS_tot = merge(__DEBFISS_tot, __DEBFISS_i)
- # Creation des chargements Aster
- # ******************************
+
+ if ( debug ):
+ os.system('ls -al ' + os.path.join(os.getcwd(),tmp_ecrevisse) )
+
+#--------------------------------------------------------------
+# CREATIONS DES CHARGEMENTS ASTER
# Recuperation des valeurs dans la table (voir si il y a plus simple)
- _lst_c = __TABFISS_i.COTES.values()
- _lst_f = __TABFISS_i.FLUX.values()
- _lst_p = __TABFISS_i.PRESSION.values()
- _lst_t = __TABFISS_i.TEMP.values()
+ _lst_c = __TABFISS_i.COTES.values()
+ _lst_f = __TABFISS_i.FLUX.values()
+ _lst_p = __TABFISS_i.PRESSION.values()
+ _lst_t = __TABFISS_i.TEMP.values()
_lst_cc = __TABFISS_i.COEF_CONV.values()
- _lis_dtot = __TABFISS_i.DEBTOT.values()
- _lis_dair = __TABFISS_i.DEBAIR.values()
- _lis_dvap = __TABFISS_i.DEBVAP.values()
- _lis_dliq = __TABFISS_i.DEBLIQ.values()
- _lis_ecou = __TABFISS_i.ECOULEMENT.values()
-
- if ( debug2 ):
- print '_lst_c2=',_lst_c
- print '_lst_f2=',_lst_f
- print '_lst_p2=',_lst_p
- print '_lst_t2=',_lst_t
- print '_lst_cc2=',_lst_cc
try:
a=len(_lst_c)
pass
+
# ------------------------------------------------------
# Extraction des conditions limites du calcul Ecrevisse
#
if len(_lst_c)>=2:
- if ( debug2 ):
- print '_lst_c=',_lst_c
- print '_lst_f=',_lst_f
- print '_lst_p=',_lst_p
- print '_lst_t=',_lst_t
- print '_lst_cc=',_lst_cc
-
- _lst_f=list(_lst_f)
- _lst_p=list(_lst_p)
- _lst_t=list(_lst_t)
- _lst_cc=list(_lst_cc)
-
- # decalage par rapport a l'abscisse curviligne (a regler)
- _x0 = 0.001
+ if not chargeLin :
+ nbCotes = len(_l_absz_m)
+ nbCotesEcre = nbCotes-1
+
+ # epsilon pour le decalage :
+ # le chargement est uniforme par maille
+ if _X0[1]>=_X0[0] :
+ epsx = 1.e-8
+ else :
+ epsx = -1.e-8
+ if _Y0[1]>=_Y0[0] :
+ epsy = 1.e-8
+ else :
+ epsy = -1.e-8
+
+ _lst_x0 = []
+ _lst_y0 = []
+ _lst_x0_b = []
+ _lst_y0_b = []
+ ly = []
+ ly2 = []
+ ly3 = []
+ ly4 = []
+
+ _lst_x0.append(_X0[0])
+ _lst_y0.append(_Y0[0])
+ _lst_x0_b.append(_X0_b[0])
+ _lst_y0_b.append(_Y0_b[0])
+ ly.append( _lst_f[0] )
+ ly2.append( _lst_p[0] )
+ ly3.append( _lst_t[0] )
+ ly4.append( _lst_cc[0] )
+
+ for i in range(nbCotes-2):
+ x = _X0[i+1]
+ y = _Y0[i+1]
+ toto1 = x - epsx
+ toto2 = x + epsx
+
+ _lst_x0.append( x - epsx )
+ _lst_x0.append( x + epsx )
+ _lst_y0.append( y - epsy )
+ _lst_y0.append( y + epsy )
+ x = _X0_b[i+1]
+ y = _Y0_b[i+1]
+ _lst_x0_b.append( x - epsx )
+ _lst_x0_b.append( x + epsx )
+ _lst_y0_b.append( y - epsy )
+ _lst_y0_b.append( y + epsy )
+ ly.append( _lst_f[i] )
+ ly.append( _lst_f[i+1] )
+ ly2.append( _lst_p[i] )
+ ly2.append( _lst_p[i+1] )
+ ly3.append( _lst_t[i] )
+ ly3.append( _lst_t[i+1] )
+ ly4.append( _lst_cc[i] )
+ ly4.append( _lst_cc[i+1] )
+
+ _lst_x0.append( _X0[nbCotes-1] )
+ _lst_y0.append( _Y0[nbCotes-1] )
+ _lst_x0_b.append( _X0_b[nbCotes-1] )
+ _lst_y0_b.append( _Y0_b[nbCotes-1] )
+ ly.append( _lst_f[nbCotesEcre-1] )
+ ly2.append( _lst_p[nbCotesEcre-1] )
+ ly3.append( _lst_t[nbCotesEcre-1] )
+ ly4.append( _lst_cc[nbCotesEcre-1] )
+ _lst_f = ly
+ _lst_p = ly2
+ _lst_t = ly3
+ _lst_cc = ly4
+ else :
+ _lst_x0 = [(x1+x2)*0.5 for (x1,x2) in zip(_X0[0:len(_X0)-1],_X0[1:len(_X0)])]
+ _lst_y0 = [(x1+x2)*0.5 for (x1,x2) in zip(_Y0[0:len(_Y0)-1],_Y0[1:len(_Y0)])]
+ _lst_x0_b = [(x1+x2)*0.5 for (x1,x2) in zip(_X0_b[0:len(_X0_b)-1],_X0_b[1:len(_X0_b)])]
+ _lst_y0_b = [(x1+x2)*0.5 for (x1,x2) in zip(_Y0_b[0:len(_Y0_b)-1],_Y0_b[1:len(_Y0_b)])]
+ _lst_x0.append(_X0[-1])
+ _lst_x0_b.append(_X0_b[-1])
+ _lst_y0.append(_Y0[-1])
+ _lst_y0_b.append(_Y0_b[-1])
# ANCIENNE VERSION (TRANSMISSION DES FLUX THERMIQUES
if(oldVersion) :
- # Creation des deux listes (x1, y1, x2, y2, ...)
+ alpha = round(theta)
+ if DIR_FISS == 'X' :
+ levre1pos = ((_Y0[0]-_yi)>=0.)
+ if alpha == -90. :
+ _lst_x0.reverse()
+ _lst_p.reverse()
+ _lst_f.reverse()
+ _lst_dir = _lst_x0
+ else :
+ levre1pos = ((_X0[0]-_xi)>=0.)
+ if abs(alpha) == 180. :
+ _lst_y0.reverse()
+ _lst_p.reverse()
+ _lst_f.reverse()
+ _lst_dir = _lst_y0
+
+ # Creation des listes pour les chargements aster :
+ # (x1, y1, x2, y2, ...)
_tmp1=[]
_tmp2=[]
_tmp3=[]
- for i in range(len(_lst_c)):
- _tmp1.append( _x0 + _lst_c[i] )
- _tmp1.append( _lst_f[i] )
- _tmp3.append( _x0 + _lst_c[i] )
- _tmp3.append( -1*_lst_f[i] )
+ for i in range(len(_lst_p)) :
+ _tmp1.append( _lst_dir[i] )
+ _tmp2.append( _lst_dir[i] )
+ _tmp3.append( _lst_dir[i] )
- _tmp2.append( _x0 + _lst_c[i] )
_tmp2.append( _lst_p[i] )
+ if levre1pos :
+ #_tmp1.append( -1*_lst_f[i] )
+ #_tmp3.append( _lst_f[i] )
+ _tmp1.append( _lst_f[i] )
+ _tmp3.append( -1*_lst_f[i] )
+ else :
+ #_tmp1.append( _lst_f[i] )
+ #_tmp3.append( -1*_lst_f[i] )
+ _tmp1.append( -1*_lst_f[i] )
+ _tmp3.append( _lst_f[i] )
+
- # Flux en provenance d'Ecrevisse
+ # Flux en provenance d'Ecrevisse
_L_F1=DEFI_FONCTION(NOM_PARA=DIR_FISS,
VALE=_tmp1,
- PROL_GAUCHE='CONSTANT',
- PROL_DROITE='CONSTANT');
+ PROL_GAUCHE='LINEAIRE',
+ PROL_DROITE='LINEAIRE');
_L_F2=DEFI_FONCTION(NOM_PARA=DIR_FISS,
VALE=_tmp3,
- PROL_GAUCHE='CONSTANT',
- PROL_DROITE='CONSTANT' );
-
- l_FLUX_REP_F1.append(_F(GROUP_MA=dFISSURE['GROUP_MA'][0],
- FLUX_X=_L_F1,))
-
- l_FLUX_REP_F2.append(_F(GROUP_MA=dFISSURE['GROUP_MA'][1],
- FLUX_X=_L_F2,))
+ PROL_GAUCHE='LINEAIRE',
+ PROL_DROITE='LINEAIRE' );
+
+ if DIR_FISS == 'X':
+ l_FLUX_REP_F1.append(_F(GROUP_MA=dFISSURE['GROUP_MA'][0],
+ FLUX_Y=_L_F1,))
+ l_FLUX_REP_F2.append(_F(GROUP_MA=dFISSURE['GROUP_MA'][1],
+ FLUX_Y=_L_F2,))
+ else :
+ l_FLUX_REP_F1.append(_F(GROUP_MA=dFISSURE['GROUP_MA'][0],
+ FLUX_X=_L_F1,))
+ l_FLUX_REP_F2.append(_F(GROUP_MA=dFISSURE['GROUP_MA'][1],
+ FLUX_X=_L_F2,))
# Pressions en provenance d'Ecrevisse
- _L_P=DEFI_FONCTION(NOM_PARA=DIR_FISS,
- VALE=_tmp2,
- PROL_GAUCHE='CONSTANT',
- PROL_DROITE='CONSTANT');
+ _L_P=DEFI_FONCTION(NOM_PARA = DIR_FISS,
+ VALE = _tmp2,
+ PROL_GAUCHE = 'LINEAIRE',
+ PROL_DROITE = 'LINEAIRE');
l_PRES_REP.append(_F(GROUP_MA=(dFISSURE['GROUP_MA'][0],dFISSURE['GROUP_MA'][1]),
PRES=_L_P,))
+
+
# NOUVELLE VERSION
else :
-
# Creation des deux listes (x1, y1, x2, y2, ...)
+ # On cree trois/six listes :
+ # Les valeurs sont constant par maille sur les levres de la fissure,
+ # _tmp1/_tmp2 = temperature
+ # _tmp3/_tmp4 = coefficient d echange
+ # _tmp5/_tmp6 = pression
_tmp1=[]
_tmp2=[]
_tmp3=[]
-
- for i in range(len(_lst_c)):
- # On cree trois listes :
- # _tmp1=temperature en chaque point du maillage,
- # _tmp3=coefficient d echange en chaque point du maillage
- # _tmp2=pression en chaque point du maillage
- _tmp1.append( _x0 + _lst_c[i] )
- _tmp1.append( _lst_t[i] )
- _tmp3.append( _x0 + _lst_c[i] )
- _tmp3.append( _lst_cc[i] )
-
- _tmp2.append( _x0 + _lst_c[i] )
- _tmp2.append( _lst_p[i] )
-
- _L_F1=DEFI_FONCTION(NOM_PARA=DIR_FISS,
+ _tmp4=[]
+ _tmp5=[]
+ _tmp6=[]
+
+ for i in range(len(_lst_f)) :
+ ix = copy(i)
+ iy = copy(i)
+ if _X0[1]<_X0[0] :
+ ix = len(_lst_f)-1-i
+ if _Y0[1]<_Y0[0] :
+ iy = len(_lst_f)-1-i
+
+ if (DIR_PREV=='X'):
+ _tmp1.append( _lst_x0[ix] )
+ _tmp1.append( _lst_t[ix] )
+ _tmp3.append( _lst_x0[ix] )
+ _tmp3.append( _lst_cc[ix] )
+ _tmp5.append( _lst_x0[ix] )
+ _tmp5.append( _lst_p[ix] )
+ _tmp2.append( _lst_x0_b[ix] )
+ _tmp2.append( _lst_t[ix] )
+ _tmp4.append( _lst_x0_b[ix] )
+ _tmp4.append( _lst_cc[ix] )
+ _tmp6.append( _lst_x0_b[ix] )
+ _tmp6.append( _lst_p[ix] )
+ else :
+ _tmp1.append( _lst_y0[iy] )
+ _tmp1.append( _lst_t[iy] )
+ _tmp3.append( _lst_y0[iy] )
+ _tmp3.append( _lst_cc[iy] )
+ _tmp5.append( _lst_y0[iy] )
+ _tmp5.append( _lst_p[iy] )
+ _tmp2.append( _lst_y0_b[iy] )
+ _tmp2.append( _lst_t[iy] )
+ _tmp4.append( _lst_y0_b[iy] )
+ _tmp4.append( _lst_cc[iy] )
+ _tmp6.append( _lst_y0_b[iy] )
+ _tmp6.append( _lst_p[iy] )
+
+
+
+
+
+ # Couplage thermique : Temperature et coefficients d'echange en provenance d'Ecrevisse
+ _L_T1=DEFI_FONCTION(NOM_PARA=DIR_PREV,
VALE=_tmp1,
- PROL_GAUCHE='CONSTANT',
- PROL_DROITE='CONSTANT');
+ PROL_GAUCHE='LINEAIRE',
+ PROL_DROITE='LINEAIRE')
- _L_F2=DEFI_FONCTION(NOM_PARA=DIR_FISS,
+ _L_T2=DEFI_FONCTION(NOM_PARA=DIR_PREV,
+ VALE=_tmp2,
+ PROL_GAUCHE='LINEAIRE',
+ PROL_DROITE='LINEAIRE')
+
+ _L_CC1=DEFI_FONCTION(NOM_PARA=DIR_PREV,
VALE=_tmp3,
- PROL_GAUCHE='CONSTANT',
- PROL_DROITE='CONSTANT');
+ PROL_GAUCHE='LINEAIRE',
+ PROL_DROITE='LINEAIRE')
+
+ _L_CC2=DEFI_FONCTION(NOM_PARA=DIR_PREV,
+ VALE=_tmp4,
+ PROL_GAUCHE='LINEAIRE',
+ PROL_DROITE='LINEAIRE')
l_ECHANGE_F1.append(_F(GROUP_MA=dFISSURE['GROUP_MA'][0],
- TEMP_EXT=_L_F1,
- COEF_H=_L_F2))
+ TEMP_EXT=_L_T1,
+ COEF_H=_L_CC2))
l_ECHANGE_F2.append(_F(GROUP_MA=dFISSURE['GROUP_MA'][1],
- TEMP_EXT=_L_F1,
- COEF_H=_L_F2))
+ TEMP_EXT=_L_T2,
+ COEF_H=_L_CC2))
- # Pressions en provenance d'Ecrevisse
- _L_P=DEFI_FONCTION(NOM_PARA=DIR_FISS,
- VALE=_tmp2,
- PROL_GAUCHE='CONSTANT',
- PROL_DROITE='CONSTANT');
+ # Couplage mecanique : Pressions en provenance d'Ecrevisse
+ _L_P1=DEFI_FONCTION(NOM_PARA=DIR_PREV,
+ VALE=_tmp5,
+ PROL_GAUCHE='LINEAIRE',
+ PROL_DROITE='LINEAIRE')
- l_PRES_REP.append(_F(GROUP_MA=(dFISSURE['GROUP_MA'][0],dFISSURE['GROUP_MA'][1]),
- PRES=_L_P,))
+ _L_P2=DEFI_FONCTION(NOM_PARA=DIR_PREV,
+ VALE=_tmp6,
+ PROL_GAUCHE='LINEAIRE',
+ PROL_DROITE='LINEAIRE')
+
+ l_PRES_REP.append(_F(GROUP_MA=(dFISSURE['GROUP_MA'][0]),
+ PRES=_L_P1,))
+ l_PRES_REP.append(_F(GROUP_MA=(dFISSURE['GROUP_MA'][1]),
+ PRES=_L_P2,))
- #
# Fin extraction des conditions limites du calcul Ecrevisse
# ----------------------------------------------------------
- # Fin de la boucle sur les fissures
-
+ if debug :
+ print ('FISSURE-'+str(k+1))
+ print '_lst_c:', len(_lst_c), _lst_c
+ print '_lst_f:', len(_lst_f), _lst_f
+ print '_lst_p:', len(_lst_p), _lst_p
+ print '_lst_t:', len(_lst_t), _lst_t
+ print '_lst_cc:', len(_lst_cc), _lst_cc
+ print '_lst_x0:', len(_lst_x0), _lst_x0
+ print '_lst_x0_b :', len(_lst_x0_b), _lst_x0_b
+ print '_lst_y0:', len(_lst_y0), _lst_y0
+ print '_lst_y0_b :', len(_lst_y0_b), _lst_y0_b
+ print '_tmp1 :', len(_tmp1), _tmp1
+ print '_tmp2 :', len(_tmp2), _tmp2
+ print '_tmp3 :', len(_tmp3), _tmp3
+ if (not oldVersion) :
+ print '_tmp4 :', len(_tmp4), _tmp4
+ print '_tmp5 :', len(_tmp5), _tmp5
+ print '_tmp6 :', len(_tmp6), _tmp6
+
+ #Fin du boucle sur la fissure for k
# Assemblage des concepts sortants
-#@ MODIF calc_essai_ops Macro DATE 21/10/2008 AUTEUR NISTOR I.NISTOR
+#@ MODIF calc_essai_ops Macro DATE 09/02/2010 AUTEUR MACOCCO K.MACOCCO
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
def calc_essai_ops( self,
INTERACTIF = None,
- UNITE_FIMEN = None,
- UNITE_RESU = None,
EXPANSION = None,
- MEIDEE_FLUDELA = None,
- MEIDEE_TURBULENT = None,
IDENTIFICATION = None,
MODIFSTRUCT = None,
GROUP_NO_CAPTEURS = None,
GROUP_NO_EXTERIEUR = None,
- RESU_FLUDELA = None,
- RESU_TURBULENT = None,
RESU_IDENTIFICATION = None,
RESU_MODIFSTRU = None,
**args):
"ComptTable" : 0,
"TablesOut" : table_fonction}
- if not RESU_FLUDELA:
- RESU_FLUDELA = []
- else:
- for res in RESU_FLUDELA:
- table.append(res['TABLE'])
- out_fludela = {"DeclareOut" : self.DeclareOut,
- "TypeTables" : 'TABLE',
- "ComptTable" : 0,
- "TablesOut" : table}
-
- if not RESU_TURBULENT:
- RESU_TURBULENT = []
- else:
- for res in RESU_TURBULENT:
- table.append(res['FONCTION'])
- out_meideeturb = {"DeclareOut" : self.DeclareOut,
- "FoncOut" : table}
-
# Mode interactif : ouverture d'une fenetre Tk
if INTERACTIF == "OUI":
create_interactive_window(self,
- UNITE_FIMEN,
- UNITE_RESU,
- out_fludela,
- out_meideeturb,
out_identification,
out_modifstru)
else:
from Meidee.meidee_calcul import MessageBox
from Meidee.meidee_test import TestMeidee
+ UNITE_RESU=7
mess = MessageBox(UNITE_RESU)
mess.disp_mess("Mode non intéractif")
# importation des concepts aster existants de la memoire jeveux
TestMeidee(self,
mess,
- out_fludela,
- out_meideeturb,
out_identification,
out_modifstru,
objects,
EXPANSION,
- MEIDEE_FLUDELA,
- MEIDEE_TURBULENT,
IDENTIFICATION,
MODIFSTRUCT,
GROUP_NO_CAPTEURS,
tabs = TabbedWindow(tabsw, ["Expansion de modeles",
"Modification structurale",
- "MEIDEE mono-modal fludela",
- "MEIDEE mono-modal turbulent",
"Identification de chargement",
"Parametres de visualisation"])
def create_interactive_window(macro,
- UNITE_FIMEN,
- UNITE_RESU,
- out_fludela,
- out_meideeturb,
out_identification,
out_modifstru):
"""Construit la fenêtre interactive comprenant une table pour
from Meidee.meidee_cata import MeideeObjects
from Meidee.meidee_correlation import InterfaceCorrelation
from Meidee.meidee_modifstruct import InterfaceModifStruct
- from Meidee.meidee_fludela import InterfaceFludela, InterfaceTurbMonomod
- from Meidee.meidee_turbulent import InterfaceTurbulent
from Meidee.meidee_parametres import InterfaceParametres
# fenetre principale
iface = InterfaceCorrelation(main, objects, macro, mess, param_visu)
imodifstruct = InterfaceModifStruct(main, objects, macro,
mess, out_modifstru, param_visu)
- fludelamonomod = InterfaceFludela(main, objects,
- get_fimen_files(UNITE_FIMEN), mess, out_fludela, param_visu)
- turbmonomod = InterfaceTurbMonomod(main, objects,get_fimen_files(UNITE_FIMEN) ,mess, out_meideeturb, param_visu)
turbulent = InterfaceTurbulent(main, objects, mess, out_identification, param_visu)
tabs.set_tab("Expansion de modeles", iface.main)
tabs.set_tab("Modification structurale", imodifstruct.main)
- tabs.set_tab("MEIDEE mono-modal fludela", fludelamonomod )
- tabs.set_tab("MEIDEE mono-modal turbulent", turbmonomod )
tabs.set_tab("Identification de chargement", turbulent)
tabs.set_tab("Parametres de visualisation", param_visu)
-#@ MODIF calc_table_ops Macro DATE 19/02/2008 AUTEUR COURTOIS M.COURTOIS
+#@ MODIF calc_table_ops Macro DATE 05/01/2010 AUTEUR MACOCCO K.MACOCCO
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
lpar = [lpar]
for p in lpar:
if not p in tab.para:
- UTMESS('F','TABLE0_4',valk=[p, TABLE.nom])
+ UTMESS('F','TABLE0_2',valk=[p, TABLE.nom])
if not p in tab2.para:
- UTMESS('F','TABLE0_5',valk=[p,occ['TABLE'].nom] )
+ UTMESS('F','TABLE0_2',valk=[p,occ['TABLE'].nom] )
opts.append(lpar)
tab = merge(*opts)
--- /dev/null
+#@ MODIF defi_fonc_elec_ops Macro DATE 09/02/2010 AUTEUR MACOCCO K.MACOCCO
+# -*- coding: iso-8859-1 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2010 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+
+from math import cos,exp,pi
+
+def FcompletGR1(T,I1,I2,FR,TR,PHI1,PHI2,TAU1,TAU2) :
+ fxt= 4.E-7 * I1 * I2
+ fxt= fxt * (cos(2*pi*FR*(T-TR)+PHI1*pi/180.)-exp(-(T-TR)/TAU1)*cos(PHI1*pi/180.))
+ fxt= fxt * (cos(2*pi*FR*(T-TR)+PHI2*pi/180.)-exp(-(T-TR)/TAU2)*cos(PHI2*pi/180.))
+ return fxt
+
+def FcontinuGR1(T,I1,I2,TR,PHI1,PHI2,TAU1,TAU2) :
+ ft1= exp(-(T-TR)*(1./TAU1+1./TAU2))
+ ft1= ft1*cos(PHI1*pi/180.)*cos(PHI2*pi/180.)
+ ft1= ft1+0.5*cos(PHI2*pi/180.-PHI1*pi/180.)
+ fxt= 4.E-7 * I1 * I2 * ft1
+ return fxt
+
+def FcompletGR2(T,I1,I2,FR,TR,PHI1,PHI2,TAU1,TAU2,D) :
+ fxt= 4.E-7 * I1 * I2 / D
+ fxt= fxt * (cos(2*pi*FR*(T-TR)+PHI1*pi/180.)-exp(-(T-TR)/TAU1)*cos(PHI1*pi/180.))
+ fxt= fxt * (cos(2*pi*FR*(T-TR)+PHI2*pi/180.)-exp(-(T-TR)/TAU2)*cos(PHI2*pi/180.))
+ return fxt
+
+def FcontinuGR2(T,I1,I2,TR,PHI1,PHI2,TAU1,TAU2,D) :
+ ft1= exp(-(T-TR)*(1./TAU1+1./TAU2))
+ ft1= ft1*cos(PHI1*pi/180.)*cos(PHI2*pi/180.)
+ ft1= ft1+0.5*cos(PHI2*pi/180.-PHI1*pi/180.)
+ fxt= 4.E-7 * I1 * I2 * ft1 / D
+ return fxt
+
+## fonction post réenclenchement, valable entre l'instant de réenclenchement et l'instant de fin de réenclenchement. Sinon 0.
+def FcompletGR2R(T,I1R,I2R,FR,TRR,PHIR1,PHI2R,TAU1R,TAU2R,D) :
+ fxt= 4.E-7 * I1R * I2R / D
+ fxt= fxt * (cos(2*pi*FR*(T-TRR)+PHI1R*pi/180.)-exp(-(T-TRR)/TAU1R)*cos(PHI1R*pi/180.))
+ fxt= fxt * (cos(2*pi*FR*(T-TRR)+PHI2R*pi/180.)-exp(-(T-TRR)/TAU2R)*cos(PHI2R*pi/180.))
+ return fxt
+
+## fonction post réenclenchement, valable entre l'instant de réenclenchement et l'instant de fin de réenclenchement. Sinon 0.
+def FcontinuGR2R(T,I1R,I2R,TRR,PHI1R,PHI2R,TAU1R,TAU2R,D) :
+ ft1= exp(-(T-TRR)*(1./TAU1R+1./TAU2R))
+ ft1= ft1*cos(PHI1R*pi/180.)*cos(PHI2R*pi/180.)
+ ft1= ft1+0.5*cos(PHI2R*pi/180.-PHI1R*pi/180.)
+ fxt= 4.E-7 * I1R * I2R * ft1 / D
+ return fxt
+
+
+
+def defi_fonc_elec_ops(self,FREQ,SIGNAL,COUR,COUR_PRIN,COUR_SECO,**args):
+ ier=0
+ from Utilitai.Utmess import UTMESS
+ import Numeric
+
+ # On importe les definitions des commandes a utiliser dans la macro
+ # Le nom de la variable doit etre obligatoirement le nom de la commande
+ DEFI_FONCTION =self.get_cmd('DEFI_FONCTION')
+ FORMULE =self.get_cmd('FORMULE')
+ CALC_FONC_INTERP =self.get_cmd('CALC_FONC_INTERP')
+
+ ### Comptage commandes + déclaration concept sortant
+ self.set_icmd(1)
+ self.DeclareOut('C_out',self.sd)
+#
+ if COUR :
+ TINI =COUR[ 0]['INST_CC_INIT']
+ TFIN =COUR[-1]['INST_CC_FIN']
+ pas_t=1./(40.*FREQ)
+#
+ temps = []
+ fff = []
+#
+ T2moins = COUR[0]['INST_CC_FIN']
+ TR = COUR[0]['INST_CC_INIT']
+ premier = 1
+ for k_cour in COUR :
+ I1 = k_cour['INTE_CC_1']
+ I2 = k_cour['INTE_CC_2']
+ PHI1 = k_cour['PHI_CC_1']
+ PHI2 = k_cour['PHI_CC_2']
+ TAU1 = k_cour['TAU_CC_1']
+ TAU2 = k_cour['TAU_CC_2']
+ T1 = k_cour['INST_CC_INIT']
+ T2 = k_cour['INST_CC_FIN']
+ if (abs(T1-T2moins)<1.E-7) : pass
+ elif (premier==1) : pass
+ else :
+ TR=T1
+ temps.append(T2moins)
+ fff.append(0.)
+ T2moins=T2
+ premier=0
+ t_k_cour=Numeric.arange((T2-T1)/pas_t)
+ t_k_cour=t_k_cour*pas_t
+ t_k_cour=t_k_cour+T1
+ t_k_cour=t_k_cour.tolist()
+ print T1,T2,FREQ
+ temps=temps+t_k_cour
+ if SIGNAL=='CONTINU' :
+ for t in t_k_cour :
+ fff.append( FcontinuGR1(t,I1,I2,TR,PHI1,PHI2,TAU1,TAU2) )
+ elif SIGNAL=='COMPLET' :
+ for t in t_k_cour :
+ fff.append(FcompletGR1(t,I1,I2,FREQ,TR,PHI1,PHI2,TAU1,TAU2))
+#
+ elif COUR_PRIN :
+ TINI =COUR_PRIN[0]['INST_CC_INIT']
+ TFIN =COUR_PRIN[0]['INST_CC_FIN']
+#
+ TINIR = COUR_PRIN[0]['INST_RENC_INIT']
+ TFINR = COUR_PRIN[0]['INST_RENC_FIN']
+#
+ pas_t=1./(40.*FREQ)
+#
+ temps = []
+ fff = []
+ T2moins = max(TFIN,TFINR)
+ TR = COUR_PRIN[0]['INST_CC_INIT']
+ TRR = COUR_PRIN[0]['INST_RENC_INIT']
+ I1 = COUR_PRIN[0]['INTE_CC_1']
+ I1R = COUR_PRIN[0]['INTE_RENC_1']
+ PHI1 = COUR_PRIN[0]['PHI_CC_1']
+ PHI1R = COUR_PRIN[0]['PHI_RENC_1']
+ TAU1 = COUR_PRIN[0]['TAU_CC_1']
+ TAU1R = COUR_PRIN[0]['TAU_RENC_1']
+#
+ fff.append(0.)
+#
+ if (abs(TR-T2moins)<1.E-7) : pass
+ else :
+ temps.append(0)
+ t_k_cour=Numeric.arange((T2moins-TR)/pas_t)
+ t_k_cour=t_k_cour*pas_t
+ t_k_cour=t_k_cour+TR
+ t_k_cour=t_k_cour.tolist()
+ temps=temps+t_k_cour
+#
+ for k_cour in COUR_SECO :
+ I2 = k_cour['INTE_CC_2']
+ PHI2 = k_cour['PHI_CC_2']
+ TAU2 = k_cour['TAU_CC_2']
+ I2R = k_cour['INTE_RENC_2']
+ PHI2R = k_cour['PHI_RENC_2']
+ TAU2R = k_cour['TAU_RENC_2']
+ DIST = k_cour['DIST']
+#
+ if SIGNAL=='CONTINU' :
+ for i in range(len(temps)) :
+ if temps[i]>TINI :
+ if temps[i]<TFIN :
+ fff[i]=fff[i]+FcontinuGR2(temps[i],I1,I2,TR,PHI1,PHI2,TAU1,TAU2,DIST)
+ if temps[i]>TINIR :
+ if temps[i]<TFINR :
+ fff[i]=fff[i]+FcontinuGR2R(temps[i],I1R,I2R,TRR,PHI1R,PHI2R,TAU1R,TAU2R,DIST)
+#
+ if SIGNAL=='COMPLET' :
+ for i in range(len(temps)) :
+ if temps[i]>TINI :
+ if temps[i]<TFIN :
+ fff[i]=fff[i]+FcompletGR2(temps[i],I1,I2,TR,PHI1,PHI2,TAU1,TAU2,DIST)
+ if temps[i]>TINIR :
+ if temps[i]<TFINR :
+ fff[i]=fff[i]+FcompletGR2R(temps[i],I1R,I2R,TRR,PHI1R,PHI2R,TAU1R,TAU2R,DIST)
+#
+ vale=[]
+ for i in range(len(temps)) :
+ vale.append(temps[i])
+ vale.append(fff[i])
+ vale.append(temps[-1]+2*pas_t)
+ vale.append(0.)
+#
+ C_out=DEFI_FONCTION(NOM_PARA='INST',NOM_RESU='ELEC',
+ VALE=vale,
+ PROL_DROITE='CONSTANT',
+ PROL_GAUCHE='CONSTANT',)
+ return ier
-#@ MODIF exec_logiciel_ops Macro DATE 18/11/2009 AUTEUR MACOCCO K.MACOCCO
+#@ MODIF exec_logiciel_ops Macro DATE 08/04/2010 AUTEUR MACOCCO K.MACOCCO
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# RESPONSABLE COURTOIS M.COURTOIS
-import os.path
+import os
+import os.path as osp
import traceback
import shutil
from types import ListType, TupleType
dMCF = mcf.cree_dict_valeurs(mcf.mc_liste)
d_para['fichIN'] = 'fort.%d' % dMCF['UNITE_GEOM']
d_para['fichOUT'] = 'fort.%d' % dMCF['UNITE']
+ if osp.exists(d_para['fichOUT']):
+ os.remove(d_para['fichOUT'])
if dMCF['FORMAT'] == 'GMSH':
mode_lancement = CMD_EXTERNE
cmd = '%(prog)s %(options)s -o %(fichOUT)s %(fichIN)s'
- d_para['prog'] = os.path.join(aster.repout(), 'gmsh')
+ d_para['prog'] = osp.join(aster.repout(), 'gmsh')
d_para['options'] = ('-3',)
elif dMCF['FORMAT'] == 'GIBI':
mode_lancement = CMD_EXTERNE
cmd = '%(prog)s %(options)s %(fichIN)s %(fichOUT)s'
- d_para['prog'] = os.path.join(aster.repout(), 'gibi')
+ d_para['prog'] = osp.join(aster.repout(), 'gibi')
elif dMCF['FORMAT'] == 'SALOME':
mode_lancement = EXECFILE
txt = open(d_para['fichIN'], 'r').read()
UTMESS('F', 'EXECLOGICIEL0_5', valk=txt)
- if not os.path.exists(d_para['fichMED']):
+ if not osp.exists(d_para['fichMED']):
UTMESS('F', 'EXECLOGICIEL0_6', valk=d_para['fichMED'])
else:
# copie fichMED vers fichOUT pour pouvoir le récupérer
umail = UL.Libre(action='ASSOCIER',
nom='exec_logiciel.%s2mail' % dMCF['FORMAT'].lower())
+ if not osp.exists(d_para['fichOUT']):
+ UTMESS('F', 'EXECLOGICIEL0_13', valk=dMCF['FORMAT'])
+
# déclaration du concept maillage en sortie
self.DeclareOut('mail', dMCF['MAILLAGE'])
-#@ MODIF macr_ecla_pg_ops Macro DATE 09/11/2004 AUTEUR VABHHTS J.PELLET
+#@ MODIF macr_ecla_pg_ops Macro DATE 03/02/2010 AUTEUR MACOCCO K.MACOCCO
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
########################################################################
def macr_ecla_pg_ops(self,RESULTAT,MAILLAGE,RESU_INIT,MODELE_INIT,
TOUT, GROUP_MA, MAILLE,
SHRINK, TAILLE_MIN,
- NOM_CHAM, TOUT_ORDRE, NUME_ORDRE, LIST_ORDRE, INST, LIST_INST, PRECISION, CRITERE,
+ NOM_CHAM, TOUT_ORDRE, NUME_ORDRE, LIST_ORDRE, INST, LIST_INST, PRECISION, CRITERE,
**args):
"""
Ecriture de la macro macr_ecla_pg
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
-
+
# Appel à CREA_MAILLAGE :
motscles={}
if TOUT : motscles['TOUT'] =TOUT
if GROUP_MA : motscles['GROUP_MA'] =GROUP_MA
if MAILLE : motscles['MAILLE'] =MAILLE
-
+
self.DeclareOut('ma2',MAILLAGE)
ma2=CREA_MAILLAGE(ECLA_PG=_F( MODELE = MODELE_INIT, NOM_CHAM=NOM_CHAM,
SHRINK = SHRINK, TAILLE_MIN=TAILLE_MIN, **motscles ));
-
-
+
+
# Appel à CREA_RESU :
- typ2=AsType(RESU_INIT).__name__
- if TOUT_ORDRE : motscles['TOUT_ORDRE'] =TOUT_ORDRE
- if NUME_ORDRE : motscles['NUME_ORDRE'] =NUME_ORDRE
- if LIST_ORDRE : motscles['LIST_ORDRE'] =LIST_ORDRE
- if LIST_INST : motscles['LIST_INST'] =LIST_INST
- if INST : motscles['INST'] =INST
- if TOUT_ORDRE : motscles['TOUT_ORDRE'] =TOUT_ORDRE
+ typ2=AsType(RESU_INIT).__name__
+ if TOUT_ORDRE : motscles['TOUT_ORDRE'] =TOUT_ORDRE
+ if NUME_ORDRE != None : motscles['NUME_ORDRE'] =NUME_ORDRE
+ if LIST_ORDRE : motscles['LIST_ORDRE'] =LIST_ORDRE
+ if LIST_INST : motscles['LIST_INST'] =LIST_INST
+ if INST != None : motscles['INST'] =INST
self.DeclareOut('resu2',RESULTAT)
resu2=CREA_RESU( OPERATION='ECLA_PG', TYPE_RESU=string.upper(typ2),
ECLA_PG=_F( MODELE_INIT= MODELE_INIT, RESU_INIT=RESU_INIT, NOM_CHAM=NOM_CHAM,
MAILLAGE= ma2, **motscles ));
- return ier
+ return ier
############################################################################################
-#@ MODIF macr_ecre_calc_ops Macro DATE 05/10/2009 AUTEUR ASSIRE A.ASSIRE
+#@ MODIF macr_ecre_calc_ops Macro DATE 05/05/2010 AUTEUR MACOCCO K.MACOCCO
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
LOGICIEL,
VERSION,
ENTETE,
- COURBES,
+ #COURBES,
IMPRESSION,
INFO,
**args):
import os, string, types, shutil
import aster
from Accas import _F
- from Noyau.N_utils import AsType
+ #from Noyau.N_utils import AsType
from Utilitai.Utmess import UTMESS
from Utilitai.System import ExecCommand
ier=0
+
+ # PARAMETRES DEBUG
+ debug = True
+
+
+
# Concept sortant
self.DeclareOut('__TAB',TABLE)
self.DeclareOut('__DEB',DEBIT)
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
- # Parametres
- # Niveaux de debug
- debug1 = (INFO>1)
- debug2 = (INFO>2)
-
+ # Info
+ info2 = (INFO==2)
+ if debug :
+ info2=True
# Parametres Developpeur
tmp_ecrevisse = "tmp_ecrevisse"
- fichier_data = "data.dat"
- defaut = '00'
+ fichier_data = "data.dat"
+ defaut = '00'
# IMPORTATION DE COMMANDES ASTER
EXEC_LOGICIEL = self.get_cmd("EXEC_LOGICIEL")
for i in dCONVERGENCE.keys():
if dCONVERGENCE[i]==None : del dCONVERGENCE[i]
- if debug2:
- print 'dFISSURE = ', dFISSURE
- print 'dECOULEMENT = ', dECOULEMENT
- print 'dTEMPERATURE = ', dTEMPERATURE
- print 'dMODELE_ECRE = ', dMODELE_ECRE
- print 'dCONVERGENCE = ', dCONVERGENCE
- print 'ENTETE = ', ENTETE
- print 'IMPRESSION = ', IMPRESSION
- print 'INFO = ', INFO
+ if debug:
+ print 'dFISSURE = ', dFISSURE
+ print 'dECOULEMENT = ', dECOULEMENT
+ print 'dTEMPERATURE = ', dTEMPERATURE
+ print 'dMODELE_ECRE = ', dMODELE_ECRE
+ print 'dCONVERGENCE = ', dCONVERGENCE
+ print 'ENTETE = ', ENTETE
+ print 'IMPRESSION = ', IMPRESSION
+ print 'INFO = ', INFO
+
-# ---------------------------------------------------------------------
- # CONSTRUCTION DU JEU DE PARAMETRES
+
+# ---------------------------------------------------------------------
+# CONSTRUCTION DU JEU DE PARAMETRES
d = {}
d[ 0 ] = ENTETE,
d[ 89 ] = dCONVERGENCE['ITER_GLOB_MAXI'],
d[ 90 ] = dCONVERGENCE['CRIT_CONV_DEBI'],
- if debug2: print d
+ if debug: print d
+
+
+
# ---------------------------------------------------------------------
+# GENERATION DU FICHIER DATA.DAT
- # GENERATION DU FICHIER DATA.DAT
txt = fichier_data_ecrevisse()
for num_param in d.keys():
# On remplace la variable dans le fichier par sa valeur
txt = txt.replace( '$V['+str(num_param)+']', txt0 )
- if debug1: print txt
+ if debug : print txt
+
+
# ---------------------------------------------------------------------
+# CREATION DE L'ENVIRONNEMENT D'ETUDE POUR ECREVISSE
- # CREATION DE L'ENVIRONNEMENT D'ETUDE POUR ECREVISSE
# Repertoire temporaire d'execution d'Ecrevisse
tmp_ecrevisse = os.path.join(os.getcwd(),tmp_ecrevisse)
- if not os.path.isdir(tmp_ecrevisse):
+ if not os.path.isdir(tmp_ecrevisse) :
try :
os.mkdir(tmp_ecrevisse)
except os.error,erreur :
- print "Code d'erreur de mkdir : " + str(erreur[0]) + " : " + str(erreur[1])
+ if debug :
+ print "Code d'erreur de mkdir : " + str(erreur[0]) + " : " + str(erreur[1])
UTMESS('F','ECREVISSE0_12',valk=[tmp_ecrevisse])
# On recopie eventuellement l'ancien fichier debits
try:
shutil.copyfile(src, dst)
except Exception, e:
- print "ERREUR : copyfile %s -> %s" % (src, dst)
+ UTMESS('F','ECREVISSE0_24',valk=[src, dst])
+ #print "ERREUR : copyfile %s -> %s" % (src, dst)
# Executable Ecrevisse
- if LOGICIEL:
+ if LOGICIEL :
if not os.path.isfile(str(LOGICIEL)):
UTMESS('F','ECREVISSE0_13')
else:
chemin_executable = str(LOGICIEL)
- else:
+ else :
chemin_executable = os.path.join(aster.repout(), 'ecrevisse')
+ #chemin_executable = os.path.join(aster.repout(),version,'ecrevisse')
+ if debug :
+ print 'chemin_executable:',chemin_executable
# Soit on fait un lien symbolique (incompatible avec certaines plate-formes) soit on recopie l'executable
if not os.path.isfile(os.path.join(tmp_ecrevisse, 'ecrevisse')):
# ---------------------------------------------------------------------
-
- # EXECUTION D'ECREVISSE
+# EXECUTION D'ECREVISSE
# Choix du shell
cmd = '#!sh'
# cmd = cmd + '\nexport LD_LIBRARY_PATH=/logiciels/aster/Linux/GF4/public/gcc-4.1.1/lib:$LD_LIBRARY_PATH'
# Creation du contenu du script de lancement ecrevisse.sh
- cmd = cmd + '\ncd ' + tmp_ecrevisse + '\n' + os.path.join(tmp_ecrevisse, 'ecrevisse') + '\nset iret=$?\ncd ..\nexit $iret'
+ cmd = cmd + '\ncd ' + tmp_ecrevisse + '\n' + os.path.join(tmp_ecrevisse, 'ecrevisse') + ' ' + str(VERSION) + '\nset iret=$?\ncd ..\nexit $iret'
fw = open(os.path.join(tmp_ecrevisse, 'ecrevisse.sh'),'w')
fw.write(cmd)
fw.close()
UTMESS('I','ECREVISSE0_17')
- if debug1: os.system('ls -al ' + tmp_ecrevisse)
+ if info2: os.system('ls -al ' + tmp_ecrevisse)
+
-# ---------------------------------------------------------------------
- # RECUPERATION DU RESULTAT DEPUIS ECREVISSE
+# ---------------------------------------------------------------------
+# RECUPERATION DES RESULTATS DEPUIS ECREVISSE
+ # 1) 5 COLONNES (a partir de ECREVISSE 3.1.e)
+ # COTE z (m), FLUX THERMIQUE (W/m2), PRESSION TOTALE ABSOLUE (Pa),
+ # TEMPERATURE FLUIDE (degres C), COEFFICIENT DE CONVECTION (W/m2/K)
try:
- f_ast = open(os.path.join(tmp_ecrevisse, 'pour_aster'),'r')
- _txt = f_ast.read()
- f_ast.close()
- # transforme le texte en liste
- _lst = _txt.split()
- # transforme la liste de textes en liste de float
- _lst = map( float, _lst )
-
- # 5 colonnes (a partir de ECREVISSE 3.1.e)
- # cote z (m), flux thermique (W/m2), pression totale absolue (Pa), temperature fluide (degres C), coefficient de convection (W/m2/K)
- _ecr_c = _lst[1:len(_lst):5]
- _ecr_f = _lst[2:len(_lst):5]
- _ecr_p = _lst[3:len(_lst):5]
- _ecr_t = _lst[4:len(_lst):5]
- _ecr_cc = _lst[5:len(_lst):5]
-
+ f_ast = open(os.path.join(tmp_ecrevisse, 'pour_aster'),'r')
+ _txt = f_ast.read()
+ f_ast.close()
+ # transforme le texte en liste
+ _lst = _txt.split()
+ # transforme la liste de textes en liste de float
+ _lst = map( float, _lst )
+
+ # ATTENTION : les cotes _ecr_c sont celles des resultats ecrevisse,
+ # c'est a dire les points de milieu du maillage aster,
+ # eventuellement multiplies par 1/TORTUOSITE!
+ _ecr_c = _lst[1:len(_lst):5]
+ _ecr_f = _lst[2:len(_lst):5]
+ _ecr_p = _lst[3:len(_lst):5]
+ _ecr_t = _lst[4:len(_lst):5]
+ _ecr_cc = _lst[5:len(_lst):5]
except:
UTMESS('F','ECREVISSE0_18')
- _ecr_c = [-1]
- _ecr_f = [-1]
- _ecr_p = [-1]
- _ecr_t = [-1]
+ _ecr_c = [-1]
+ _ecr_f = [-1]
+ _ecr_p = [-1]
+ _ecr_t = [-1]
_ecr_cc = [-1]
else:
- # Generation de la table resultat
- if debug1: print "Chargement donne par Ecrevisse"
- if debug1: print len(_ecr_c), len(_ecr_f), len(_ecr_p)
- if debug1:
- print '_ecr_c : min=', min(_ecr_c), ' / max=', max(_ecr_c), ' / ', _ecr_c
- print '_ecr_f : min=', min(_ecr_f), ' / max=', max(_ecr_f), ' / ', _ecr_f
- print '_ecr_p : min=', min(_ecr_p), ' / max=', max(_ecr_p), ' / ', _ecr_p
- print '_ecr_t : min=', min(_ecr_t), ' / max=', max(_ecr_t), ' / ', _ecr_t
- print '_ecr_cc : min=', min(_ecr_cc), ' / max=', max(_ecr_cc), ' / ', _ecr_cc
-
-
- # Formule permettant de redefinir les chargements par mailles
+ # On elimine les eventuels points en plus
+ # (cela arrive si la longueur de la fissure est plus grande de la derniere cotes)
+ # mais on considere quand meme la derniere cote du maillage aster
lx_ast = dFISSURE['LISTE_COTES_AH']
+ nbCotesEcre = len(lx_ast)
+ _ecr_c = _ecr_c[0:nbCotesEcre]
+ _ecr_f = _ecr_f[0:nbCotesEcre]
+ _ecr_p = _ecr_p[0:nbCotesEcre]
+ _ecr_t = _ecr_t[0:nbCotesEcre]
+ _ecr_cc = _ecr_cc[0:nbCotesEcre]
- # epsilon pour le decalage
- eps = 1.e-8
-
- lx = []
- ly = []
- ly2 = []
- ly3 = []
- ly4 = []
-
- lx.append( lx_ast[0] )
- ly.append( _ecr_f[0] )
- ly2.append( _ecr_p[0] )
- ly3.append( _ecr_t[0] )
- ly4.append( _ecr_cc[0] )
-
- for i in range(len(lx_ast)-2):
- x = lx_ast[i+1]
- lx.append( x - eps )
- lx.append( x + eps )
- ly.append( _ecr_f[i] )
- ly.append( _ecr_f[i+1] )
- ly2.append( _ecr_p[i] )
- ly2.append( _ecr_p[i+1] )
- ly3.append( _ecr_t[i] )
- ly3.append( _ecr_t[i+1] )
- ly4.append( _ecr_cc[i] )
- ly4.append( _ecr_cc[i+1] )
- #
- lx.append( lx_ast[-1] )
- ly.append( _ecr_f[-1] )
- ly2.append( _ecr_p[-1] )
- ly3.append( _ecr_t[-1] )
- ly4.append( _ecr_cc[-1] )
-
- _ecr_c = lx
- _ecr_f = ly
- _ecr_p = ly2
- _ecr_t = ly3
- _ecr_cc = ly4
-
-
- # Generation de la table resultat
- if debug1: print "Chargement par mailles pour Aster"
- if debug1: print len(_ecr_c), len(_ecr_f), len(_ecr_p)
- if debug1:
- print '_ecr_c : min=', min(_ecr_c), ' / max=', max(_ecr_c), ' / ', _ecr_c
- print '_ecr_f : min=', min(_ecr_f), ' / max=', max(_ecr_f), ' / ', _ecr_f
- print '_ecr_p : min=', min(_ecr_p), ' / max=', max(_ecr_p), ' / ', _ecr_p
- print '_ecr_t : min=', min(_ecr_t), ' / max=', max(_ecr_t), ' / ', _ecr_t
- print '_ecr_cc : min=', min(_ecr_cc), ' / max=', max(_ecr_cc), ' / ', _ecr_cc
-
- # Creation de la SD table (resultat de CALC_ECREVISSE)
- __TAB=CREA_TABLE(LISTE=(_F(LISTE_R=_ecr_c,
- PARA='COTES'),
- _F(LISTE_R=_ecr_f,
- PARA='FLUX'),
- _F(LISTE_R=_ecr_p,
- PARA='PRESSION'),
- _F(LISTE_R=_ecr_t,
- PARA='TEMP'),
- _F(LISTE_R=_ecr_cc,
- PARA='COEF_CONV'),
- ));
-
-
-# if debug: IMPR_TABLE(TABLE=__TAB, FORMAT='TABLEAU',);
-
-# ---------------------------------------------------------------------
- # RECUPERATION DU DEBIT DEPUIS ECREVISSE
+ # 2) DEBIT - 5 COLONNES (a partir de ECREVISSE 3.1.e)
+ # DEBIT TOTAL (kg/s), DEBIT AIR (kg/s), DEBIT VAPEUR (kg/s),
+ # DEBIT LIQUIDE (kg/s), TYPE ECOULEMENT
try:
- f_deb = open(os.path.join(tmp_ecrevisse, 'debits'),'r')
- _tex = f_deb.read()
- f_deb.close()
- # transforme le texte en liste
- _lis = _tex.split()
- # transforme la liste de textes en liste de float
- _lis = map( float, _lis )
-
- # 5 colonnes (a partir de ECREVISSE 3.1.e)
- # debit total (kg/s), debit d'air (kg/s), debit de vapeur (kg/s), debit de liquide (kg/s), type d'ecoulement
- _dtot = _lis[0:len(_lis):5]
- _dair = _lis[1:len(_lis):5]
- _dvap = _lis[2:len(_lis):5]
- _dliq = _lis[3:len(_lis):5]
- _ecou = _lis[4:len(_lis):5]
-
+ f_deb = open(os.path.join(tmp_ecrevisse, 'debits'),'r')
+ _tex = f_deb.read()
+ f_deb.close()
+ _lis = _tex.split()
+ _lis = map( float, _lis )
+
+ _dtot = _lis[0:len(_lis):5]
+ _dair = _lis[1:len(_lis):5]
+ _dvap = _lis[2:len(_lis):5]
+ _dliq = _lis[3:len(_lis):5]
+ _ecou = _lis[4:len(_lis):5]
except:
UTMESS('A','ECREVISSE0_18')
_ecou = [-1]
- # Formule permettant de redefinir les chargements par mailles
- ly_deb = LIST_INST
-
-
- # epsilon pour le decalage
- eps = 1.e-8
-
- ly = []
- ly1 = []
- ly2 = []
- ly3 = []
- ly4 = []
-
- ly.append( _dtot[0] )
- ly1.append( _dair[0] )
- ly2.append( _dvap[0] )
- ly3.append( _dliq[0] )
- ly4.append( _ecou[0] )
-
- for i in range(len(ly_deb)-2):
- ly.append( _dtot[i] )
- ly.append( _dtot[i+1] )
- ly1.append( _dair[i] )
- ly1.append( _dair[i+1] )
- ly2.append( _dvap[i] )
- ly2.append( _dvap[i+1] )
- ly3.append( _dliq[i] )
- ly3.append( _dliq[i+1] )
- ly4.append( _ecou[i] )
- ly4.append( _ecou[i+1] )
- #
- ly.append( _dtot[-1] )
- ly1.append( _dair[-1] )
- ly2.append( _dvap[-1] )
- ly3.append( _dliq[-1] )
- ly4.append( _ecou[-1] )
-
- _dtot = ly
- _dair = ly1
- _dvap = ly2
- _dliq = ly3
- _ecou = ly4
-
- # Creation de la SD table (resultat de CALC_ECREVISSE)
+
+# ---------------------------------------------------------------------
+# CREATION DES SD-TABLE DE RESULTATS
+
+ __TAB=CREA_TABLE(LISTE=(_F(LISTE_R=_ecr_c,
+ PARA='COTES'),
+ _F(LISTE_R=_ecr_f,
+ PARA='FLUX'),
+ _F(LISTE_R=_ecr_p,
+ PARA='PRESSION'),
+ _F(LISTE_R=_ecr_t,
+ PARA='TEMP'),
+ _F(LISTE_R=_ecr_cc,
+ PARA='COEF_CONV'),
+ ))
+
__DEB=CREA_TABLE(LISTE=(_F(LISTE_R=_dtot,
PARA='DEBTOT'),
_F(LISTE_R=_dair,
PARA='DEBLIQ'),
_F(LISTE_I=_ecou,
PARA='ECOULEMENT'),
- ));
+ ))
+
-# if debug: IMPR_TABLE(TABLE=__DEB, FORMAT='TABLEAU',);
# ---------------------------------------------------------------------
+# DEBUG
+ if debug :
+ print 'DEBUT DEBUG MACR_ECRE_CALC'
+ print 'Chargements donnes par Ecrevisse'
+ print 'cotes aster :', lx_ast
+ print '_ecr_c : min=', min(_ecr_c), ' / max=', max(_ecr_c), ' / ', _ecr_c
+ print '_ecr_f : min=', min(_ecr_f), ' / max=', max(_ecr_f), ' / ', _ecr_f
+ print '_ecr_p : min=', min(_ecr_p), ' / max=', max(_ecr_p), ' / ', _ecr_p
+ print '_ecr_t : min=', min(_ecr_t), ' / max=', max(_ecr_t), ' / ', _ecr_t
+ print '_ecr_cc : min=', min(_ecr_cc), ' / max=', max(_ecr_cc), ' / ', _ecr_cc
+ print '_dtot=', _dtot
+ print '_dair=', _dair
+ print '_dvap=', _dvap
+ print '_dliq=', _dliq
+ print '_ecou=', _ecou
+ print __DEB.EXTR_TABLE()
+ print __TAB.EXTR_TABLE()
+ print 'FIN DEBUG MACR_ECRE_CALC'
- # RECUPERATION DES RESULTATS OPTIONNELS DEPUIS ECREVISSE
-# A finir
+# ---------------------------------------------------------------------
+# RECUPERATION DES RESULTATS OPTIONNELS DEPUIS ECREVISSE
+# A finir
# lst_fic = os.listdir(tmp_ecrevisse)
-# ---------------------------------------------------------------------
- # FIN MACR_ECRE_CALC
+# ---------------------------------------------------------------------
+# FIN MACR_ECRE_CALC
return ier
-# ---------------------------------------------------------------------
+
+
+# ---------------------------------------------------------------------
def fichier_data_ecrevisse():
"""
-#@ MODIF macr_ecrevisse_ops Macro DATE 05/10/2009 AUTEUR ASSIRE A.ASSIRE
+#@ MODIF macr_ecrevisse_ops Macro DATE 05/05/2010 AUTEUR MACOCCO K.MACOCCO
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2009 EDF R&D WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
def macr_ecrevisse_ops(self,reuse,
**args):
"""
Procedure de couplage Aster-Ecrevisse
- Execution pour tous les pas de temps des calculs thermiques, mécaniques puis hydraulique
+ Execution pour tous les pas de temps des calculs thermiques, mecaniques puis hydraulique
DecoupageGeneration par Aster du fichier de donnees d'Ecrevisse et lancement d'Ecrevisse
"""
import os, aster, copy
ier=0
- # Niveaux de debug
- debug1 = (INFO>1)
- debug2 = (INFO>2)
-
- #
- InfoAster = 1
#
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
+ # Parametres debug
+ debug = False
+
+ # Info
+ InfoAster = 1
+ info2 = (INFO==2)
+ if debug :
+ info2=True
+
# IMPORTATION DE COMMANDES ASTER
DEFI_LIST_REEL = self.get_cmd("DEFI_LIST_REEL")
THER_LINEAIRE = self.get_cmd("THER_LINEAIRE")
# Concepts sortant: les resultats de STAT_NON_LINE et de THER_LINEAIRE valides vis-a-vis du calcul ecrevisse
self.DeclareOut('RTHERM',TEMPER)
self.DeclareOut('MECANIC', self.sd)
-
+
IsPoursuite = False
IsInit = True
# Traitement de l'etat initial en cas de poursuite
IsPoursuite= True
else :
dEtatInit=None
-
- # Valeur par defaut du mot cle LOGICIEL
- if not LOGICIEL: LOGICIEL = os.path.join(aster.repout(), 'ecrevisse')
+
+ ## Valeur par defaut du mot cle LOGICIEL
+ #if not LOGICIEL: LOGICIEL = os.path.join(aster.repout(), 'ecrevisse')
# RECUPERATION DES MOTS-CLES FACTEURS
motclefsCALC_ECREVISSE = {}
motclefsCALC_ECREVISSE['COURBES'] = COURBES,
+
+
+
+
# -----------------------------------------------------------------------------------------------------
# Debut de la macro
# Si LIST_INST est un DEFI_LIST_REEL :
_liste_inst = LIST_INST.Valeurs()
- if ( debug1 ):
+ if (debug):
print 'liste des instants liste_inst = ', _liste_inst
# Drapeaux pour les 1ers calculs et les 1eres definitions
_nume_ordre = 0
else :
# Dans le cas d'une poursuite :
- # n reconstruit une nouvelle liste d'instant composee de l'ancienne liste jusqu'a l'instant recherche,
+ # n reconstruit une nouvelle liste d'instant composee de l'ancienne liste jusqu'a l'instant recherche,
# puis de la nouvelle a partir de cet instant
# ainsi le _nume_ordre de la nouvelle liste correspond au nume_ordre de l'ancienne
__dico1 = __THINIT.LIST_VARI_ACCES()
break
idx += 1
new_list = _list_precedente[0:_nume_ordre] # liste precedent jusqu'a l'instant a recalculer (inclu, ca permet de gerer le cas ou l'instant a recalculer n'est pas dans la nouvelle liste : il sera ajoute)
- new_list.extend( _liste_inst[_idx+1:] ) # on lui ajoute la nouvelle liste a partir du l'instant a recalculer
+ new_list.extend( _liste_inst[_idx+1:] ) # on lui ajoute la nouvelle liste a partir du l'instant a recalculer
_liste_inst = copy.copy(new_list)
-
- ########################################################################################
+
+ ########################################################################################
# Debut boucle sur la liste d'instant
########################################################################################
FinBoucle = False
while ( not FinBoucle ):
_inst = _liste_inst[_nume_ordre]
- if (debug1):
- print 'instant debut boucle', _inst
-
+ if ( debug ):
+ print 'Instant debut boucle', _inst
# On boucle jusqu'a convergence
NbIter = 0
while True:
- if ( (not IsPoursuite) or EcrevisseExe) :
+ if ( (not IsPoursuite) or EcrevisseExe) :
# Le temps que l'on traite
_inst_p_un = _liste_inst[_nume_ordre+1]
IsInitEcre= False
# Construction de la liste des pas
LES_PAS = DEFI_LIST_REEL( VALE=_liste_inst, )
- if ( debug1 ):
+ if (debug):
print '=====> ===== ===== ===== <===='
print 'Iteration numero : ', NbIter
print 'Instant : ', _inst
if ( EcrevisseExe ):
_dEXCIT_THER.append( _F(CHARGE=FLU1ECR0) )
_dEXCIT_THER.append( _F(CHARGE=FLU2ECR0) )
-
- # Definition de l'etat initial
+
+ # Definition de l'etat initial
motclefs = {}
if (_nume_ordre == 0) :
- # On verifie que temp_ref est bien renseigne dans AFFE_MATERIAU
+ # On verifie que temp_ref est bien renseigne dans AFFE_MATERIAU
try:
tref = CHAM_MATER['AFFE_VARC']['VALE_REF']
except:
UTMESS('F','ECREVISSE0_22',)
-
+
motclefs['ETAT_INIT']=[_F(VALE=tref, NUME_ORDRE=_nume_ordre)]
- if ( debug2 ):
+ if ( debug ):
print 'thermique initialise avec tref'
else:
if (IsInit) :
- motclefs['reuse']=__THINIT
+ motclefs['reuse']=__THINIT
motclefs['ETAT_INIT']=[_F(EVOL_THER=__THINIT, NUME_ORDRE=_nume_ordre)]
- if (debug2):
+ if (debug):
print 'thermique initialise avec etat_initial'
else :
motclefs['reuse']=RTHERM
motclefs['ETAT_INIT']=[_F(EVOL_THER=RTHERM, NUME_ORDRE=_nume_ordre)]
- if (debug2):
+ if (debug):
print 'thermique initialise avec instant precedent'
- if ( debug1 ):
+
+ if (debug):
print '====> THER_LINEAIRE <===='
- if ( debug2 ):
print ' Les charges thermiques'
print EXCIT_THER
#
ARCHIVAGE = _F(NUME_INIT=_nume_ordre+1,DETR_NUME_SUIV='OUI'),
INFO = InfoAster,
**motclefs )
-
+
RTHERMPJ=PROJ_CHAMP(RESULTAT=__THINIT, MODELE_1=MODELE_THER, MODELE_2=MODELE_MECA,
VIS_A_VIS=_F(TOUT_1='OUI', TOUT_2='OUI',),
INFO=2,
)
RTHERM=__THINIT
- else :
+ else :
RTHERM=THER_LINEAIRE(
MODELE = MODELE_THER,
CHAM_MATER = CHAM_MATER,
**motclefs
)
- # Projection du champ thermique, à tous les instants sinon pas de deformations thermiques
+ # Projection du champ thermique, a tous les instants sinon pas de deformations thermiques
RTHERMPJ=PROJ_CHAMP(RESULTAT=RTHERM, MODELE_1=MODELE_THER, MODELE_2=MODELE_MECA,
VIS_A_VIS=_F(TOUT_1='OUI', TOUT_2='OUI',),
INFO=2,
for j in dEXCIT_MECA_i.keys():
if dEXCIT_MECA_i[j]==None : del dEXCIT_MECA_i[j]
_dEXCIT_MECA.append(dEXCIT_MECA_i)
-
-
+
+
# Definition des chargements venant d'Ecrevisse
if ( EcrevisseExe ):
_dEXCIT_MECA.append( _F(CHARGE=MECAECR0) )
if (_nume_ordre != 0):
motclefs['reuse'] = MECANIC
motclefs['ETAT_INIT']=[_F(EVOL_NOLI=MECANIC, NUME_ORDRE=_nume_ordre)]
- if (debug2):
+ if (debug):
print 'etat meca initial = pas precedent'
else:
- if (debug2):
- print 'etat meca initial : vierge'
- else:
+ if (debug):
+ print 'etat meca initial : vierge'
+ else:
motclefs['reuse']=__EVINIT
motclefs['ETAT_INIT']=[_F(EVOL_NOLI=__EVINIT, NUME_ORDRE=_nume_ordre)]
- if (debug2):
+ if (debug):
print 'etat meca initial dReuseM', motclefs
-
-
- if ( debug1 ):
+
+ if (debug):
print '====> STAT_NON_LINE <===='
- if ( debug2 ):
+ if (debug):
print ' Les charges mecaniques'
print _dEXCIT_MECA
-
-
+
+
MECANIC=STAT_NON_LINE(
MODELE = MODELE_MECA,
CHAM_MATER = __MATMEC,
# Thermique projete
# Liste des pas
DETRUIRE( CONCEPT=(_F(NOM=RTHERMPJ),_F(NOM=LES_PAS),),INFO=1,ALARME='NON',)
-
+
else :
- # CAS OU LA MACRO EST REENTRANTE : ON RELANCE ECREVISSE POUR CONNAITRE
+ # CAS OU LA MACRO EST REENTRANTE : ON RELANCE ECREVISSE POUR CONNAITRE
# LES CHARGEMENT A UTILISER POUR LES PROBLEMES THERMIQUES ET MECANIQUES
_inst_p_un=_inst
IsInitEcre = True
-
+
# -----------------------------------------------------------------------
# ECREVISSE : ATTENTION SI REPRISE CALCUL, ON RECALCULE LE DERNIER INSTANT
# -------------------------------------------------------------------------
TABLECR1=CO('TABLECR1')
DEBIECR1=CO('DEBIECR1')
- if ( debug1 ):
+ if (debug):
print '====> ECREVISSE entree dans CALC_ECREVISSE <===='
-
- if (not IsPoursuite) :
-
+
+ if (not IsPoursuite) :
+
CALC_ECREVISSE(
CHARGE_MECA = MECAECR1,
CHARGE_THER1 = FLU1ECR1,
# assurer la coherence des donnees en fonction de FLUIDE_ENTREE = iflow (voir doc Ecrevisse)
# activation eventuelle de TITR_VA et P_AIR
- FISSURE=l_dFISSURE, # TODO a verifier
+ FISSURE=l_dFISSURE,
ECOULEMENT=_F( **dECOULEMENT_ecrevisse ),
MODELE_ECRE=_F( **dMODELE_ECRE),
# assurer la coherence des donnees en fonction de FLUIDE_ENTREE = iflow (voir doc Ecrevisse)
# activation eventuelle de TITR_VA et P_AIR
- FISSURE=l_dFISSURE, # TODO a verifier
+ FISSURE=l_dFISSURE,
ECOULEMENT=_F( **dECOULEMENT_ecrevisse ),
MODELE_ECRE=_F( **dMODELE_ECRE),
CONVERGENCE=_F( **dCONVERGENCE_ECREVISSE ),
**motclefsCALC_ECREVISSE
);
-
- if ( debug1 ):
+
+ if (debug):
print '====> ECREVISSE sortie de CALC_ECREVISSE <===='
# Recuperation des infos de la table resultat Ecrevisse
T_TABL_TMP1 = TABLECR1.EXTR_TABLE()
T_DEB_TMP1 = DEBIECR1.EXTR_TABLE()
-# # Ajout de deux colonnes supplementaires
+# # On ajoute deux colonnes supplementaires
# _nb_ligne = len(T_DEB_TMP1["DEBTOT"])
# T_DEB_TMP1["NUME_ORDRE"] = [_nume_ordre+1]*_nb_ligne
# T_DEB_TMP1["INST"] = [_inst_p_un]*_nb_ligne
-
+
# Le calcul Ecrevisse c'est bien passe ?
EcrevisseExe = ( T_TABL_TMP1.values()['COTES'][0] != -1 )
#
# TABLECR0 table Ecrevisse a _inst
# TABLECR1 table Ecrevisse a _inst_p_un
# --------------------
-
+
if ( not IsInit ):
# On recupere la liste des temperatures a t et t+1
lst_T_0 = T_TABL_TMP0.values()['TEMP']
Erreur = ErreurP
else:
Erreur = ErreurG
- #
- print 'CONVERGENCE_MACR_ECREVISSE. Instant de calcul : %.3f .' % (_inst_p_un)
- print ' Erreur en Temperature : %f . Ecart en Temperature : %.3f' % (ErreurT,max_T_diff_01)
- print ' Erreur en Pression : %f . Ecart en Pression : %.3f' % (ErreurP,max_P_diff_01)
- print ' Erreur Temp-Press : %f' % (ErreurG)
+
if ( MacrCritere != 'EXPLICITE' ):
Convergence = ( Erreur <= MacrPrecisCritere )
- print 'CONVERGENCE_MACR_ECREVISSE . Nature du Critere %s . Valeur du critere %s . Convergence %s ' % (MacrCritere,MacrPrecisCritere,Convergence,)
+ #
+ if info2 :
+ # Info Critere
+ UTMESS('I', 'ECREVISSE0_35', valr=[_inst_p_un], valk=[MacrCritere,MacrPrecisCritere,Convergence])
+ # Info Convergence
+ UTMESS('I', 'ECREVISSE0_34', valr=[_inst_p_un,ErreurT,max_T_diff_01,ErreurP,max_P_diff_01,ErreurG])
else:
Convergence = True
- print 'CONVERGENCE_MACR_ECREVISSE. 1er Instant de calcul : %f . Pas de calcul de critere.' % (_inst_p_un)
+ if info2 :
+ UTMESS('I', 'ECREVISSE0_36', valr=[_inst_p_un])
# --------------------
-
#
+
if ( MacrCritere == 'EXPLICITE' ):
Convergence = True
else:
T_TABL_TMP1["NUME_ORDRE"] = [_nume_ordre+1]*nb_lignes_t1
T_TABL_TMP1["INST"] = [_inst_p_un]*nb_lignes_t1
- # POUR LA TABLE DES DEBITS
+ # POUR LA TABLE DES DEBITS
nb_ligne_t2 = len(T_DEB_TMP1["DEBTOT"])
T_DEB_TMP1["NUME_ORDRE"] = [_nume_ordre+1]*nb_ligne_t2
T_DEB_TMP1["INST"] = [_inst_p_un]*nb_ligne_t2
T_TABL_TMP0 = T_TABL_TMP1
if (not IsInitEcre) :
IsInit = False
- if ( debug1 ):
- print 'Convergence atteinte, on passe au pas de temps suivant'
+ if (info2):
+ UTMESS('I','ECREVISSE0_37', valr=[_inst_p_un])
break
-
+
else:
NbIter += 1
# A t'on le droit de decouper, par rapport au nombre de division
UTMESS('A','ECREVISSE0_31', valr=[_inst,_inst_p_un,tmp,MacrPasMini])
break
#
- if ( debug1 ):
+ if ( info2 ):
UTMESS('A','ECREVISSE0_32', valr=[_inst,_inst_p_un,tmp],vali=[NbIter])
# on insere le nouveau temps dans la liste des instants avant "_inst_p_un"
_liste_inst.insert(_nume_ordre+1,tmp)
),
INFO=1,ALARME='NON',
)
-
+
if (_nume_ordre != 0 ):
DETRUIRE(
CONCEPT=( _F(NOM=MECAECR0),
-#@ MODIF macr_lign_coupe_ops Macro DATE 18/11/2009 AUTEUR MACOCCO K.MACOCCO
+#@ MODIF macr_lign_coupe_ops Macro DATE 08/04/2010 AUTEUR MACOCCO K.MACOCCO
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
########################################################################
# script PYTHON de creation du résultat local
+########################################################################
+
+########################################################################
+# verification que les points de la ligne de coupe sont dans la matiere
+def crea_grp_matiere(self,groupe,newgrp,iocc,m,__remodr,NOM_CHAM,LIGN_COUPE,__macou):
+
+ import aster
+ import os,string,types
+ from Accas import _F
+ from Noyau.N_utils import AsType
+ from Utilitai.Utmess import UTMESS
+ import os
+ POST_RELEVE_T = self.get_cmd('POST_RELEVE_T')
+ DEFI_GROUP = self.get_cmd('DEFI_GROUP')
+
+ motscles={}
+ if m['NOM_CMP']!=None:
+ motscles['NOM_CMP']=m['NOM_CMP']
+ else:
+ motscles['TOUT_CMP']='OUI'
+ motscles['OPERATION']='EXTRACTION'
+
+ __tab=POST_RELEVE_T(ACTION=_F( INTITULE=newgrp,
+ RESULTAT = __remodr,
+ NOM_CHAM=NOM_CHAM,
+ GROUP_NO = groupe,**motscles ))
+
+ # dictb=table initiale (contenant éventuellement des noeuds hors matière)
+ dictb=__tab.EXTR_TABLE()
+ # listenoe_b=liste ordonnee des noeuds de la ligne de coupe (avec doublons)
+ listenoe_b = dictb.NOEUD.values()
+ # lno_b2=liste des noeuds de la ligne de coupe après élimination des doublons
+ # (attention, on perd l'ordre des noeuds)
+ lno_b2 = set(listenoe_b)
+
+ # dictc=table (extraite de dictb) contenant uniquement des noeuds dans la matière
+ if m['NOM_CMP']!=None:
+ dictc=getattr(dictb,m['NOM_CMP'][0]).NON_VIDE()
+ lno_c2 = set(dictc.NOEUD.values())
+ else:# TOUT_CMP='OUI'
+ # on garde uniquement les composantes pour conserver les noeuds où il y a des valeurs
+ a_suppr = set(['INTITULE', 'RESU', 'NOM_CHAM', 'NUME_ORDRE', 'INST', 'ABSC_CURV', 'COOR_X', 'COOR_Y', 'COOR_Z'])
+ new_para = set(dictb.para)
+ new_para.difference_update(a_suppr)
+
+ lno_c2 = set()
+ for comp in new_para.difference(['NOEUD']):
+ dictc = getattr(dictb, comp).NON_VIDE()
+ lno_c2.update(dictc.NOEUD.values())
+
+ # on réordonne la liste des noeuds de lno_c2 (selon leur position dans listenoe_b) => l_matiere
+ # l_horsmat=liste des noeuds hors matière
+ l_matiere = [j for j in listenoe_b if j in lno_c2]
+ nderm=l_matiere.index(l_matiere[len(l_matiere)-1])
+ l_horsmat = [j for j in listenoe_b if j not in lno_c2]
+
+ # si on est en présence de noeuds hors matière,
+ # on emet une alarme pour informer l'utilisateur
+ nbpoin=m['NB_POINTS']
+ reste=nbpoin-len(l_matiere)
+ if len(l_horsmat) > 0:
+
+ nderh=l_horsmat.index(l_horsmat[len(l_horsmat)-1])
+ cnom = list(__macou.NOMNOE.get())
+ l_coor = __macou.COORDO.VALE.get()
+ indent=os.linesep+' '*12
+ l_surlig = []
+ l_horslig = []
+ for j in l_matiere[:nderm+1]:
+ nuno=cnom.index(j.ljust(8))
+ text_coordo = '(%f, %f, %f)' % tuple(l_coor[3*nuno:3*nuno+3])
+ l_surlig.append(text_coordo)
+ for j in l_horsmat[:nderh+1]:
+ nuno=cnom.index(j.ljust(8))
+ text_coordo = '(%f, %f, %f)' % tuple(l_coor[3*nuno:3*nuno+3])
+ l_horslig.append(text_coordo)
+ UTMESS('A','POST0_8',valk=[indent.join(l_surlig),indent.join(l_horslig)])
+
+ elif reste > 0:
+
+ cnom = list(__macou.NOMNOE.get())
+ l_coor = __macou.COORDO.VALE.get()
+ indent=os.linesep+' '*12
+ l_surlig = []
+ for j in l_matiere[:nderm+1]:
+ nuno=cnom.index(j.ljust(8))
+ text_coordo = '(%f, %f, %f)' % tuple(l_coor[3*nuno:3*nuno+3])
+ l_surlig.append(text_coordo)
+ UTMESS('A','POST0_24',vali=[iocc,reste],valk=[indent.join(l_surlig)])
+
+ __macou=DEFI_GROUP( reuse =__macou , MAILLAGE=__macou ,
+ CREA_GROUP_NO=_F(NOM=newgrp,NOEUD=l_matiere[:nderm+1]),)
+
+ return
def crea_resu_local(self,dime,NOM_CHAM,m,resin,mail,nomgrma):
return dist
########################################################################
-# verification que les points de la ligne de coupe sont dans la matiere
-def crea_grp_matiere(self,groupe,newgrp,m,__remodr,NOM_CHAM,__macou):
-
- import aster
- from Accas import _F
- from Utilitai.Utmess import UTMESS
- import os
- from sets import Set
- POST_RELEVE_T = self.get_cmd('POST_RELEVE_T')
- DEFI_GROUP = self.get_cmd('DEFI_GROUP')
-
- motscles={}
- if m['NOM_CMP']!=None:
- motscles['NOM_CMP']=m['NOM_CMP']
- else:
- motscles['TOUT_CMP']='OUI'
- motscles['OPERATION']='EXTRACTION'
-
- __tab=POST_RELEVE_T(ACTION=_F( INTITULE=newgrp,
- RESULTAT = __remodr,
- NOM_CHAM=NOM_CHAM,
- GROUP_NO = groupe,**motscles ))
-
- # dictb=table initiale (contenant éventuellement des noeuds hors matière)
- dictb=__tab.EXTR_TABLE()
- # listenoe_b=liste ordonnee des noeuds de la ligne de coupe (avec doublons)
- listenoe_b = dictb.NOEUD.values()
- # lno_b2=liste des noeuds de la ligne de coupe après élimination des doublons
- # (attention, on perd l'ordre des noeuds)
- lno_b2 = Set(listenoe_b)
-
- # dictc=table (extraite de dictb) contenant uniquement des noeuds dans la matière
- if m['NOM_CMP']!=None:
- dictc=getattr(dictb,m['NOM_CMP'][0]).NON_VIDE()
- lno_c2 = Set(dictc.NOEUD.values())
- else:# TOUT_CMP='OUI'
- # on garde uniquement les composantes pour conserver les noeuds où il y a des valeurs
- a_suppr = Set(['INTITULE', 'RESU', 'NOM_CHAM', 'NUME_ORDRE', 'INST', 'ABSC_CURV', 'COOR_X', 'COOR_Y', 'COOR_Z'])
- new_para = Set(dictb.para)
- new_para.difference_update(a_suppr)
-
- lno_c2 = Set()
- for comp in new_para.difference(['NOEUD']):
- dictc = getattr(dictb, comp).NON_VIDE()
- lno_c2.update(dictc.NOEUD.values())
-
- # on réordonne la liste des noeuds de lno_c2 (selon leur position dans listenoe_b) => l_matiere
- # l_horsmat=liste des noeuds hors matière
- l_matiere = [j for j in listenoe_b if j in lno_c2]
- nderm=l_matiere.index(l_matiere[len(l_matiere)-1])
- l_horsmat = [j for j in listenoe_b if j not in lno_c2]
-
- # si on est en présence de noeuds hors matière,
- # on emet une alarme pour informer l'utilisateur
- if len(l_horsmat) > 0:
-
- nderh=l_horsmat.index(l_horsmat[len(l_horsmat)-1])
- cnom = list(__macou.NOMNOE.get())
- l_coor = __macou.COORDO.VALE.get()
- indent=os.linesep+' '*12
- l_surlig = []
- l_horslig = []
- for j in l_matiere[:nderm+1]:
- nuno=cnom.index(j.ljust(8))
- text_coordo = '(%f, %f, %f)' % tuple(l_coor[3*nuno:3*nuno+3])
- l_surlig.append(text_coordo)
- for j in l_horsmat[:nderh+1]:
- nuno=cnom.index(j.ljust(8))
- text_coordo = '(%f, %f, %f)' % tuple(l_coor[3*nuno:3*nuno+3])
- l_horslig.append(text_coordo)
- UTMESS('A','POST0_8',valk=[indent.join(l_surlig),indent.join(l_horslig)])
-
- __macou=DEFI_GROUP( reuse =__macou , MAILLAGE=__macou ,
- CREA_GROUP_NO=_F(NOM=newgrp,NOEUD=l_matiere[:nderm+1]),)
-
- return
-########################################################################
# script PYTHON de creation d un maillage de ligne de coupe
def crea_mail_lig_coup(dimension,lignes,groups,arcs):
# détermination du type de résultat à créer
if nomgd[:6] == 'TEMP_R' : TYPE_RESU='EVOL_THER'
elif nomgd[:6] == 'DEPL_R' : TYPE_RESU='EVOL_ELAS'
+ elif nomgd[:6] == 'VAR2_R' : TYPE_RESU='EVOL_NOLI'
+ elif nomgd[:6] == 'VARI_R' : TYPE_RESU='EVOL_NOLI'
elif nomgd[:6] == 'SIEF_R' :
if NOM_CHAM[:4]=='SIGM':TYPE_RESU='EVOL_ELAS'
elif NOM_CHAM[:4]=='SIEF':TYPE_RESU='EVOL_NOLI'
if AsType(RESULTAT).__name__ in ('evol_elas','evol_noli') :
if NOM_CHAM in ('DEPL','SIEF_ELNO_ELGA','SIGM_NOEU_DEPL','SIGM_NOEU_SIEF','SIGM_NOEU_ELGA','SIGM_NOEU_COQU','SIGM_ELNO_DEPL'):icham=1
-
+ iocc=0
for m in LIGN_COUPE :
+ iocc=iocc+1
motscles={}
motscles['OPERATION']=m['OPERATION']
if m['NOM_CMP']!=None:
groupe='LICOU'+str(ioc2)
nomgrma=' '
newgrp='LICOF'+str(ioc2)
- crea_grp_matiere(self,groupe,newgrp,m,__remodr,NOM_CHAM,__macou)
+ crea_grp_matiere(self,groupe,newgrp,iocc,m,__remodr,NOM_CHAM,LIGN_COUPE,__macou)
groupe=newgrp
# on definit l'intitulé
elif AsType(RESULTAT).__name__ in ('evol_ther',) :
-
+ iocc=0
for m in LIGN_COUPE :
+ iocc=iocc+1
motscles={}
motscles['OPERATION']=m['OPERATION']
if m['NOM_CMP']!=None:
ioc2=ioc2+1
groupe='LICOU'+str(ioc2)
newgrp='LICOF'+str(ioc2)
- crea_grp_matiere(self,groupe,newgrp,m,__remodr,NOM_CHAM,__macou)
+ crea_grp_matiere(self,groupe,newgrp,iocc,m,__remodr,NOM_CHAM,LIGN_COUPE,__macou)
groupe=newgrp
if m['INTITULE'] !=None : intitl=m['INTITULE']
else : intitl='l.coupe'+str(ioc2)
-#@ MODIF macro_elas_mult_ops Macro DATE 22/10/2007 AUTEUR PELLET J.PELLET
+#@ MODIF macro_elas_mult_ops Macro DATE 03/02/2010 AUTEUR MACOCCO K.MACOCCO
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
-# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
-# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
-# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
-# (AT YOUR OPTION) ANY LATER VERSION.
-#
-# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
-# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
-# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
-# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
-#
-# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
-# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
-# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
def macro_elas_mult_ops(self,MODELE,CHAM_MATER,CARA_ELEM,NUME_DDL,
- CHAR_MECA_GLOBAL,CHAR_CINE_GLOBAL,LIAISON_DISCRET,
+ CHAR_MECA_GLOBAL,LIAISON_DISCRET,
CAS_CHARGE,SOLVEUR,**args):
"""
Ecriture de la macro MACRO_ELAS_MULT
# Le concept sortant (de type mult_elas ou fourier_elas) est nommé
# 'nomres' dans le contexte de la macro
-
+
self.DeclareOut('nomres',self.sd)
ielas = 0
if ielas==1 :
motscles={}
if CHAR_MECA_GLOBAL: motscles['CHARGE'] =CHAR_MECA_GLOBAL
- elif CHAR_CINE_GLOBAL: motscles['CHARGE'] =CHAR_CINE_GLOBAL
if CHAM_MATER : motscles['CHAM_MATER']=CHAM_MATER
if CARA_ELEM : motscles['CARA_ELEM'] =CARA_ELEM
__nomrig=CALC_MATR_ELEM(OPTION='RIGI_MECA',MODELE=MODELE,**motscles)
-
+
if lnume:
# On peut passer des mots cles egaux a None. Ils sont ignores
motscles={}
# boucle sur les items de CAS_CHARGE
nomchn=[]
+ lcharg=[]
iocc=0
for m in CAS_CHARGE:
iocc=iocc+1
+ # calcul de lcharg : liste des listes de char_meca (mots clé CHAR_MECA et CHAR_MECA_GLOBAL)
+ xx1=m['CHAR_MECA']
+ if type(xx1) != type((1,)) : xx1=(xx1,)
+ xx2=CHAR_MECA_GLOBAL
+ if type(xx2) != type((1,)) : xx2=(xx2,)
+ lchar1=[]
+ for chargt in (xx1+xx2) :
+ if chargt : lchar1.append(chargt)
+ lcharg.append(lchar1)
+
if ifour:
motscles={}
if CHAR_MECA_GLOBAL: motscles['CHARGE'] =CHAR_MECA_GLOBAL
- elif CHAR_CINE_GLOBAL: motscles['CHARGE'] =CHAR_CINE_GLOBAL
if CHAM_MATER : motscles['CHAM_MATER'] =CHAM_MATER
if CARA_ELEM : motscles['CARA_ELEM'] =CARA_ELEM
motscles['MODE_FOURIER'] =m['MODE_FOURIER']
if CHAM_MATER : motscles['CHAM_MATER'] =CHAM_MATER
if CARA_ELEM : motscles['CARA_ELEM'] =CARA_ELEM
if ifour : motscles['MODE_FOURIER'] =m['MODE_FOURIER']
- if m['CHAR_MECA'] : motscles['CHARGE'] =m['CHAR_MECA']
- elif m['CHAR_CINE'] : motscles['CHARGE'] =m['CHAR_CINE']
+ if len(lchar1) > 0 : motscles['CHARGE'] =lchar1
__nomvel=CALC_VECT_ELEM(OPTION='CHAR_MECA',**motscles)
__nomasv=ASSE_VECTEUR(VECT_ELEM=__nomvel,NUME_DDL=num)
else :
if CHAM_MATER : motscle2['CHAM_MATER']=CHAM_MATER
if CARA_ELEM : motscle2['CARA_ELEM']=CARA_ELEM
if CHAM_MATER or CARA_ELEM :
- if ielas :
+ if ielas :
motscles['AFFE']=[]
for m in CAS_CHARGE:
motscles['AFFE'].append(_F(MODELE=MODELE,
**motscle2) )
iocc=iocc+1
else:
- if ielas :
+ if ielas :
motscles['AFFE']=[]
for m in CAS_CHARGE:
motscles['AFFE'].append(_F(MODELE=MODELE,
iocc=0
for m in CAS_CHARGE:
+ lchar1=lcharg[iocc]
iocc=iocc+1
if m['OPTION']:
else:
motscles['NUME_MODE']=m['MODE_FOURIER']
motscles['EXCIT']=[]
- if m['CHAR_MECA'] :
- for chargt in m['CHAR_MECA'] : motscles['EXCIT'].append(_F(CHARGE=chargt))
- elif m['CHAR_CINE'] :
- for chargt in m['CHAR_CINE'] : motscles['EXCIT'].append(_F(CHARGE=chargt))
- if CHAR_MECA_GLOBAL:
- for chargt in CHAR_MECA_GLOBAL : motscles['EXCIT'].append(_F(CHARGE=chargt))
- elif CHAR_CINE_GLOBAL:
- for chargt in CHAR_CINE_GLOBAL : motscles['EXCIT'].append(_F(CHARGE=chargt))
+ for chargt in lchar1 : motscles['EXCIT'].append(_F(CHARGE=chargt))
CALC_ELEM(reuse=nomres,
RESULTAT=nomres,
- MODELE=MODELE,
REPE_COQUE=_F(NIVE_COUCHE=m['NIVE_COUCHE'],
NUME_COUCHE=m['NUME_COUCHE'],),
OPTION=tuple(liste_el),
else:
motscles['NUME_MODE']=m['MODE_FOURIER']
motscles['EXCIT']=[]
- if m['CHAR_MECA'] :
- for chargt in m['CHAR_MECA'] : motscles['EXCIT'].append(_F(CHARGE=chargt))
- elif m['CHAR_CINE'] :
- for chargt in m['CHAR_CINE'] : motscles['EXCIT'].append(_F(CHARGE=chargt))
- if CHAR_MECA_GLOBAL:
- for chargt in CHAR_MECA_GLOBAL : motscles['EXCIT'].append(_F(CHARGE=chargt))
- elif CHAR_CINE_GLOBAL:
- for chargt in CHAR_CINE_GLOBAL : motscles['EXCIT'].append(_F(CHARGE=chargt))
+ for chargt in lchar1 : motscles['EXCIT'].append(_F(CHARGE=chargt))
CALC_NO(reuse=nomres,
RESULTAT=nomres,
- MODELE=MODELE,
OPTION=tuple(liste_no),
**motscles)
-#@ MODIF macro_matr_asse_ops Macro DATE 17/11/2008 AUTEUR DELMAS J.DELMAS
+#@ MODIF macro_matr_asse_ops Macro DATE 05/05/2010 AUTEUR MACOCCO K.MACOCCO
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
if CHARGE != None:
if option[0:9] not in ('MASS_THER','RIGI_GEOM'):
motscles['CHARGE'] =CHARGE
- if CHAM_MATER != None: motscles['CHAM_MATER'] =CHAM_MATER
+ if CHAM_MATER != None and option != 'RIGI_GEOM' : motscles['CHAM_MATER'] =CHAM_MATER
if CARA_ELEM != None: motscles['CARA_ELEM'] =CARA_ELEM
if INST != None: motscles['INST'] =INST
self.DeclareOut('mm',m['MATRICE'])
motscles={'OPTION':option}
- if CHAR_CINE != None:
+ if CHAR_CINE != None:
mm=ASSE_MATRICE(MATR_ELEM=_a,NUME_DDL=num,CHAR_CINE=CHAR_CINE)
else:
mm=ASSE_MATRICE(MATR_ELEM=_a,NUME_DDL=num)
-#@ MODIF post_k1_k2_k3_ops Macro DATE 22/12/2008 AUTEUR COURTOIS M.COURTOIS
+#@ MODIF post_k1_k2_k3_ops Macro DATE 08/04/2010 AUTEUR MACOCCO K.MACOCCO
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# en sortie : xyza = Coordonnees du point et abscisse
n = len(Coorfo) / 4
if ( s0 < Coorfo[3] ) :
- xyz = [Coorfo[0],Coorfo[1],Coorfo[2]]
+ xyz = [Coorfo[0],Coorfo[1],Coorfo[2],s0]
return xyz
if ( s0 > Coorfo[-1] ) :
- xyz = [Coorfo[-4],Coorfo[-3],Coorfo[-2]]
+ xyz = [Coorfo[-4],Coorfo[-3],Coorfo[-2],s0]
return xyz
i = 1
while s0 > Coorfo[4*i+3]:
tabsup=TlibS[ino].EXTR_TABLE()
DETRUIRE(CONCEPT=_F(NOM=TlibS[ino]),INFO=1)
elif RESULTAT :
- __TSUP=POST_RELEVE_T(ACTION=_F(INTITULE='Deplacement SUP',
- NOEUD=Lnosup[ino],
- RESULTAT=RESULTAT,
- NOM_CHAM='DEPL',
- TOUT_ORDRE='OUI',
- NOM_CMP=('DX','DY','DZ',),
- OPERATION='EXTRACTION',),);
+ if MODELISATION=='AXIS' or MODELISATION=='C_PLAN' or MODELISATION=='D_PLAN':
+ __TSUP=POST_RELEVE_T(ACTION=_F(INTITULE='Deplacement SUP',
+ NOEUD=Lnosup[ino],
+ RESULTAT=RESULTAT,
+ NOM_CHAM='DEPL',
+ TOUT_ORDRE='OUI',
+ NOM_CMP=('DX','DY',),
+ OPERATION='EXTRACTION',),);
+ else :
+ __TSUP=POST_RELEVE_T(ACTION=_F(INTITULE='Deplacement SUP',
+ NOEUD=Lnosup[ino],
+ RESULTAT=RESULTAT,
+ NOM_CHAM='DEPL',
+ TOUT_ORDRE='OUI',
+ NOM_CMP=('DX','DY','DZ',),
+ OPERATION='EXTRACTION',),);
tabsup=__TSUP.EXTR_TABLE()
DETRUIRE(CONCEPT=_F(NOM=__TSUP),INFO=1)
else :
tabinf=TlibI[ino].EXTR_TABLE()
DETRUIRE(CONCEPT=_F(NOM=TlibI[ino]),INFO=1)
elif RESULTAT :
- __TINF=POST_RELEVE_T(ACTION=_F(INTITULE='Deplacement INF',
- NOEUD=Lnoinf[ino],
- RESULTAT=RESULTAT,
- NOM_CHAM='DEPL',
- TOUT_ORDRE='OUI',
- NOM_CMP=('DX','DY','DZ',),
- OPERATION='EXTRACTION',),);
+ if MODELISATION=='AXIS' or MODELISATION=='C_PLAN' or MODELISATION=='D_PLAN':
+ __TINF=POST_RELEVE_T(ACTION=_F(INTITULE='Deplacement INF',
+ NOEUD=Lnoinf[ino],
+ RESULTAT=RESULTAT,
+ NOM_CHAM='DEPL',
+ TOUT_ORDRE='OUI',
+ NOM_CMP=('DX','DY'),
+ OPERATION='EXTRACTION',),);
+ else :
+ __TINF=POST_RELEVE_T(ACTION=_F(INTITULE='Deplacement INF',
+ NOEUD=Lnoinf[ino],
+ RESULTAT=RESULTAT,
+ NOM_CHAM='DEPL',
+ TOUT_ORDRE='OUI',
+ NOM_CMP=('DX','DY','DZ',),
+ OPERATION='EXTRACTION',),);
tabinf=__TINF.EXTR_TABLE()
DETRUIRE(CONCEPT=_F(NOM=__TINF),INFO=1)
else :
-#@ MODIF propa_fiss_ops Macro DATE 20/10/2008 AUTEUR GALENNE E.GALENNE
+#@ MODIF propa_fiss_ops Macro DATE 18/05/2010 AUTEUR MACOCCO K.MACOCCO
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# On importe les definitions des commandes a utiliser dans la macro
ASSE_MAILLAGE =self.get_cmd('ASSE_MAILLAGE' )
LIRE_MAILLAGE =self.get_cmd('LIRE_MAILLAGE' )
+ DEFI_FICHIER = self.get_cmd('DEFI_FICHIER' )
CREA_TABLE =self.get_cmd('CREA_TABLE' )
CALC_TABLE =self.get_cmd('CALC_TABLE' )
PROPA_XFEM = self.get_cmd('PROPA_XFEM' )
# Sauvegarde (maillage xfem et maillage concatene)
MA_XFEM2 = args['MA_XFEM2']
if MA_XFEM2 != None : self.DeclareOut('ma_xfem2',MA_XFEM2)
- __MA = mm.ToAster(unite=39)
+
+ unit = mm.ToAster()
+ DEFI_FICHIER(UNITE=unit, ACTION="LIBERER")
self.DeclareOut('ma_xfem2',MA_XFEM2)
- ma_xfem2=LIRE_MAILLAGE(UNITE=39);
+ ma_xfem2=LIRE_MAILLAGE(UNITE=unit);
MA_TOT2 = args['MA_TOT2']
if MA_TOT2 != None : self.DeclareOut('ma_tot',MA_TOT2)
# Sauvegarde (maillage xfem et maillage concatene)
MA_XFEM2 = args['MA_XFEM2']
if MA_XFEM2 != None : self.DeclareOut('ma_xfem2',MA_XFEM2)
- __MA = mm.ToAster(unite=39)
+ unit = mm.ToAster()
+ DEFI_FICHIER(UNITE=unit, ACTION="LIBERER")
self.DeclareOut('ma_xfem2',MA_XFEM2)
- ma_xfem2=LIRE_MAILLAGE(UNITE=39);
+ ma_xfem2=LIRE_MAILLAGE(UNITE=unit);
MA_TOT2 = args['MA_TOT2']
if MA_TOT2 != None : self.DeclareOut('ma_tot',MA_TOT2)
