From: Pascale Noyret Date: Thu, 3 Jun 2010 09:08:13 +0000 (+0000) Subject: Mise en coherence avec 9.6.10 X-Git-Tag: V2_0~76 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=7cb7f3df4e44a83bfeca1c666caaab5a432d45a4;p=modules%2Feficas.git Mise en coherence avec 9.6.10 --- diff --git a/Aster/Cata/cataSTA9/Macro/calc_ecrevisse_ops.py b/Aster/Cata/cataSTA9/Macro/calc_ecrevisse_ops.py index b14842da..520bf6f8 100644 --- a/Aster/Cata/cataSTA9/Macro/calc_ecrevisse_ops.py +++ b/Aster/Cata/cataSTA9/Macro/calc_ecrevisse_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -18,8 +18,100 @@ # 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, @@ -43,7 +135,7 @@ def calc_ecrevisse_ops(self, """ 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 """ @@ -51,9 +143,10 @@ def calc_ecrevisse_ops(self, 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 @@ -64,21 +157,30 @@ def calc_ecrevisse_ops(self, 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") @@ -89,10 +191,12 @@ def calc_ecrevisse_ops(self, 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) @@ -111,31 +215,33 @@ def calc_ecrevisse_ops(self, 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): @@ -155,10 +261,7 @@ def calc_ecrevisse_ops(self, 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 @@ -171,26 +274,31 @@ def calc_ecrevisse_ops(self, 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', @@ -199,18 +307,7 @@ def calc_ecrevisse_ops(self, 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', @@ -218,172 +315,182 @@ def calc_ecrevisse_ops(self, 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]) @@ -397,13 +504,22 @@ def calc_ecrevisse_ops(self, 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'], @@ -449,154 +565,170 @@ def calc_ecrevisse_ops(self, __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 @@ -608,32 +740,35 @@ def calc_ecrevisse_ops(self, 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) @@ -654,122 +789,289 @@ def calc_ecrevisse_ops(self, 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 diff --git a/Aster/Cata/cataSTA9/Macro/calc_essai_ops.py b/Aster/Cata/cataSTA9/Macro/calc_essai_ops.py index 7fdadf8d..06c2a912 100644 --- a/Aster/Cata/cataSTA9/Macro/calc_essai_ops.py +++ b/Aster/Cata/cataSTA9/Macro/calc_essai_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -29,17 +29,11 @@ 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): @@ -74,37 +68,16 @@ def calc_essai_ops( self, "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") @@ -113,14 +86,10 @@ def calc_essai_ops( self, # 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, @@ -162,8 +131,6 @@ def create_tab_mess_widgets(tk, UNITE_RESU): tabs = TabbedWindow(tabsw, ["Expansion de modeles", "Modification structurale", - "MEIDEE mono-modal fludela", - "MEIDEE mono-modal turbulent", "Identification de chargement", "Parametres de visualisation"]) @@ -215,10 +182,6 @@ class FermetureCallback: 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 @@ -228,8 +191,6 @@ def create_interactive_window(macro, 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 @@ -249,15 +210,10 @@ def create_interactive_window(macro, 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) diff --git a/Aster/Cata/cataSTA9/Macro/calc_table_ops.py b/Aster/Cata/cataSTA9/Macro/calc_table_ops.py index 2f1353bb..dabeeb7b 100644 --- a/Aster/Cata/cataSTA9/Macro/calc_table_ops.py +++ b/Aster/Cata/cataSTA9/Macro/calc_table_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -123,9 +123,9 @@ def calc_table_ops(self, TABLE, ACTION, INFO, **args): 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) diff --git a/Aster/Cata/cataSTA9/Macro/defi_fonc_elec_ops.py b/Aster/Cata/cataSTA9/Macro/defi_fonc_elec_ops.py new file mode 100644 index 00000000..32daba72 --- /dev/null +++ b/Aster/Cata/cataSTA9/Macro/defi_fonc_elec_ops.py @@ -0,0 +1,192 @@ +#@ 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]TINIR : + if temps[i]TINI : + if temps[i]TINIR : + if temps[i]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") @@ -95,19 +100,21 @@ def macr_ecre_calc_ops( 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, @@ -211,11 +218,14 @@ def macr_ecre_calc_ops( 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(): @@ -235,21 +245,24 @@ def macr_ecre_calc_ops( # 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 @@ -259,16 +272,20 @@ def macr_ecre_calc_ops( 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')): @@ -291,8 +308,7 @@ def macr_ecre_calc_ops( # --------------------------------------------------------------------- - - # EXECUTION D'ECREVISSE +# EXECUTION D'ECREVISSE # Choix du shell cmd = '#!sh' @@ -305,7 +321,7 @@ def macr_ecre_calc_ops( # 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() @@ -317,143 +333,73 @@ def macr_ecre_calc_ops( 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') @@ -464,50 +410,22 @@ def macr_ecre_calc_ops( _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, @@ -518,27 +436,48 @@ def macr_ecre_calc_ops( 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(): """ diff --git a/Aster/Cata/cataSTA9/Macro/macr_ecrevisse_ops.py b/Aster/Cata/cataSTA9/Macro/macr_ecrevisse_ops.py index 2cbd64a3..8758d4f9 100644 --- a/Aster/Cata/cataSTA9/Macro/macr_ecrevisse_ops.py +++ b/Aster/Cata/cataSTA9/Macro/macr_ecrevisse_ops.py @@ -1,21 +1,21 @@ -#@ 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, @@ -47,7 +47,7 @@ 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 """ @@ -58,16 +58,19 @@ def macr_ecrevisse_ops(self,reuse, 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") @@ -89,7 +92,7 @@ def macr_ecrevisse_ops(self,reuse, # 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 @@ -103,9 +106,9 @@ def macr_ecrevisse_ops(self,reuse, 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 @@ -148,12 +151,16 @@ def macr_ecrevisse_ops(self,reuse, 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 @@ -189,7 +196,7 @@ def macr_ecrevisse_ops(self,reuse, _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() @@ -209,30 +216,29 @@ def macr_ecrevisse_ops(self,reuse, 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 @@ -257,33 +263,33 @@ def macr_ecrevisse_ops(self,reuse, 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 # @@ -296,13 +302,13 @@ def macr_ecrevisse_ops(self,reuse, 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, @@ -313,7 +319,7 @@ def macr_ecrevisse_ops(self,reuse, **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, @@ -358,8 +364,8 @@ def macr_ecrevisse_ops(self,reuse, 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) ) @@ -370,25 +376,24 @@ def macr_ecrevisse_ops(self,reuse, 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, @@ -407,13 +412,13 @@ def macr_ecrevisse_ops(self,reuse, # 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 # ------------------------------------------------------------------------- @@ -446,11 +451,11 @@ def macr_ecrevisse_ops(self,reuse, 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, @@ -472,7 +477,7 @@ def macr_ecrevisse_ops(self,reuse, # 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), @@ -501,26 +506,26 @@ def macr_ecrevisse_ops(self,reuse, # 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 ) # @@ -552,7 +557,7 @@ def macr_ecrevisse_ops(self,reuse, # 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'] @@ -582,22 +587,24 @@ def macr_ecrevisse_ops(self,reuse, 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: @@ -612,7 +619,7 @@ def macr_ecrevisse_ops(self,reuse, 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 @@ -640,10 +647,10 @@ def macr_ecrevisse_ops(self,reuse, 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 @@ -660,7 +667,7 @@ def macr_ecrevisse_ops(self,reuse, 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) @@ -696,7 +703,7 @@ def macr_ecrevisse_ops(self,reuse, ), INFO=1,ALARME='NON', ) - + if (_nume_ordre != 0 ): DETRUIRE( CONCEPT=( _F(NOM=MECAECR0), diff --git a/Aster/Cata/cataSTA9/Macro/macr_lign_coupe_ops.py b/Aster/Cata/cataSTA9/Macro/macr_lign_coupe_ops.py index a503e9da..bcca4fb6 100644 --- a/Aster/Cata/cataSTA9/Macro/macr_lign_coupe_ops.py +++ b/Aster/Cata/cataSTA9/Macro/macr_lign_coupe_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -20,6 +20,100 @@ ######################################################################## # 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): @@ -364,83 +458,6 @@ def dist_min_deux_points(mail): 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): @@ -664,6 +681,8 @@ def macr_lign_coupe_ops(self,RESULTAT,CHAM_GD,UNITE_MAILLAGE,LIGN_COUPE, # 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' @@ -809,9 +828,10 @@ def macr_lign_coupe_ops(self,RESULTAT,CHAM_GD,UNITE_MAILLAGE,LIGN_COUPE, 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: @@ -839,7 +859,7 @@ def macr_lign_coupe_ops(self,RESULTAT,CHAM_GD,UNITE_MAILLAGE,LIGN_COUPE, 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é @@ -883,9 +903,10 @@ def macr_lign_coupe_ops(self,RESULTAT,CHAM_GD,UNITE_MAILLAGE,LIGN_COUPE, 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: @@ -908,7 +929,7 @@ def macr_lign_coupe_ops(self,RESULTAT,CHAM_GD,UNITE_MAILLAGE,LIGN_COUPE, 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) diff --git a/Aster/Cata/cataSTA9/Macro/macro_elas_mult_ops.py b/Aster/Cata/cataSTA9/Macro/macro_elas_mult_ops.py index 0d5a4139..94b5e820 100644 --- a/Aster/Cata/cataSTA9/Macro/macro_elas_mult_ops.py +++ b/Aster/Cata/cataSTA9/Macro/macro_elas_mult_ops.py @@ -1,27 +1,27 @@ -#@ 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 @@ -49,7 +49,7 @@ def macro_elas_mult_ops(self,MODELE,CHAM_MATER,CARA_ELEM,NUME_DDL, # 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 @@ -75,11 +75,10 @@ def macro_elas_mult_ops(self,MODELE,CHAM_MATER,CARA_ELEM,NUME_DDL, 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={} @@ -106,14 +105,24 @@ def macro_elas_mult_ops(self,MODELE,CHAM_MATER,CARA_ELEM,NUME_DDL, # 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'] @@ -134,8 +143,7 @@ def macro_elas_mult_ops(self,MODELE,CHAM_MATER,CARA_ELEM,NUME_DDL, 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 : @@ -154,7 +162,7 @@ def macro_elas_mult_ops(self,MODELE,CHAM_MATER,CARA_ELEM,NUME_DDL, 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, @@ -172,7 +180,7 @@ def macro_elas_mult_ops(self,MODELE,CHAM_MATER,CARA_ELEM,NUME_DDL, **motscle2) ) iocc=iocc+1 else: - if ielas : + if ielas : motscles['AFFE']=[] for m in CAS_CHARGE: motscles['AFFE'].append(_F(MODELE=MODELE, @@ -196,6 +204,7 @@ def macro_elas_mult_ops(self,MODELE,CHAM_MATER,CARA_ELEM,NUME_DDL, iocc=0 for m in CAS_CHARGE: + lchar1=lcharg[iocc] iocc=iocc+1 if m['OPTION']: @@ -233,17 +242,9 @@ def macro_elas_mult_ops(self,MODELE,CHAM_MATER,CARA_ELEM,NUME_DDL, 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), @@ -257,17 +258,9 @@ def macro_elas_mult_ops(self,MODELE,CHAM_MATER,CARA_ELEM,NUME_DDL, 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) diff --git a/Aster/Cata/cataSTA9/Macro/macro_matr_asse_ops.py b/Aster/Cata/cataSTA9/Macro/macro_matr_asse_ops.py index a3089492..e8edd504 100644 --- a/Aster/Cata/cataSTA9/Macro/macro_matr_asse_ops.py +++ b/Aster/Cata/cataSTA9/Macro/macro_matr_asse_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -88,7 +88,7 @@ def macro_matr_asse_ops(self,MODELE,CHAM_MATER,CARA_ELEM,MATR_ASSE, 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 @@ -121,7 +121,7 @@ def macro_matr_asse_ops(self,MODELE,CHAM_MATER,CARA_ELEM,MATR_ASSE, 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) diff --git a/Aster/Cata/cataSTA9/Macro/post_k1_k2_k3_ops.py b/Aster/Cata/cataSTA9/Macro/post_k1_k2_k3_ops.py index 7fcb68a6..551acc58 100644 --- a/Aster/Cata/cataSTA9/Macro/post_k1_k2_k3_ops.py +++ b/Aster/Cata/cataSTA9/Macro/post_k1_k2_k3_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -58,10 +58,10 @@ def InterpolFondFiss(s0, Coorfo) : # 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]: @@ -810,13 +810,22 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, 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 : @@ -839,13 +848,22 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, 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 : diff --git a/Aster/Cata/cataSTA9/Macro/propa_fiss_ops.py b/Aster/Cata/cataSTA9/Macro/propa_fiss_ops.py index 2933aa86..676a4dea 100644 --- a/Aster/Cata/cataSTA9/Macro/propa_fiss_ops.py +++ b/Aster/Cata/cataSTA9/Macro/propa_fiss_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -114,6 +114,7 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args): # 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' ) @@ -483,9 +484,11 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args): # 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) @@ -639,9 +642,10 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args): # 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)