From 73f76f6575b8cc939b006e54c03160ea85bf37bd Mon Sep 17 00:00:00 2001 From: Pascale Noyret Date: Thu, 3 Jun 2010 09:09:41 +0000 Subject: [PATCH] Mise en coherence avec 10.1.27 --- .../cataSTA10/Macro/calc_ecrevisse_ops.py | 1164 +++++++---- Aster/Cata/cataSTA10/Macro/calc_essai_ops.py | 194 +- .../cataSTA10/Macro/calc_europlexus_ops.py | 18 +- .../Cata/cataSTA10/Macro/calc_fonction_ops.py | 17 +- .../cataSTA10/Macro/calc_mode_rotation_ops.py | 3 +- .../Cata/cataSTA10/Macro/calc_precont_ops.py | 13 +- Aster/Cata/cataSTA10/Macro/calc_spec_ops.py | 135 +- Aster/Cata/cataSTA10/Macro/calc_table_ops.py | 37 +- .../Macro/creation_donnees_homard.py | 301 ++- .../cataSTA10/Macro/defi_fonc_elec_ops.py | 192 ++ .../cataSTA10/Macro/defi_inte_spec_ops.py | 19 +- .../Cata/cataSTA10/Macro/dyna_iss_vari_ops.py | 92 +- .../Cata/cataSTA10/Macro/exec_logiciel_ops.py | 16 +- .../Cata/cataSTA10/Macro/fiabilite_mefisto.py | 21 +- .../cataSTA10/Macro/impr_diag_campbell_ops.py | 1142 ++--------- .../Macro/impr_diag_campbell_utils.py | 823 ++++++++ .../Cata/cataSTA10/Macro/lire_fonction_ops.py | 11 +- Aster/Cata/cataSTA10/Macro/lire_table_ops.py | 4 +- .../cataSTA10/Macro/macr_adap_mail_ops.py | 245 ++- .../cataSTA10/Macro/macr_ascouf_calc_ops.py | 36 +- .../cataSTA10/Macro/macr_aspic_calc_ops.py | 44 +- .../Cata/cataSTA10/Macro/macr_ecla_pg_ops.py | 53 +- .../cataSTA10/Macro/macr_ecre_calc_ops.py | 373 ++-- .../cataSTA10/Macro/macr_ecrevisse_ops.py | 187 +- .../cataSTA10/Macro/macr_fiabilite_ops.py | 27 +- .../cataSTA10/Macro/macr_lign_coupe_ops.py | 188 +- Aster/Cata/cataSTA10/Macro/macr_recal_ops.py | 1126 ++++------- .../cataSTA10/Macro/macro_elas_mult_ops.py | 175 +- .../Cata/cataSTA10/Macro/macro_expans_ops.py | 69 +- .../cataSTA10/Macro/macro_matr_asse_ops.py | 6 +- .../Cata/cataSTA10/Macro/macro_miss_3d_ops.py | 25 +- Aster/Cata/cataSTA10/Macro/observation_ops.py | 907 +++++++-- Aster/Cata/cataSTA10/Macro/post_coque_ops.py | 172 ++ .../cataSTA10/Macro/post_dyna_alea_ops.py | 24 +- .../cataSTA10/Macro/post_endo_fiss_ops.py | 868 ++++++++ .../Cata/cataSTA10/Macro/post_k1_k2_k3_ops.py | 398 ++-- Aster/Cata/cataSTA10/Macro/propa_fiss_ops.py | 952 +++++---- Aster/Cata/cataSTA10/Macro/raff_xfem_ops.py | 3 +- Aster/Cata/cataSTA10/Macro/reca_algo.py | 153 +- .../Cata/cataSTA10/Macro/reca_calcul_aster.py | 1033 ++++------ Aster/Cata/cataSTA10/Macro/reca_controles.py | 24 +- Aster/Cata/cataSTA10/Macro/reca_evol.py | 165 ++ Aster/Cata/cataSTA10/Macro/reca_graphique.py | 3 +- Aster/Cata/cataSTA10/Macro/reca_interp.py | 181 +- Aster/Cata/cataSTA10/Macro/reca_mac.py | 129 ++ Aster/Cata/cataSTA10/Macro/reca_message.py | 199 +- .../Cata/cataSTA10/Macro/reca_utilitaires.py | 37 +- Aster/Cata/cataSTA10/Macro/recal.py | 1759 ++++++++++++++--- .../cataSTA10/Macro/simu_point_mat_ops.py | 1039 +++++----- .../Cata/cataSTA10/Macro/test_fonction_ops.py | 473 +++-- 50 files changed, 9337 insertions(+), 5938 deletions(-) create mode 100644 Aster/Cata/cataSTA10/Macro/defi_fonc_elec_ops.py create mode 100644 Aster/Cata/cataSTA10/Macro/impr_diag_campbell_utils.py create mode 100644 Aster/Cata/cataSTA10/Macro/post_coque_ops.py create mode 100644 Aster/Cata/cataSTA10/Macro/post_endo_fiss_ops.py create mode 100644 Aster/Cata/cataSTA10/Macro/reca_evol.py create mode 100644 Aster/Cata/cataSTA10/Macro/reca_mac.py diff --git a/Aster/Cata/cataSTA10/Macro/calc_ecrevisse_ops.py b/Aster/Cata/cataSTA10/Macro/calc_ecrevisse_ops.py index b14842da..fb0f15d5 100644 --- a/Aster/Cata/cataSTA10/Macro/calc_ecrevisse_ops.py +++ b/Aster/Cata/cataSTA10/Macro/calc_ecrevisse_ops.py @@ -1,25 +1,117 @@ -#@ MODIF calc_ecrevisse_ops Macro DATE 05/10/2009 AUTEUR ASSIRE A.ASSIRE +#@ MODIF calc_ecrevisse_ops Macro DATE 21/04/2010 AUTEUR BOTTONI M.BOTTONI # -*- 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. # ====================================================================== -# 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/cataSTA10/Macro/calc_essai_ops.py b/Aster/Cata/cataSTA10/Macro/calc_essai_ops.py index 7fdadf8d..749fa427 100644 --- a/Aster/Cata/cataSTA10/Macro/calc_essai_ops.py +++ b/Aster/Cata/cataSTA10/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 28/01/2010 AUTEUR BODEL C.BODEL # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -29,17 +29,18 @@ def calc_essai_ops( self, INTERACTIF = None, - UNITE_FIMEN = None, + #UNITE_FIMEN = None, UNITE_RESU = None, EXPANSION = None, - MEIDEE_FLUDELA = None, - MEIDEE_TURBULENT = None, + #MEIDEE_FLUDELA = None, + #MEIDEE_TURBULENT = None, IDENTIFICATION = None, MODIFSTRUCT = None, + TRAITEMENTSIG = None, GROUP_NO_CAPTEURS = None, GROUP_NO_EXTERIEUR = None, - RESU_FLUDELA = None, - RESU_TURBULENT = None, + #RESU_FLUDELA = None, + #RESU_TURBULENT = None, RESU_IDENTIFICATION = None, RESU_MODIFSTRU = None, **args): @@ -47,16 +48,16 @@ def calc_essai_ops( self, from Meidee.meidee_cata import MeideeObjects ier = 0 - prev = aster.onFatalError() - aster.onFatalError("EXCEPTION") - # La macro compte pour 1 dans la numerotation des commandes self.set_icmd(1) + prev = aster.onFatalError() # gestion des concepts sortants de la macro, declares a priori table = [] table_fonction = [] + mode_mec = [] + if not RESU_MODIFSTRU: out_modifstru = {} @@ -74,34 +75,36 @@ 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} - +## SUPRESSION (PROVISOIRE ?) DES ONGLETS IFS +## 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_fonction.append(res['FONCTION']) +## out_meideeturb = {"DeclareOut" : self.DeclareOut, +## "FoncOut" : table_fonction} # Mode interactif : ouverture d'une fenetre Tk if INTERACTIF == "OUI": + aster.onFatalError('EXCEPTION') + create_interactive_window(self, - UNITE_FIMEN, - UNITE_RESU, - out_fludela, - out_meideeturb, + #UNITE_FIMEN, + #out_fludela, + #out_meideeturb, out_identification, - out_modifstru) + out_modifstru, + ) else: from Meidee.meidee_calcul import MessageBox from Meidee.meidee_test import TestMeidee @@ -113,14 +116,14 @@ def calc_essai_ops( self, # importation des concepts aster existants de la memoire jeveux TestMeidee(self, mess, - out_fludela, - out_meideeturb, + #out_fludela, + #out_meideeturb, out_identification, out_modifstru, objects, EXPANSION, - MEIDEE_FLUDELA, - MEIDEE_TURBULENT, + #MEIDEE_FLUDELA, + #MEIDEE_TURBULENT, IDENTIFICATION, MODIFSTRUCT, GROUP_NO_CAPTEURS, @@ -133,7 +136,7 @@ def calc_essai_ops( self, -def create_tab_mess_widgets(tk, UNITE_RESU): +def create_tab_mess_widgets(tk): """Construits les objects table et boîte à messages.""" try: from Pmw import PanedWidget @@ -142,60 +145,45 @@ def create_tab_mess_widgets(tk, UNITE_RESU): from Meidee.meidee_iface import MessageBoxInteractif, TabbedWindow - if PanedWidget: - pw = PanedWidget(tk, orient='vertical', - hull_borderwidth = 1, - hull_relief = 'sunken', - ) - tabsw = pw.add("main", min=.1, max=.9) - msgw = pw.add("msg", min=.1, max=.2) - pw.grid(sticky='nsew') - tabsw.rowconfigure(0, weight=1) - tabsw.columnconfigure(0, weight=1) - msgw.rowconfigure(0, weight=1) - msgw.columnconfigure(0, weight=1) - else: - tabsw = tk - msgw = tk - tk.rowconfigure(1, weight=3) - tk.rowconfigure(1, weight=1) - + tabsw = tk + msgw = tk + tk.rowconfigure(0, weight=2) + tk.rowconfigure(1, weight=1) + tabs = TabbedWindow(tabsw, ["Expansion de modeles", "Modification structurale", - "MEIDEE mono-modal fludela", - "MEIDEE mono-modal turbulent", + #"MEIDEE mono-modal fludela", + #"MEIDEE mono-modal turbulent", "Identification de chargement", - "Parametres de visualisation"]) + "Traitement du signal", + "Parametres de visualisation", + ]) tabs.grid(row=0, column=0, sticky='nsew') # pack(side='top',expand=1,fill='both') # ecriture des message dans un fichier message - mess = MessageBoxInteractif(msgw, UNITE_RESU) - if PanedWidget: - mess.grid(row=0, column=0, sticky='nsew') - #mess.pack(side='top',expand=1,fill='both') - else: - mess.grid(row=1, column=0, sticky='nsew') - #mess.pack(side='top',expand=1,fill='both') + mess = MessageBoxInteractif(msgw) + mess.grid(row=1, column=0, sticky='nsew') return tabs, mess -def get_fimen_files(UNITE_FIMEN, FIMEN=None): - """Fichiers fimen éventuels associés aux unités logiques en entrée""" - # XXX FIMEN is not defined (should it be included in the macro) - from Utilitai.UniteAster import UniteAster - fichiers_fimen = [] - print "FIMEN:", UNITE_FIMEN - - if UNITE_FIMEN: - if type(FIMEN)==int: - UNITE_FIMEN= [ UNITE_FIMEN ] - for unit in UNITE_FIMEN: - UL = UniteAster() - fichiers_fimen.append( (unit, UL.Nom(unit)) ) - - return fichiers_fimen +## SUPRESSION (PROVISOIRE ?) DES ONGLETS IFS +##def get_fimen_files(UNITE_FIMEN, FIMEN=None): +## """Fichiers fimen éventuels associés aux unités logiques en entrée""" +## # XXX FIMEN is not defined (should it be included in the macro) +## from Utilitai.UniteAster import UniteAster +## fichiers_fimen = [] +## print "FIMEN:", UNITE_FIMEN +## +## if UNITE_FIMEN: +## if type(FIMEN)==int: +## UNITE_FIMEN= [ UNITE_FIMEN ] +## for unit in UNITE_FIMEN: +## UL = UniteAster() +## fichiers_fimen.append( (unit, UL.Nom(unit)) ) +## +## return fichiers_fimen class FermetureCallback: @@ -215,12 +203,12 @@ class FermetureCallback: def create_interactive_window(macro, - UNITE_FIMEN, - UNITE_RESU, - out_fludela, - out_meideeturb, + #UNITE_FIMEN, + #out_fludela, + #out_meideeturb, out_identification, - out_modifstru): + out_modifstru, + ): """Construit la fenêtre interactive comprenant une table pour les 4 domaines de Meidee.""" from Tkinter import Tk @@ -228,16 +216,19 @@ 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 + from Meidee.meidee_calc_spec import InterfaceCalcSpec +## SUPRESSION (PROVISOIRE ?) DES ONGLETS IFS +## from Meidee.meidee_fludela import InterfaceFludela, InterfaceTurbMonomod # fenetre principale tk = Tk() tk.rowconfigure(0, weight=1) tk.columnconfigure(0,weight=1) - - tabs, mess = create_tab_mess_widgets(tk, UNITE_RESU) + tk.title("CALC_ESSAI") + + tabs, mess = create_tab_mess_widgets(tk) main = tabs.root() # importation des concepts aster de la memoire jeveux @@ -246,25 +237,32 @@ def create_interactive_window(macro, param_visu = InterfaceParametres(main, mess) - iface = InterfaceCorrelation(main, objects, macro, mess, param_visu) + 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) + identification = InterfaceTurbulent(main, objects, mess, out_identification, param_visu) + calc_spec= InterfaceCalcSpec(main,objects,mess,param_visu) +## SUPRESSION (PROVISOIRE ?) DES ONGLETS IFS +## 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) + + 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("Identification de chargement", identification) + tabs.set_tab("Traitement du signal", calc_spec) tabs.set_tab("Parametres de visualisation", param_visu) +## SUPRESSION (PROVISOIRE ?) DES ONGLETS IFS +## tabs.set_tab("MEIDEE mono-modal fludela", fludelamonomod ) +## tabs.set_tab("MEIDEE mono-modal turbulent", turbmonomod ) + - #tabs.set_current_tab("Modifstruct") tabs.set_current_tab("Expansion de modeles") - tk.protocol("WM_DELETE_WINDOW", FermetureCallback(tk, turbulent).apply) + tk.protocol("WM_DELETE_WINDOW", FermetureCallback(tk, identification).apply) try: tk.mainloop() diff --git a/Aster/Cata/cataSTA10/Macro/calc_europlexus_ops.py b/Aster/Cata/cataSTA10/Macro/calc_europlexus_ops.py index d1ebb7d1..95a09fff 100644 --- a/Aster/Cata/cataSTA10/Macro/calc_europlexus_ops.py +++ b/Aster/Cata/cataSTA10/Macro/calc_europlexus_ops.py @@ -1,4 +1,4 @@ -#@ MODIF calc_europlexus_ops Macro DATE 16/11/2009 AUTEUR ASSIRE A.ASSIRE +#@ MODIF calc_europlexus_ops Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -33,7 +33,7 @@ dryrun = False import types,string import os -import Numeric as N +import numpy import math import copy @@ -54,7 +54,7 @@ tst = 1.0E-10 #----------------------------------------------------------------------- def norme(u) : - return N.sqrt(N.dot(u,u)) + return numpy.sqrt(numpy.dot(u,u)) def vecteurs_egaux(v1,v2): diff = v1-v2 @@ -335,7 +335,7 @@ class EUROPLEXUS: ligne_vale = [float(val) for val in ligne] courbes[icourbe].append(ligne_vale) for courbe in courbes : - courbes[courbe]=N.transpose(N.array(courbes[courbe])) + courbes[courbe]=numpy.transpose(numpy.array(courbes[courbe])) return courbes #----------------------------------------------------------------------- @@ -986,7 +986,7 @@ class EUROPLEXUS: if debug: print 'type(car_temp) = %s'%type(car_temp) dic_mater[nom_mater]['BETON'][car] = None if car_temp : - if type(car_temp) == float : + if isinstance(car_temp, float) : dic_mater[nom_mater]['BETON'][car] = car_temp else : if debug: print dir(car_temp) @@ -1137,7 +1137,7 @@ class EUROPLEXUS: vale = dic_mater[nom_mater]['BETON'][car_aster] car_epx = dic_corres2[car_aster] if vale is not None : - if type(vale) == float : + if isinstance(vale, float) : epx[MODULE].append('%s %s' %(car_epx,vale)) else : epx[MODULE].append('%s %s' %(car_epx,vale)) @@ -1145,7 +1145,7 @@ class EUROPLEXUS: vale = dic_mater[nom_mater]['BETON'][car_aster] car_epx = dic_corres2b[car_aster] if vale is not None : - if type(vale) == float : + if isinstance(vale, float) : epx[MODULE].append('%s %s' %(car_epx,vale)) else : epx[MODULE].append('%s %s' %(car_epx,vale)) @@ -2433,7 +2433,7 @@ class POUTRE: def angle2vecty(self,angl): #transformer en rd for iangl in range(len(angl)): - angl[iangl] = N.pi*angl[iangl]/180. + angl[iangl] = numpy.pi*angl[iangl]/180. cosa = math.cos( angl[0] ) sina = math.sin( angl[0] ) @@ -2444,7 +2444,7 @@ class POUTRE: vect = [ sing*sinb*cosa - cosg*sina , cosg*cosa + sing*sinb*sina , sing*cosb ] for ii in range(len(vect)): if abs(vect[ii]) <= tst : vect[ii] = 0.0 - vect = N.array(vect) + vect = numpy.array(vect) vect = vect/norme(vect) return vect diff --git a/Aster/Cata/cataSTA10/Macro/calc_fonction_ops.py b/Aster/Cata/cataSTA10/Macro/calc_fonction_ops.py index eabae056..6ad29724 100644 --- a/Aster/Cata/cataSTA10/Macro/calc_fonction_ops.py +++ b/Aster/Cata/cataSTA10/Macro/calc_fonction_ops.py @@ -1,4 +1,4 @@ -#@ MODIF calc_fonction_ops Macro DATE 16/11/2009 AUTEUR COURTOIS M.COURTOIS +#@ MODIF calc_fonction_ops Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -18,19 +18,11 @@ # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== +import os import copy import traceback -import os -from math import pi - -# ----------------------------------------------------------------------------- -def tocomplex(arg): - if arg[0]=='RI' : return complex(arg[1],arg[2]) - if arg[0]=='MP' : return complex(arg[1]*cos(arg[2]),arg[1]*sin(arg[2])) - -# ----------------------------------------------------------------------------- def calc_fonction_ops(self,FFT,DERIVE,INTEGRE,LISS_ENVELOP, SPEC_OSCI,ABS,COMB,COMB_C,COMPOSE,EXTRACTION, ENVELOPPE,FRACTILE,ASSE,CORR_ACCE,PUISSANCE,INVERSE, @@ -44,11 +36,10 @@ def calc_fonction_ops(self,FFT,DERIVE,INTEGRE,LISS_ENVELOP, from Cata_Utils.t_fonction import t_fonction, t_fonction_c, t_nappe, homo_support_nappe, \ FonctionError, ParametreError, InterpolationError, ProlongementError, enveloppe, fractile from Utilitai import liss_enveloppe + from Macro.defi_inte_spec_ops import tocomplex from Accas import _F from Cata.cata import nappe_sdaster,fonction_sdaster,fonction_c from Utilitai.Utmess import UTMESS - from Numeric import alltrue,less,array,reshape,cos,sin,exp,sqrt - from Numeric import choose,zeros,Float import aster_fonctions EnumTypes = (list, tuple) @@ -388,7 +379,7 @@ def calc_fonction_ops(self,FFT,DERIVE,INTEGRE,LISS_ENVELOP, return ier -# ----------------------------------------------------------------------------- + class Context(object): """Permet de stocker des éléments de contexte pour aider au diagnostic lors de l'émission de message. diff --git a/Aster/Cata/cataSTA10/Macro/calc_mode_rotation_ops.py b/Aster/Cata/cataSTA10/Macro/calc_mode_rotation_ops.py index 9a756cfa..51bfaa2a 100644 --- a/Aster/Cata/cataSTA10/Macro/calc_mode_rotation_ops.py +++ b/Aster/Cata/cataSTA10/Macro/calc_mode_rotation_ops.py @@ -1,4 +1,4 @@ -#@ MODIF calc_mode_rotation_ops Macro DATE 24/11/2009 AUTEUR COURTOIS M.COURTOIS +#@ MODIF calc_mode_rotation_ops Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -19,7 +19,6 @@ # ====================================================================== # RESPONSABLE Mohamed TORKHANI -from Numeric import * import aster from Accas import _F from types import ListType, TupleType diff --git a/Aster/Cata/cataSTA10/Macro/calc_precont_ops.py b/Aster/Cata/cataSTA10/Macro/calc_precont_ops.py index 1b178633..090b69e6 100644 --- a/Aster/Cata/cataSTA10/Macro/calc_precont_ops.py +++ b/Aster/Cata/cataSTA10/Macro/calc_precont_ops.py @@ -1,4 +1,4 @@ -#@ MODIF calc_precont_ops Macro DATE 31/03/2008 AUTEUR ASSIRE A.ASSIRE +#@ MODIF calc_precont_ops Macro DATE 23/03/2010 AUTEUR COURTOIS M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -86,12 +86,6 @@ def calc_precont_ops(self,reuse,MODELE,CHAM_MATER,CARA_ELEM,EXCIT, else : dEtatInit=None - # Test de la presence de reuse= - if self.reuse == None: - dReuse=None - else : - dReuse='RES' - # Teste si INST_INIT est donné ou bien recalcule __TMIN if dIncrement['INST_INIT'] == None: if self.reuse == None: @@ -401,9 +395,8 @@ def calc_precont_ops(self,reuse,MODELE,CHAM_MATER,CARA_ELEM,EXCIT, FONC_MULT=__FCT ),) motscle4={} - if dReuse: motscle4['reuse']=[] - else: motscle4['reuse']=dReuse - + if self.reuse: + motscle4['reuse'] = self.reuse RES=STAT_NON_LINE( MODELE =MODELE, diff --git a/Aster/Cata/cataSTA10/Macro/calc_spec_ops.py b/Aster/Cata/cataSTA10/Macro/calc_spec_ops.py index a6d669f0..12f66085 100644 --- a/Aster/Cata/cataSTA10/Macro/calc_spec_ops.py +++ b/Aster/Cata/cataSTA10/Macro/calc_spec_ops.py @@ -1,4 +1,4 @@ -#@ MODIF calc_spec_ops Macro DATE 21/10/2008 AUTEUR CORUS M.CORUS +#@ MODIF calc_spec_ops Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -41,8 +41,8 @@ def calc_spec_ops(self,TAB_ECHANT,ECHANT,INTERSPE,TRANSFERT,TITRE,INFO,**args): EnumTypes = (ListType, TupleType) from Accas import _F from Utilitai.Utmess import UTMESS - import Numeric - import FFT + import numpy + import numpy.fft as FFT commande='CALC_SPEC' @@ -102,6 +102,7 @@ def calc_spec_ops(self,TAB_ECHANT,ECHANT,INTERSPE,TRANSFERT,TITRE,INFO,**args): vale_sig=l_f[0][1]['FONCTION'].Valeurs(); l_ech=len(vale_sig[0]) dt=vale_sig[0][1]-vale_sig[0][0] + print "test : l_ech = ", l_ech else : #tab_ast=l_t[0][1]['NOM_TAB']; tab_ast=l_t['NOM_TAB'] #MC @@ -114,8 +115,10 @@ def calc_spec_ops(self,TAB_ECHANT,ECHANT,INTERSPE,TRANSFERT,TITRE,INFO,**args): l_ech_temp=l_t['LONGUEUR_ECH']; recouvr_temp=l_t['RECOUVREMENT']; + l_ech_t=[l_ech_temp[0]['DUREE'] , l_ech_temp[0]['POURCENT'],l_ech_temp[0]['NB_PTS'] ]; recouvr_t=[recouvr_temp[0]['DUREE'] , recouvr_temp[0]['POURCENT'],recouvr_temp[0]['NB_PTS'] ]; + if l_ech_t.count(None)==3 : l_ech=len(temp)/2; if recouvr_t.count(None)==3 : recouvr=0; if l_ech_t.count(None)<2 : @@ -125,43 +128,48 @@ def calc_spec_ops(self,TAB_ECHANT,ECHANT,INTERSPE,TRANSFERT,TITRE,INFO,**args): for i1 in range(3) : if l_ech_t[i1] !=None : if i1 == 0 : - l_ech=int(Numeric.floor(l_ech_t[i1]/dt)); + l_ech=int(numpy.floor(l_ech_t[i1]/dt)); elif i1 == 1 : - l_ech=int(Numeric.floor((len(temp)/2)*l_ech_t[i1]*0.01)); + l_ech=int(numpy.floor((len(temp)/2)*l_ech_t[i1]*0.01)); elif i1 == 2 : - l_ech=int(Numeric.floor(l_ech_t[i1])) + l_ech=int(numpy.floor(l_ech_t[i1])) if l_ech > len(temp)/2 : raise FonctionError, 'Vous devez specifier une longueur d'+"'"+'echantillon inferieure a la longueur totale de l'+"'"+'acquisition' for i1 in range(3) : if recouvr_t[i1] !=None : if i1 == 0 : - recouvr=int(Numeric.floor(recouvr_t[i1]/dt)); + recouvr=int(numpy.floor(recouvr_t[i1]/dt)); elif i1 == 1 : - recouvr=int(Numeric.floor((l_ech)*recouvr_t[i1]*0.01)); + recouvr=int(numpy.floor((l_ech)*recouvr_t[i1]*0.01)); elif i1 == 2 : - recouvr=int(Numeric.floor(recouvr_t[i1])) + recouvr=int(numpy.floor(recouvr_t[i1])) if recouvr > l_ech : raise FonctionError, 'La longueur de recouvrement ne peut exceder la longueur ' + print "test2 : l_ech = ", l_ech #-- Recuperation des fenetres + for occ in l_G+l_H : if occ[1]['FENETRE'] == 'RECT' : fene=[1.]*l_ech elif occ[1]['FENETRE'] == 'HAMM' : - fene=[0.54-0.46*Numeric.cos(2*Numeric.pi*i1/(l_ech-1)) for i1 in range(l_ech)] + fene=[0.54-0.46*numpy.cos(2*numpy.pi*i1/(l_ech-1)) for i1 in range(l_ech)] elif occ[1]['FENETRE'] == 'HANN' : - fene=[0.5-0.5*Numeric.cos(2*Numeric.pi*i1/(l_ech-1)) for i1 in range(l_ech)] + fene=[0.5-0.5*numpy.cos(2*numpy.pi*i1/(l_ech-1)) for i1 in range(l_ech)] elif occ[1]['FENETRE'] == 'EXPO' : para=occ[1]['DEFI_FENE'] if len(para) != 2 : raise FonctionError, 'Erreur de taille dans DEFI_FENE : ' + 'la fenetre exponentielle est definie par exactement deux valeurs' - fene=[1.]*int(para[0]-1)+[Numeric.exp(para[1]*(i1-int(para[0]-1))*dt) for i1 in range(int(para[0]-1),l_ech)] + fene=[1.]*int(para[0])+[numpy.exp(para[1]*(i1-int(para[0]-1))*dt) for i1 in range(int(para[0]),l_ech)] elif occ[1]['FENETRE'] == 'PART' : fene=occ[1]['DEFI_FENE'] if len(fene) != l_ech : raise FonctionError, 'Erreur de taille dans DEFI_FENE : ' + 'La fenetre doit etre definie avec le meme nombre de points que les echantillons' - + + # normalisation de la fenetre + fene=numpy.divide(fene,numpy.sqrt(numpy.sum(numpy.multiply(fene,fene)))).tolist() + if len(TRANSFERT)+len(INTERSPE) == 0 : #-- on ne rentre rien : interspectre par defaut - fenetre rectangulaire fene=[1.]*l_ech INTERSPE=1.; @@ -182,11 +190,11 @@ def calc_spec_ops(self,TAB_ECHANT,ECHANT,INTERSPE,TRANSFERT,TITRE,INFO,**args): if TAB_ECHANT : # Cas TAB_ECHANT num_mes_temp= tab_py['NUME_MES'].values()['NUME_MES'] - max_mes=Numeric.maximum.reduce(num_mes_temp); + max_mes=numpy.maximum.reduce(num_mes_temp); num_ord_temp= tab_py['NUME_ORDRE_I'].values()['NUME_ORDRE_I'] long_fonc=[len(fonc_py[i1].VALE.get()) for i1 in range(len(fonc_py))] - N_fen=int(Numeric.floor((Numeric.minimum.reduce(long_fonc)/2-l_ech)/(l_ech-recouvr))+1) + N_fen=int(numpy.floor((numpy.minimum.reduce(long_fonc)/2-l_ech)/(l_ech-recouvr))+1) sig=[]; dt=[]; @@ -194,7 +202,7 @@ def calc_spec_ops(self,TAB_ECHANT,ECHANT,INTERSPE,TRANSFERT,TITRE,INFO,**args): vale=fonc_py[i1].VALE.get(); temp=(list(vale[0:int(len(vale)/2)])); sig.append(list(vale[int(len(vale)/2):])); - test_pas=Numeric.subtract(temp[1:],temp[0:-1]) + test_pas=numpy.subtract(temp[1:],temp[0:-1]) crit=test_pas.tolist(); crit.sort(); dt.append(crit[-1]); @@ -203,16 +211,17 @@ def calc_spec_ops(self,TAB_ECHANT,ECHANT,INTERSPE,TRANSFERT,TITRE,INFO,**args): for j1 in range(N_fen) : for i1 in range(len(fonc_py)) : - fft.append(FFT.fft(Numeric.multiply(sig[i1][j1*(l_ech-recouvr):(j1*(l_ech-recouvr)+l_ech)],fene))) + fft.append(FFT.fft(numpy.multiply(sig[i1][j1*(l_ech-recouvr):(j1*(l_ech-recouvr)+l_ech)],fene))) if j1 == 0 : df.append(1./(dt[i1])/l_ech); num_mes.append(num_mes_temp[i1]+max_mes*j1); num_ord.append(num_ord_temp[i1]); - test_df=Numeric.subtract(df[1:],df[0:-1]) - test_df=test_df.tolist(); - test_df.sort(); - if abs(test_df[-1]) > 1.e-5 : - raise FonctionError, 'Toutes les fonctions doivent etre definies ' + 'avec la meme frequence d'+"'"+'echantillonage' + if len(df)>1 : + test_df=numpy.subtract(df[1:],df[0:-1]) + test_df=test_df.tolist(); + test_df.sort(); + if abs(test_df[-1]) > 1.e-5 : + raise FonctionError, 'Toutes les fonctions doivent etre definies ' + 'avec la meme frequence d'+"'"+'echantillonage' frq = [df[-1]*i1 for i1 in range(l_ech)] @@ -232,29 +241,31 @@ def calc_spec_ops(self,TAB_ECHANT,ECHANT,INTERSPE,TRANSFERT,TITRE,INFO,**args): num_ord.append(occ[1]['NUME_ORDRE_I']) tmp.append(vale_sig[0]) - test_pas=Numeric.subtract(vale_sig[0][1:],vale_sig[0][0:-1]) + test_pas=numpy.subtract(vale_sig[0][1:],vale_sig[0][0:-1]) crit=test_pas.tolist(); crit.sort(); if abs((crit[-1]-crit[0])/crit[-1]) > 1.e-5 : raise FonctionError, 'L'+"'"+'echantillonage doit etre fait a pas constant' - fft.append(FFT.fft(Numeric.multiply(vale_sig[1],fene))) + print "vale_sig[1]= ", len(vale_sig[1]), vale_sig[1] + print " fene = ",len(fene), fene + fft.append(FFT.fft(numpy.multiply(vale_sig[1],fene))) df.append(1./(crit[-1])/len(vale_sig[0])); #-- Verification des longueurs --# - test_long=Numeric.subtract(lt[1:],lt[0:-1]) + test_long=numpy.subtract(lt[1:],lt[0:-1]) test_long=test_long.tolist(); test_long.sort(); if (test_long[-1]-test_long[0]) != 0 : raise FonctionError, 'Toutes les fonctions doivent etre definies avec le meme nombre de points' - - test_df=Numeric.subtract(df[1:],df[0:-1]) - test_df=test_df.tolist(); - test_df.sort(); - if abs(test_df[-1]) > 1.e-5 : - raise FonctionError, 'Toutes les fonctions doivent etre definies '+'avec la meme frequence d'+"'"+'echantillonage' + if len(df) > 1 : + test_df=numpy.subtract(df[1:],df[0:-1]) + test_df=test_df.tolist(); + test_df.sort(); + if abs(test_df[-1]) > 1.e-5 : + raise FonctionError, 'Toutes les fonctions doivent etre definies '+'avec la meme frequence d'+"'"+'echantillonage' frq = [df[-1]*i1 for i1 in range(lt[-1])] @@ -280,13 +291,14 @@ def calc_spec_ops(self,TAB_ECHANT,ECHANT,INTERSPE,TRANSFERT,TITRE,INFO,**args): #-- Calcul de la matrice inter spectrale if len(INTERSPE) != 0 : - dimh = (len(list_ord)*(len(list_ord)+1))/2 + nb_ord = len(list_ord) + dimh = (nb_ord*(nb_ord+1))/2 l_fc=[]; nume_i1=[] nume_j1=[] - for i1 in range(len(list_ord)) : - for j1 in range(i1,len(list_ord)) : + for i1 in range(nb_ord) : + for j1 in range(i1,nb_ord) : #-- on ne calcule les spectres que pour des numeros de mesures correspondants #-- Ca n'a a priori pas de sens de calculer l'interspectre entre deux signaux acquis a des instants differents #-- Par contre, on peut moyenner deux interspectres obtenus a des instants differents, sous reserve @@ -297,19 +309,20 @@ def calc_spec_ops(self,TAB_ECHANT,ECHANT,INTERSPE,TRANSFERT,TITRE,INFO,**args): #-- recuperation des indices des fft a prendre en compte pour l'interspectre for k1 in range(len(mes_i1)) : if mes_i1[k1] in mes_j1 : - ind_mes.append([ind_ord[i1][k1],ind_ord[j1][mes_j1.index(mes_i1[k1])]]) + ind_mes.append([ind_ord[i1][k1], + ind_ord[j1][mes_j1.index(mes_i1[k1])]]) #-- Calcul des interspectres dsp=[0.j]*l_ech; if len(ind_mes) > 0 : for l1 in range(len(ind_mes)) : - dsp_t=Numeric.multiply(Numeric.conjugate(fft[ind_mes[l1][0]]),fft[ind_mes[l1][1]]) - dsp_t=Numeric.divide(dsp_t,l_ech*len(ind_mes)) - dsp=Numeric.add(dsp,dsp_t) + dsp_t=numpy.multiply(numpy.conjugate(fft[ind_mes[l1][0]]),fft[ind_mes[l1][1]]) + dsp_t=numpy.divide(dsp_t,l_ech*len(ind_mes)) + dsp=numpy.add(dsp,dsp_t) dsp=dsp.tolist(); dsp_r=[]; - for k1 in range(int(Numeric.floor(l_ech/2))) : + for k1 in range(int(numpy.floor(l_ech/2))) : dsp_r=dsp_r+[frq[k1],dsp[k1].real,dsp[k1].imag] _fonc = DEFI_FONCTION(NOM_PARA='FREQ',VALE_C=dsp_r,); @@ -318,17 +331,19 @@ def calc_spec_ops(self,TAB_ECHANT,ECHANT,INTERSPE,TRANSFERT,TITRE,INFO,**args): nume_j1.append(list_ord[j1]) mcfact=[] - mcfact.append(_F(PARA='NOM_CHAM' ,LISTE_K='DSP' )) - mcfact.append(_F(PARA='OPTION' ,LISTE_K='TOUT' )) - mcfact.append(_F(PARA='DIMENSION' ,LISTE_I=(dimh,) )) - mcfact.append(_F(PARA='NUME_ORDRE_I',LISTE_I=nume_i1 )) - mcfact.append(_F(PARA='NUME_ORDRE_J',LISTE_I=nume_j1 )) - mcfact.append(_F(PARA='FONCTION_C' ,LISTE_K=l_fc )) + mcfact.append(_F(PARA='NOM_CHAM' ,LISTE_K='DSP' ,NUME_LIGN=(1,) )) + mcfact.append(_F(PARA='OPTION' ,LISTE_K='TOUT' ,NUME_LIGN=(1,) )) + mcfact.append(_F(PARA='DIMENSION' ,LISTE_I=(dimh,) ,NUME_LIGN=(1,) )) + mcfact.append(_F(PARA='NUME_ORDRE_I',LISTE_I=nume_i1 ,NUME_LIGN=range(2,dimh+2) )) + mcfact.append(_F(PARA='NUME_ORDRE_J',LISTE_I=nume_j1 ,NUME_LIGN=range(2,dimh+2) )) + mcfact.append(_F(PARA='FONCTION_C' ,LISTE_K=l_fc ,NUME_LIGN=range(2,dimh+2))) self.DeclareOut('tab_inte',self.sd) tab_inte=CREA_TABLE(LISTE=mcfact, TITRE='', TYPE_TABLE='TABLE_FONCTION') - + + + #-- Calcul des transferts @@ -361,11 +376,13 @@ def calc_spec_ops(self,TAB_ECHANT,ECHANT,INTERSPE,TRANSFERT,TITRE,INFO,**args): if refer[i1] != list_ord[j1] : mes_i1=[num_mes[k1] for k1 in ind_ord[ind_refer[i1]]] #-- mesures des efforts mes_j1=[num_mes[k1] for k1 in ind_ord[j1]] #-- mesures des reponses + ind_mes=[]; #-- recuperation des indices des mesures a predre en compte pour les spectres for k1 in range(len(mes_i1)) : if mes_i1[k1] in mes_j1 : - ind_mes.append([ind_ord[i1][k1],ind_ord[j1][mes_j1.index(mes_i1[k1])]]) + ind_ord[j1][mes_j1.index(mes_i1[k1])] + ind_mes.append([ind_ord[ind_refer[i1]][k1],ind_ord[j1][mes_j1.index(mes_i1[k1])]]) #-- Calcul des FRF Guu=[0.j]*l_ech; @@ -373,29 +390,29 @@ def calc_spec_ops(self,TAB_ECHANT,ECHANT,INTERSPE,TRANSFERT,TITRE,INFO,**args): Gyu=[0.j]*l_ech; if len(ind_mes) > 0 : for l1 in range(len(ind_mes)) : - Guu_t=Numeric.multiply(Numeric.conjugate(fft[ind_mes[l1][0]]),fft[ind_mes[l1][0]]) - Guu=Numeric.add(Guu,Guu_t) - Gyu_t=Numeric.multiply(Numeric.conjugate(fft[ind_mes[l1][1]]),fft[ind_mes[l1][0]]) - Gyu=Numeric.add(Gyu,Gyu_t) - Gyy_t=Numeric.multiply(Numeric.conjugate(fft[ind_mes[l1][1]]),fft[ind_mes[l1][1]]) - Gyy=Numeric.add(Gyy,Gyy_t) + Guu_t=numpy.multiply(numpy.conjugate(fft[ind_mes[l1][0]]),fft[ind_mes[l1][0]]) + Guu=numpy.add(Guu,Guu_t) + Gyu_t=numpy.multiply(numpy.conjugate(fft[ind_mes[l1][1]]),fft[ind_mes[l1][0]]) + Gyu=numpy.add(Gyu,Gyu_t) + Gyy_t=numpy.multiply(numpy.conjugate(fft[ind_mes[l1][1]]),fft[ind_mes[l1][1]]) + Gyy=numpy.add(Gyy,Gyy_t) if l_H[0][1]['ESTIM']=='H1' : - frf=Numeric.divide(Numeric.conjugate(Gyu),Guu); + frf=numpy.divide(numpy.conjugate(Gyu),Guu); nom_frf='FRF-H1'; elif l_H[0][1]['ESTIM']=='H2' : - frf=Numeric.divide(Gyy,Gyu); + frf=numpy.divide(Gyy,Gyu); nom_frf='FRF-H2'; elif l_H[0][1]['ESTIM']=='CO' : - H1=Numeric.divide(Numeric.conjugate(Gyu),Guu); - H2=Numeric.divide(Gyy,Gyu); - frf=Numeric.divide(H1,H2); + H1=numpy.divide(numpy.conjugate(Gyu),Guu); + H2=numpy.divide(Gyy,Gyu); + frf=numpy.divide(H1,H2); nom_frf='FRF-COH'; frf=frf.tolist(); frf_r=[]; - for k1 in range(int(Numeric.floor(l_ech/2))) : + for k1 in range(int(numpy.floor(l_ech/2))) : frf_r=frf_r+[frq[k1],frf[k1].real,frf[k1].imag] _fonc = DEFI_FONCTION(NOM_PARA='FREQ',VALE_C=frf_r,); diff --git a/Aster/Cata/cataSTA10/Macro/calc_table_ops.py b/Aster/Cata/cataSTA10/Macro/calc_table_ops.py index 2c743742..842f7c5e 100644 --- a/Aster/Cata/cataSTA10/Macro/calc_table_ops.py +++ b/Aster/Cata/cataSTA10/Macro/calc_table_ops.py @@ -1,4 +1,4 @@ -#@ MODIF calc_table_ops Macro DATE 13/10/2009 AUTEUR COURTOIS M.COURTOIS +#@ MODIF calc_table_ops Macro DATE 26/05/2010 AUTEUR COURTOIS M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -18,7 +18,7 @@ # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -# RESPONSABLE MCOURTOI M.COURTOIS +# RESPONSABLE COURTOIS M.COURTOIS def calc_table_ops(self, TABLE, ACTION, INFO, **args): """ @@ -32,6 +32,7 @@ def calc_table_ops(self, TABLE, ACTION, INFO, **args): from Utilitai.Utmess import UTMESS from Utilitai import transpose from Utilitai.Table import Table, merge + from Utilitai.utils import get_titre_concept ier = 0 # La macro compte pour 1 dans la numerotation des commandes @@ -58,6 +59,10 @@ def calc_table_ops(self, TABLE, ACTION, INFO, **args): else: tab = TABLE.EXTR_TABLE() + # Réinitialiser le titre si on n'est pas réentrant + if self.reuse is None: + tab.titr = get_titre_concept(self.sd) + #---------------------------------------------- # Boucle sur les actions à effectuer for fOP in ACTION: @@ -98,7 +103,19 @@ def calc_table_ops(self, TABLE, ACTION, INFO, **args): tab = tab[occ['NOM_PARA']] #---------------------------------------------- - # 3. Traitement de RENOMME + # 3. Traitement de SUPPRIME + if occ['OPERATION'] == 'SUPPRIME': + lpar = occ['NOM_PARA'] + if type(lpar) not in (list, tuple): + lpar = [lpar] + keep = [] + for p in tab.para: + if not p in lpar: + keep.append(p) + tab = tab[keep] + + #---------------------------------------------- + # 4. Traitement de RENOMME if occ['OPERATION'] == 'RENOMME': try: tab.Renomme(*occ['NOM_PARA']) @@ -106,12 +123,12 @@ def calc_table_ops(self, TABLE, ACTION, INFO, **args): UTMESS('F','TABLE0_3',valk=msg) #---------------------------------------------- - # 4. Traitement du TRI + # 5. Traitement du TRI if occ['OPERATION'] == 'TRI': tab.sort(CLES=occ['NOM_PARA'], ORDRE=occ['ORDRE']) #---------------------------------------------- - # 5. Traitement de COMB + # 6. Traitement de COMB if occ['OPERATION'] == 'COMB': tab2 = occ['TABLE'].EXTR_TABLE() lpar = [] @@ -121,14 +138,14 @@ 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] ) restrict = occ.get('RESTREINT') == 'OUI' tab = merge(tab, tab2, lpar, restrict=restrict) #---------------------------------------------- - # 6. Traitement de OPER + # 7. Traitement de OPER if occ['OPERATION'] == 'OPER': # ajout de la colonne dans la table tab.fromfunction(occ['NOM_PARA'], occ['FORMULE']) @@ -137,7 +154,7 @@ def calc_table_ops(self, TABLE, ACTION, INFO, **args): aster.affiche('MESSAGE', 'Ajout de la colonne %s : %s' % (occ['NOM_PARA']+repr(vectval))+'\n') #---------------------------------------------- - # 6. Traitement de AJOUT + # 8. Traitement de AJOUT if occ['OPERATION'] == 'AJOUT': if len(occ['NOM_PARA']) != len(occ['VALE']): UTMESS('F', 'TABLE0_14') @@ -148,7 +165,7 @@ def calc_table_ops(self, TABLE, ACTION, INFO, **args): #---------------------------------------------- # 99. Création de la table_sdaster résultat # cas réentrant : il faut détruire l'ancienne table_sdaster - if self.sd.nom == TABLE.nom: + if self.reuse is not None: DETRUIRE(CONCEPT=_F(NOM=TABLE,), INFO=1) dprod = tab.dict_CREA_TABLE() diff --git a/Aster/Cata/cataSTA10/Macro/creation_donnees_homard.py b/Aster/Cata/cataSTA10/Macro/creation_donnees_homard.py index b3e19a1e..ccc45840 100644 --- a/Aster/Cata/cataSTA10/Macro/creation_donnees_homard.py +++ b/Aster/Cata/cataSTA10/Macro/creation_donnees_homard.py @@ -1,4 +1,4 @@ -#@ MODIF creation_donnees_homard Macro DATE 06/10/2008 AUTEUR GNICOLAS G.NICOLAS +#@ MODIF creation_donnees_homard Macro DATE 15/03/2010 AUTEUR GNICOLAS G.NICOLAS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -6,7 +6,7 @@ # 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. +# (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 @@ -19,9 +19,10 @@ # ====================================================================== # RESPONSABLE GNICOLAS G.NICOLAS """ -Cette classe crée le fichier de configuration permettant de lancer HOMARD depuis Code_Aster. +Cette classe crée le fichier de configuration permettant de lancer HOMARD +depuis Code_Aster. """ -__revision__ = "V1.4" +__revision__ = "V1.5" __all__ = [ ] import os @@ -33,7 +34,7 @@ try: from Utilitai.Utmess import UTMESS except ImportError: def UTMESS(code, idmess, valk=(), vali=(), valr=()): - """Clone de utmess si on ne reussit pas à le charger + """Clone de utmess si on ne reussit pas é le charger """ fmt = '\n <%s> <%s> %s %s %s\n\n' print fmt % (code, idmess, valk, vali, valr) @@ -56,9 +57,8 @@ class creation_donnees_homard: . Nom_Fichier_Configuration : nom du fichier de configuration (immuable) . Nom_Fichier_Donnees : nom du fichier de données (immuable) . mode_homard : le mode pour filtrer ici ("ADAP" ou "INFO") - . ModeHOMA : le mode pour HOMARD (1 ou 2) . mode_homard_texte : le mode d'utilisation, en francais ("ADAPTATION" ou "INFORMATION") - . elements_incompatibles : que faire des éléments incompatibles avec HOMARD + . mailles_incompatibles : que faire des mailles incompatibles avec HOMARD """ # ------------------------------------------------------------------------------ def __init__(self, nom_macro, mots_cles, dico_configuration ) : @@ -68,14 +68,13 @@ class creation_donnees_homard: # 1. Vérification de la macro qui appelle # d_aux = {} - d_aux["MACR_ADAP_MAIL"] = ( "ADAP", 1, "ADAPTATION" ) - d_aux["MACR_INFO_MAIL"] = ( "INFO", 2, "INFORMATION" ) + d_aux["MACR_ADAP_MAIL"] = ( "ADAP", "ADAPTATION" ) + d_aux["MACR_INFO_MAIL"] = ( "INFO", "INFORMATION" ) if d_aux.has_key(nom_macro) : self.mode_homard = d_aux[nom_macro][0] - self.ModeHOMA = d_aux[nom_macro][1] - self.mode_homard_texte = d_aux[nom_macro][2] + self.mode_homard_texte = d_aux[nom_macro][1] else : - UTMESS("F",'HOMARD0_1') + UTMESS("F", 'HOMARD0_1') # # 2. Données générales de cette initialisation # @@ -88,15 +87,15 @@ class creation_donnees_homard: self.mots_cles = mots_cles self.dico_configuration = dico_configuration # -# 3. Quel type de traitement des elemenst incompatibles +# 3. Quel type de traitement des mailles incompatibles # if mots_cles.has_key("ELEMENTS_NON_HOMARD") : d_aux = {} d_aux["REFUSER"] = "TOUS" d_aux["IGNORER"] = "IGNORE_QUAD" - self.elements_incompatibles = d_aux[mots_cles["ELEMENTS_NON_HOMARD"]] + self.mailles_incompatibles = d_aux[mots_cles["ELEMENTS_NON_HOMARD"]] else : - self.elements_incompatibles = None + self.mailles_incompatibles = None # # 4. Attributs immuables # @@ -106,7 +105,7 @@ class creation_donnees_homard: # ------------------------------------------------------------------------------ def int_to_str2 (self, entier) : """ - Transforme un entier compris entre 0 et 99 en une chaine sur deux caractères + Transforme un entier compris entre 0 et 99 en une chaine sur deux caractéres """ # print "\nArguments a l'entree de", __name__, ":", entier # @@ -125,7 +124,7 @@ class creation_donnees_homard: return # ------------------------------------------------------------------------------ def creation_configuration (self) : - """Crée les données nécessaires à la configuration + """Crée les données nécessaires é la configuration """ # message_erreur = None @@ -148,9 +147,29 @@ class creation_donnees_homard: aux = "Liste." + self.niter_vers_niterp1 self.ListeStd = aux # -# 3. Le type de bilan : il faut convertir la donnée textuelle en un entier, +# 3. Le mode de pilotage +# + if self.mode_homard == "INFO" : + self.ModeHOMA = 2 + self.Action = "info" + else : + if self.mots_cles["ADAPTATION"] == "MODIFICATION" : + self.ModeHOMA = 3 + self.Action = "modi" + self.ModDegre = "non" + self.CreJoint = "non" + else : + self.ModeHOMA = 1 + self.Action = "homa" + self.TypeRaff = "non" + self.TypeDera = "non" + self.critere_raffinement = None + self.critere_deraffinement = None + self.niveau = [] +# +# 4. Le type de bilan : il faut convertir la donnée textuelle en un entier, # produit de nombres premiers. -# Si rien n'est demandé, on met 0. +# Si rien n'est demandé, on met 1. # aux = 1 dico_aux = {} @@ -159,6 +178,7 @@ class creation_donnees_homard: dico_aux["QUALITE"] = 5 dico_aux["CONNEXITE"] = 11 dico_aux["TAILLE"] = 13 + dico_aux["PROP_CALCUL"] = 17 l_aux = dico_aux.keys() for choix in l_aux : if self.mots_cles.has_key(choix) : @@ -168,7 +188,7 @@ class creation_donnees_homard: aux = 0 self.TypeBila = aux # -# 4. Les entrées/sorties au format MED +# 5. Les entrées/sorties au format MED # self.CCNoMN__ = self.dico_configuration["NOM_MED_MAILLAGE_N"] if self.mode_homard == "ADAP" : @@ -178,20 +198,20 @@ class creation_donnees_homard: else : self.CCMaiAnn = None # -# 5. Les entrées/sorties au format HOMARD +# 6. Les entrées/sorties au format HOMARD # if self.mode_homard == "ADAP" : - self.fic_homard_niter = "M_" + self.str_niter + ".hom.med" - self.fic_homard_niterp1 = "M_" + self.str_niterp1 + ".hom.med" + self.fic_homard_niter = "maill." + self.str_niter + ".hom.med" + self.fic_homard_niterp1 = "maill." + self.str_niterp1 + ".hom.med" else : - self.fic_homard_niter = None + self.fic_homard_niter = None self.fic_homard_niterp1 = None # -# 6.1. Le pilotage de l'adaptation +# 7. Le pilotage de l'adaptation # - if self.mode_homard == "ADAP" : + if self.ModeHOMA == 1 : # -# 6.1. Le type d'adaptation +# 7.1. Le type d'adaptation # if self.mots_cles["ADAPTATION"] == "RAFFINEMENT" or self.mots_cles["ADAPTATION"] == "RAFFINEMENT_ZONE" : self.TypeRaff = "libre" @@ -214,7 +234,7 @@ class creation_donnees_homard: #gn print "... self.TypeRaff = ",self.TypeRaff #gn print "... self.TypeDera = ",self.TypeDera # -# 6.2. L'éventuel seuil de raffinement +# 7.2. L'éventuel seuil de raffinement # if self.TypeRaff == "libre" and self.mots_cles["ADAPTATION"] != "RAFFINEMENT_ZONE" : d_aux = {} @@ -226,11 +246,9 @@ class creation_donnees_homard: if self.mots_cles[mot_cle] is not None : aux = self.mots_cles[mot_cle]*d_aux[mot_cle][1] self.critere_raffinement = (d_aux[mot_cle][0], aux) - else : - self.critere_raffinement = None #gn print "... self.critere_raffinement = ", self.critere_raffinement # -# 6.3. L'éventuel seuil de déraffinement +# 7.3. L'éventuel seuil de déraffinement # if self.TypeDera == "libre" : d_aux = {} @@ -242,13 +260,10 @@ class creation_donnees_homard: if self.mots_cles[mot_cle] is not None : aux = self.mots_cles[mot_cle]*d_aux[mot_cle][1] self.critere_deraffinement = (d_aux[mot_cle][0], aux) - else : - self.critere_deraffinement = None #gn print "... self.critere_deraffinement = ", self.critere_deraffinement # -# 6.4. Les niveaux extremes +# 7.4. Les niveaux extremes # - self.niveau = [] for mot_cle in [ "NIVE_MIN", "NIVE_MAX" ] : if self.mots_cles.has_key(mot_cle) : if self.mots_cles[mot_cle] is not None : @@ -265,11 +280,11 @@ class creation_donnees_homard: ", doit etre < au niveau maxi, "+str(self.mots_cles["NIVE_MAX"])+"." break # -# 6.5. Les éventuelles zones de raffinement +# 7.5. Les éventuelles zones de raffinement # - if self.dico_configuration.has_key("Zones") : + if self.dico_configuration.has_key("Zones_raffinement") : iaux = 0 - for zone in self.dico_configuration["Zones"] : + for zone in self.dico_configuration["Zones_raffinement"] : iaux = iaux + 1 s_aux_1 = "Zone numero "+str(iaux)+" : " s_aux_2 = ", doit etre < au " @@ -281,16 +296,41 @@ class creation_donnees_homard: if zone.has_key("Z_MINI") : if zone["Z_MINI"] > zone["Z_MAXI"] : message_erreur = s_aux_1+"Z mini ,"+str(zone["Z_MINI"])+s_aux_2+"Z maxi, "+str(zone["Z_MAXI"])+"." +# +# 8. Le pilotage de la modification +# + if self.ModeHOMA == 3 : + mot_cle = "DEGRE" + if self.mots_cles.has_key(mot_cle) : + if self.mots_cles[mot_cle] is not None : + self.ModDegre = self.mots_cles[mot_cle] +# + mot_cle = "JOINT" + if self.mots_cles.has_key(mot_cle) : + if self.mots_cles[mot_cle] is not None : + self.CreJoint = self.mots_cles[mot_cle] +#gn print self.ModDegre, self.CreJoint +# +# 9. Options annexes +# + info = self.dico_configuration["INFO"] + if ( info == 2 ) : + self.MessInfo = 2 + elif ( info > 2 ) : + self.MessInfo = 30 + else : + self.MessInfo = None + # break # if message_erreur is not None : - UTMESS("F",'HOMARD0_2',valk=message_erreur) + UTMESS("F", 'HOMARD0_2', valk=message_erreur) # return self.fic_homard_niter, self.fic_homard_niterp1 # ------------------------------------------------------------------------------ def ouvre_fichier (self, nomfic_local) : - """Ouvre en écriture un fichier après l'avoir éventuellement détruit + """Ouvre en écriture un fichier aprés l'avoir éventuellement détruit """ codret_partiel = [0] ### print nomfic_local @@ -302,16 +342,17 @@ class creation_donnees_homard: os.remove (nomfic) except os.error, codret_partiel : print "Probleme au remove, erreur numéro ", codret_partiel[0], ":", codret_partiel[1] - UTMESS("F",'HOMARD0_3',valk=nomfic) + UTMESS("F", 'HOMARD0_3', valk=nomfic) # fichier = open (nomfic,"w") self.fichier = fichier # return fichier, nomfic +# ------------------------------------------------------------------------------ def ecrire_ligne_configuration_0 (self, commentaire) : """Ecrit une ligne de commentaires du fichier de configuration Arguments : - . commentaire : le commentaire à écrire + . commentaire : le commentaire é écrire """ # ligne = "#\n" @@ -320,12 +361,26 @@ class creation_donnees_homard: self.fichier.write(ligne) # return +# ------------------------------------------------------------------------------ + def ecrire_ligne_configuration_1 (self, texte) : + """Ecrit une ligne brute du fichier de configuration + Arguments : + . texte : le texte a ecrire + """ +# +# print texte +# ligne = texte + "\n" + ligne = texte +# print "==> ",ligne + self.fichier.write(ligne) +# + return # ------------------------------------------------------------------------------ def ecrire_ligne_configuration_2 (self, motcle, valeur) : """Ecrit une ligne du fichier de configuration dans le cas : motcle + valeur Arguments : - . motcle : le mot-clé HOMARD à écrire - . valeur : la valeur associée + . motcle : le mot-cle HOMARD a ecrire + . valeur : la valeur associee """ # ligne = motcle + " " + str(valeur) + "\n" @@ -336,8 +391,8 @@ class creation_donnees_homard: def ecrire_ligne_configuration_3 (self, motcle, valeur1, valeur2) : """Ecrit une ligne du fichier de configuration dans le cas : motcle + valeur1 + valeur2 Arguments : - . motcle : le mot-clé HOMARD à écrire - . valeur : la valeur associée + . motcle : le mot-cle HOMARD a ecrire + . valeur : la valeur associee """ # ligne = motcle + " " + str(valeur1) + " " + str(valeur2) + "\n" @@ -360,6 +415,7 @@ class creation_donnees_homard: # self.ecrire_ligne_configuration_0("Generalites") self.ecrire_ligne_configuration_2("ModeHOMA", self.ModeHOMA) + self.ecrire_ligne_configuration_2("Action", self.Action) self.ecrire_ligne_configuration_2("ListeStd", self.ListeStd) self.ecrire_ligne_configuration_2("TypeBila", self.TypeBila) self.ecrire_ligne_configuration_2("CCAssoci", "MED") @@ -391,6 +447,7 @@ class creation_donnees_homard: # 5. Le pilotage de l'adaptation # if self.mode_homard == "ADAP" : +# self.ecrire_ligne_configuration_0("Le pilotage de l'adaptation") # # 5.1. Type d'adaptation @@ -409,34 +466,55 @@ class creation_donnees_homard: self.ecrire_ligne_configuration_0("L'indicateur d'erreur") self.ecrire_ligne_configuration_2("CCIndica", self.dico_configuration["Fichier_ASTER_vers_HOMARD"]) self.ecrire_ligne_configuration_2("CCNoChaI", self.dico_configuration["Indicateur"]["NOM_MED"]) - self.ecrire_ligne_configuration_2("CCCoChaI", self.dico_configuration["Indicateur"]["COMPOSANTE"]) + for saux in self.dico_configuration["Indicateur"]["COMPOSANTE"] : + self.ecrire_ligne_configuration_2("CCCoChaI", saux) if self.dico_configuration["Indicateur"].has_key("NUME_ORDRE") : self.ecrire_ligne_configuration_2("CCNumOrI", self.dico_configuration["Indicateur"]["NUME_ORDRE"]) self.ecrire_ligne_configuration_2("CCNumPTI", self.dico_configuration["Indicateur"]["NUME_ORDRE"]) if self.mots_cles.has_key("TYPE_VALEUR_INDICA") : - self.ecrire_ligne_configuration_2("CCTyVaIn", self.mots_cles["TYPE_VALEUR_INDICA"]) + self.ecrire_ligne_configuration_2("CCUsCmpI", self.mots_cles["TYPE_VALEUR_INDICA"]) # # 5.3. Les éventuelles zones de raffinement # - if self.dico_configuration.has_key("Zones") : + if self.dico_configuration.has_key("Zones_raffinement") : + dico_zone = {} + dico_zone["X_MINI"] = "ZoRaXmin" + dico_zone["X_MAXI"] = "ZoRaXmax" + dico_zone["Y_MINI"] = "ZoRaYmin" + dico_zone["Y_MAXI"] = "ZoRaYmax" + dico_zone["Z_MINI"] = "ZoRaZmin" + dico_zone["Z_MAXI"] = "ZoRaZmax" + dico_zone["X_CENTRE"] = "ZoRaXCen" + dico_zone["Y_CENTRE"] = "ZoRaYCen" + dico_zone["Z_CENTRE"] = "ZoRaZCen" + dico_zone["RAYON"] = "ZoRaRayo" + dico_zone["RAYON_INT"] = "ZoRaRayI" + dico_zone["RAYON_EXT"] = "ZoRaRayE" + dico_zone["X_AXE"] = "ZoRaXAxe" + dico_zone["Y_AXE"] = "ZoRaYAxe" + dico_zone["Z_AXE"] = "ZoRaZAxe" + dico_zone["X_BASE"] = "ZoRaXBas" + dico_zone["Y_BASE"] = "ZoRaYBas" + dico_zone["Z_BASE"] = "ZoRaZBas" + dico_zone["HAUTEUR"] = "ZoRaHaut" + l_aux = dico_zone.keys() + dico_zone["TYPE"] = "ZoRaType" + dico_zone["RECTANGLE"] = 1 + dico_zone["BOITE"] = 2 + dico_zone["DISQUE"] = 3 + dico_zone["SPHERE"] = 4 + dico_zone["CYLINDRE"] = 5 + dico_zone["DISQUE_PERCE"] = 6 + dico_zone["TUYAU"] = 7 iaux = 0 - for zone in self.dico_configuration["Zones"] : + for zone in self.dico_configuration["Zones_raffinement"] : iaux = iaux + 1 self.ecrire_ligne_configuration_0("Zone de raffinement numéro "+str(iaux)) - if zone.has_key("X_MINI") : - self.ecrire_ligne_configuration_3("ZoRaXmin", iaux, zone["X_MINI"]) - self.ecrire_ligne_configuration_3("ZoRaXmax", iaux, zone["X_MAXI"]) - self.ecrire_ligne_configuration_3("ZoRaYmin", iaux, zone["Y_MINI"]) - self.ecrire_ligne_configuration_3("ZoRaYmax", iaux, zone["Y_MAXI"]) - if zone.has_key("Z_MINI") : - self.ecrire_ligne_configuration_3("ZoRaZmin", iaux, zone["Z_MINI"]) - self.ecrire_ligne_configuration_3("ZoRaZmax", iaux, zone["Z_MAXI"]) - if zone.has_key("X_CENTRE") : - self.ecrire_ligne_configuration_3("ZoRaXCen", iaux, zone["X_CENTRE"]) - self.ecrire_ligne_configuration_3("ZoRaYCen", iaux, zone["Y_CENTRE"]) - self.ecrire_ligne_configuration_3("ZoRaRayo", iaux, zone["RAYON"]) - if zone.has_key("Z_CENTRE") : - self.ecrire_ligne_configuration_3("ZoRaZCen", iaux, zone["Z_CENTRE"]) + jaux = dico_zone[zone["TYPE"]] + self.ecrire_ligne_configuration_3(dico_zone["TYPE"], iaux, jaux) + for aux in l_aux : + if zone.has_key(aux) : + self.ecrire_ligne_configuration_3(dico_zone[aux], iaux, zone[aux]) # # 5.4. Les niveaux extremes # @@ -460,6 +538,20 @@ class creation_donnees_homard: for group in self.mots_cles[cle] : self.ecrire_ligne_configuration_2("CCGroAda", group) # +# 5.7. Les modifications +# + if self.ModeHOMA == 3 : + self.ecrire_ligne_configuration_2("ModDegre", self.ModDegre) + self.ecrire_ligne_configuration_2("CreJoint", self.CreJoint) +# +# 5.8. L'éventuel maillage annexe +# + if self.CCMaiAnn is not None : + self.ecrire_ligne_configuration_0("Maillage d'autre degré") + self.ecrire_ligne_configuration_2("ModDegre", "oui") + self.ecrire_ligne_configuration_2("CCNoMAnn", self.CCMaiAnn) + self.ecrire_ligne_configuration_2("CCMaiAnn", self.dico_configuration["Fichier_HOMARD_vers_ASTER"]) +# # 6. Les éventuels champs à mettre à jour # if self.dico_configuration.has_key("Champs") : @@ -477,11 +569,15 @@ class creation_donnees_homard: elif maj_champ.has_key("INST") : self.ecrire_ligne_configuration_3("CCChaIns", iaux, maj_champ["INST"]) # -# 7. L'éventuel maillage de frontière +# 7. L'éventuel suivi de frontière +# + SuivFron = 1 +# +# 7.1. A partir d'un maillage de la frontière # if self.dico_configuration.has_key("NOM_MED_MAILLAGE_FRONTIERE") : + SuivFron = SuivFron * 2 self.ecrire_ligne_configuration_0("Maillage de frontière") - self.ecrire_ligne_configuration_2("SuivFron", "oui") self.ecrire_ligne_configuration_2("CCFronti", self.dico_configuration["Fichier_ASTER_vers_HOMARD"]) self.ecrire_ligne_configuration_2("CCNoMFro", self.dico_configuration["NOM_MED_MAILLAGE_FRONTIERE"]) if self.mots_cles.has_key("GROUP_MA_FRONT") : @@ -492,30 +588,73 @@ class creation_donnees_homard: for group_ma in self.mots_cles["GROUP_MA_FRONT"] : self.ecrire_ligne_configuration_2("CCGroFro", group_ma) # -# 8. L'éventuel maillage annexe +# 7.2. A partir d'une definition analytique +# + if self.dico_configuration.has_key("Frontiere_analytique") : + SuivFron = SuivFron * 3 + dico_frontiere = {} + dico_frontiere["RAYON"] = "FARayon" + dico_frontiere["X_CENTRE"] = "FAXCen" + dico_frontiere["Y_CENTRE"] = "FAYCen" + dico_frontiere["Z_CENTRE"] = "FAZCen" + dico_frontiere["X_AXE"] = "FAXAxe" + dico_frontiere["Y_AXE"] = "FAYAxe" + dico_frontiere["Z_AXE"] = "FAZAxe" + l_aux = dico_frontiere.keys() + dico_frontiere["GROUP_MA"] = "FAGroupe" + dico_frontiere["TYPE"] = "FAType" + dico_frontiere["CYLINDRE"] = 1 + dico_frontiere["SPHERE"] = 2 + iaux = 0 + for frontiere in self.dico_configuration["Frontiere_analytique"] : + if not type(frontiere["GROUP_MA"]) in EnumTypes : + lt_aux = [ frontiere["GROUP_MA"] ] + else : + lt_aux = frontiere["GROUP_MA"] + for group_ma in lt_aux : + iaux = iaux + 1 + self.ecrire_ligne_configuration_0("Description de la frontiere analytique numero "+str(iaux)) + jaux = dico_frontiere[frontiere["TYPE"]] + self.ecrire_ligne_configuration_3(dico_frontiere["TYPE"], iaux, jaux) + self.ecrire_ligne_configuration_3(dico_frontiere["GROUP_MA"], iaux, group_ma) + for aux in l_aux : + if frontiere.has_key(aux) : + self.ecrire_ligne_configuration_3(dico_frontiere[aux], iaux, frontiere[aux]) # - if self.mode_homard == "ADAP" : - if self.CCMaiAnn is not None : - self.ecrire_ligne_configuration_0("Maillage d'autre degré") - self.ecrire_ligne_configuration_2("ModDegre", "oui") - self.ecrire_ligne_configuration_2("CCNoMAnn", self.CCMaiAnn) - self.ecrire_ligne_configuration_2("CCMaiAnn", self.dico_configuration["Fichier_HOMARD_vers_ASTER"]) +# 7.3. Activation de la fonction # -# 9. Options particulières + if ( self.dico_configuration.has_key("NOM_MED_MAILLAGE_FRONTIERE") or self.dico_configuration.has_key("Frontiere_analytique") ) : + self.ecrire_ligne_configuration_2("SuivFron", SuivFron) +# +# 8. Options particuliéres # self.ecrire_ligne_configuration_0("Autres options") if self.mots_cles.has_key("LANGUE") : self.ecrire_ligne_configuration_2("Langue", self.mots_cles["LANGUE"]) - self.ecrire_ligne_configuration_2("MessInfo", self.dico_configuration["INFO"]) + if self.MessInfo is not None : + self.ecrire_ligne_configuration_2("MessInfo", self.MessInfo) if self.dico_configuration["version_perso"] : VERSION_HOMARD = self.dico_configuration["VERSION_HOMARD"] self.ecrire_ligne_configuration_2("DicoOSGM", "$HOMARD_USER/"+VERSION_HOMARD+"/CONFIG/typobj.stu") # -# 10. L'usage des éléments incompatibles avec HOMARD +# 9. L'usage des mailles incompatibles avec HOMARD +# + if self.mailles_incompatibles is not None : + self.ecrire_ligne_configuration_0("Les mailles incompatibles avec HOMARD") + self.ecrire_ligne_configuration_2("TypeElem", self.mailles_incompatibles) +# +# 10. L'éventuel complement # - if self.elements_incompatibles is not None : - self.ecrire_ligne_configuration_0("Les éléments incompatibles avec HOMARD") - self.ecrire_ligne_configuration_2("TypeElem", self.elements_incompatibles) + if self.dico_configuration.has_key("fichier_conf_suppl") : + nomfic = self.dico_configuration["fichier_conf_suppl"] +# print nomfic + if os.path.isfile(nomfic) : + fichier_bis = open (nomfic, "r") + les_lignes = fichier_bis.readlines() + fichier_bis.close() +# print les_lignes + for ligne in les_lignes : + self.ecrire_ligne_configuration_1(ligne) # # 11. Fermeture du fichier # @@ -524,7 +663,7 @@ class creation_donnees_homard: # if message_erreur is not None : message_erreur = "Ecriture de "+nomfic_global+". "+message_erreur - UTMESS("F",'HOMARD0_2',valk=message_erreur) + UTMESS("F", 'HOMARD0_2', valk=message_erreur) # return # ------------------------------------------------------------------------------ @@ -552,6 +691,6 @@ class creation_donnees_homard: break # if message_erreur is not None : - UTMESS("F",'HOMARD0_2',valk=message_erreur) + UTMESS("F", 'HOMARD0_2', valk=message_erreur) # return nomfic_global diff --git a/Aster/Cata/cataSTA10/Macro/defi_fonc_elec_ops.py b/Aster/Cata/cataSTA10/Macro/defi_fonc_elec_ops.py new file mode 100644 index 00000000..0560d328 --- /dev/null +++ b/Aster/Cata/cataSTA10/Macro/defi_fonc_elec_ops.py @@ -0,0 +1,192 @@ +#@ MODIF defi_fonc_elec_ops Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS +# -*- 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 numpy + + # 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=numpy.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=numpy.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] Ecriture des données nécessaires # f_stoch.Ecrit_Titre ("Code name") - aux=string.replace(VERSION,"_",".") - aux=string.replace(aux,"N","n") - aux=string.replace(aux,"V","v") + aux=VERSION.replace("_",".") + aux=aux.replace("N","n") + aux=aux.replace("V","v") f_stoch.Ecrit_Valeurs ( "aster_" + aux ) # aux = [ "Gradients evaluated by the code" ] @@ -246,8 +245,8 @@ def fiabilite_mefisto ( self, Rep_Calc_LOGICIEL_global, aux.append(args["MATRICE"][n + m*nb_occu_variable]) f_stoch.Ecrit_Valeurs ( aux ) else: - aux=Numeric.identity(nb_occu_variable) - aux=Numeric.concatenate(aux) + aux=numpy.identity(nb_occu_variable) + aux=numpy.concatenate(aux) aux=aux.tolist() f_stoch.Ecrit_Valeurs ( aux ) # diff --git a/Aster/Cata/cataSTA10/Macro/impr_diag_campbell_ops.py b/Aster/Cata/cataSTA10/Macro/impr_diag_campbell_ops.py index 445a766d..47670423 100644 --- a/Aster/Cata/cataSTA10/Macro/impr_diag_campbell_ops.py +++ b/Aster/Cata/cataSTA10/Macro/impr_diag_campbell_ops.py @@ -1,4 +1,4 @@ -#@ MODIF impr_diag_campbell_ops Macro DATE 28/07/2009 AUTEUR TORKHANI M.TORKHANI +#@ MODIF impr_diag_campbell_ops Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -19,933 +19,27 @@ # ====================================================================== # RESPONSABLE Mohamed TORKHANI -import Numeric -import aster -from Accas import _F -from Numeric import * -def CLASS_MODES(self,L_MODES, NFREQ, NFREQ_camp, L_GR_NOEUD, VITE_ROTA) : - - POST_RELEVE_T =self.get_cmd('POST_RELEVE_T') - EXTR_MODE =self.get_cmd('EXTR_MODE') - NORM_MODE =self.get_cmd('NORM_MODE') - DETRUIRE =self.get_cmd('DETRUIRE') -# Classification des modes en flexion, en torsion et en traction/compression - NFREQ_f=0; - NFREQ_t=0; - NFREQ_l=0; - - nbF_f=[]; - nbF_t=[]; - nbF_l=[]; - lflex={}; - ltors={}; - llong={}; - - NBV=len(L_MODES); - - Ntot =Numeric.zeros((NFREQ),Numeric.Float); - Nflex=Numeric.zeros((NFREQ),Numeric.Float); - Ntors=Numeric.zeros((NFREQ),Numeric.Float); - Nlong=Numeric.zeros((NFREQ),Numeric.Float); - - RESULT=[]; - - NBV=len(L_MODES); - NOEU=len(L_GR_NOEUD); - MODEf=[0]*NBV ; - MODEt=[0]*NBV ; - MODEl=[0]*NBV ; - NVT =Numeric.zeros((NFREQ, NBV),Numeric.Float); - - for ii in range(NBV): - chaine='\n' - aster.affiche('RESULTAT', chaine) - chaine = 'Vitesse de rotation : %15.5E' %VITE_ROTA[ii] - aster.affiche('RESULTAT', chaine) - chaine='\n' - aster.affiche('RESULTAT', chaine) - #IMPR_RESU( - #FORMAT='RESULTAT', - # RESU=_F(RESULTAT=L_MODES[ii],NOM_PARA=('NUME_MODE','FREQ','OMEGA2'),FORM_TABL='OUI'), - # ) - - # ------------------------------------------------------------------- - # Extraire les modes en module, definir les differents types de modes - # ------------------------------------------------------------------- - - tabmoN=POST_RELEVE_T(ACTION=_F(INTITULE='MODES_MODULE', - NOEUD=L_GR_NOEUD, - RESULTAT=L_MODES[ii], - NOM_CHAM='DEPL', - TOUT_ORDRE='OUI', - NOM_CMP=('DX','DY','DZ', 'DRX', 'DRY', 'DRZ'), - FORMAT_C='MODULE', - OPERATION='EXTRACTION',),); - - #IMPR_TABLE(TABLE=tabmoN); - - chaine='\n' - aster.affiche('RESULTAT', chaine) - chaine='Rapport de type de modes' - aster.affiche('RESULTAT', chaine) - chaine='Flexion Torsion Traction/compression' - aster.affiche('RESULTAT', chaine) - #for jj in range(NFREQ): - jj =0; - - for jj in range(NFREQ): - Ntot[jj] =0.0 - Nflex[jj] =0.0 - Ntors[jj] =0.0 - Nlong[jj] =0.0 - for ll in range(NOEU): - nmod=NOEU*jj+ll - dx = tabmoN['DX' ,nmod+1] - dy = tabmoN['DY' ,nmod+1] - dz = tabmoN['DZ' ,nmod+1] - drx = tabmoN['DRX',nmod+1] - dry = tabmoN['DRY',nmod+1] - drz = tabmoN['DRZ',nmod+1] - Ntot1 = dx**2+dy**2+dz**2+drx**2+dry**2+drz**2 - Nflex1 = dy**2+dz**2+dry**2+drz**2 - Ntors1 = drx**2 - Nlong1 = dx**2 - Ntot[jj] = Ntot[jj] + Ntot1 - Nflex[jj] = Nflex[jj] + Nflex1 - Ntors[jj] = Ntors[jj] + Ntors1 - Nlong[jj] = Nlong[jj] + Nlong1 - Ntot[jj] = Numeric.sqrt(Ntot[jj]) - Nflex[jj] = Numeric.sqrt(Nflex[jj])/ Ntot[jj] - Ntors[jj] = Numeric.sqrt(Ntors[jj])/ Ntot[jj] - Nlong[jj] = Numeric.sqrt(Nlong[jj])/ Ntot[jj] - #print Nflex[jj],Ntors[jj],Nlong - chaine = '%15.5E %15.5E %15.5E' %(Nflex[jj],Ntors[jj],Nlong[jj]) - aster.affiche('RESULTAT', chaine) - - DETRUIRE(CONCEPT=_F(NOM=(tabmoN)),INFO=1) - - jf=0; - jt=0; - jl=0; - - for jj in range(NFREQ): - NVT[jj][ii]=jj+1; - if (Nflex[jj]> Ntors[jj]) and (Nflex[jj]> Nlong[jj]): - #print "ii jf jj" - lflex[(ii,jf)]=jj+1; - #print ii, jf, jj - #print lflex - jf=jf+1; - - - elif (Ntors[jj]> Nflex[jj]) and (Ntors[jj]> Nlong[jj]): - ltors[(ii,jt)]=jj+1; - jt=jt+1; - - - elif (Nlong[jj]> Nflex[jj]) and (Nlong[jj]> Ntors[jj]): - llong[(ii,jl)]=jj+1; - jl=jl+1; - - nbF_f.append(jf); - nbF_t.append(jt); - nbF_l.append(jl); - - NFREQ_f = min(nbF_f) - NFREQ_t = min(nbF_t) - NFREQ_l = min(nbF_l) - - if NFREQ_f>0: - NVT_f =Numeric.zeros((NFREQ_f, NBV),Numeric.Int); - l_f =Numeric.zeros((NBV, NFREQ_f),Numeric.Int); - if NFREQ_t>0: - NVT_t =Numeric.zeros((NFREQ_t, NBV),Numeric.Int); - l_t =Numeric.zeros((NBV, NFREQ_t),Numeric.Int); - if NFREQ_l>0: - NVT_l =Numeric.zeros((NFREQ_l, NBV),Numeric.Int); - l_l =Numeric.zeros((NBV, NFREQ_l),Numeric.Int); - else: - NVT_l = 0; - - for ii in range(NBV): - for jj in range(NFREQ_f): - NVT_f[jj][ii]=lflex[ii,jj]; - l_f[ii][jj] =lflex[ii,jj]; - - for jj in range(NFREQ_t): - NVT_t[jj][ii]=ltors[ii,jj]; - l_t[ii][jj] =ltors[ii,jj]; - - for jj in range(NFREQ_l): - NVT_l[jj][ii]=llong[ii,jj]; - l_l[ii][jj] =llong[ii,jj]; - - for ii in range(NBV): - # ---------------------------------------------- - # Extraire la base des modes en flexion - # ---------------------------------------------- - if NFREQ_f >0: - lmodef =list(l_f[ii]); - #print 'lmodef' - #print lmodef - - MODEf[ii] = EXTR_MODE ( FILTRE_MODE = _F ( MODE = L_MODES[ii], - NUME_MODE = lmodef) - ); - - MODEf[ii]= NORM_MODE (MODE=MODEf[ii], - reuse = MODEf[ii], - NORME='TRAN', - ); - #IMPR_RESU( - # FORMAT='RESULTAT', - # RESU=_F(RESULTAT=MODEf[ii],NOM_PARA=('NUME_MODE','FREQ'),FORM_TABL='OUI'), - # ) - # ---------------------------------------------- - # Extraire la base des modes en torsion - # ---------------------------------------------- - if NFREQ_t >0: - lmodet =list(l_t[ii]); - #print 'lmodet' - #print lmodet - MODEt[ii] = EXTR_MODE ( FILTRE_MODE = _F ( MODE = L_MODES[ii], - NUME_MODE = lmodet) - ); - MODEt[ii]= NORM_MODE (MODE=MODEt[ii], - reuse = MODEt[ii], - AVEC_CMP=('DRX','DRY', 'DRZ'), - ); - #IMPR_RESU( - # FORMAT='RESULTAT', - # RESU=_F(RESULTAT=MODEt[ii],NOM_PARA=('NUME_MODE','FREQ'),FORM_TABL='OUI'), - # ) - # ---------------------------------------------- - # Extraire la base des modes en longi - # ---------------------------------------------- - if NFREQ_l >0: - lmodel =list(l_l[ii]); - #print 'lmodel' - #print lmodel - MODEl[ii] = EXTR_MODE ( FILTRE_MODE = _F ( MODE = L_MODES[ii], - NUME_MODE = lmodel) - ); - - MODEl[ii]= NORM_MODE (MODE=MODEl[ii], - reuse = MODEl[ii], - NORME='TRAN', - ); - #IMPR_RESU( - # FORMAT='RESULTAT', - # RESU=_F(RESULTAT=MODEl[ii],NOM_PARA=('NUME_MODE','FREQ'),FORM_TABL='OUI'), - # ) - - - # ----------------------------------------------------------- - # Nombre de frequences par type pour le diagramme de Campbell - # ----------------------------------------------------------- - NFREQ_fc=0; - for jj in range(NFREQ_f): - if NVT_f[jj][NBV-1]<= NFREQ_camp: - NFREQ_fc=NFREQ_fc+1; - - NFREQ_tc=0; - for jj in range(NFREQ_t): - if NVT_t[jj][NBV-1]<= NFREQ_camp: - NFREQ_tc=NFREQ_tc+1; - - NFREQ_lc=0; - for jj in range(NFREQ_l): - if NVT_l[jj][NBV-1]<= NFREQ_camp: - NFREQ_lc=NFREQ_lc+1; - - - - RESULT =[NFREQ_f,NFREQ_t,NFREQ_l,MODEf,MODEt,MODEl,NVT,NVT_f,NVT_t,NVT_l,NFREQ_fc,NFREQ_tc,NFREQ_lc] - - - - return RESULT - - -#------------------------------------------------------------------------------------------------ -def EXTR_FREQ(self,L_MODES, L_MODEf,L_MODEt,L_MODEl, NFREQ, NFREQ_f, NFREQ_t, NFREQ_l) : -#Extraire les frequences - - RECU_TABLE =self.get_cmd('RECU_TABLE') - IMPR_TABLE =self.get_cmd('IMPR_TABLE') - DETRUIRE =self.get_cmd('DETRUIRE') - - - RESULT=[]; - - NBV =len(L_MODES); - FRQ =Numeric.zeros((NFREQ,NBV),Numeric.Float); - FRQ_f =Numeric.zeros((NFREQ_f,NBV),Numeric.Float); - FRQ_t =Numeric.zeros((NFREQ_t,NBV),Numeric.Float); - FRQ_l =Numeric.zeros((NFREQ_l,NBV),Numeric.Float); - AMO_f =Numeric.zeros((NFREQ_f,NBV),Numeric.Float); - FRQ_max = 0.0; - EPSI =1.E-10; - for ii in range(NBV): - - # frequences totales - tabfreq = RECU_TABLE(CO=L_MODES[ii],NOM_PARA=('NUME_MODE','FREQ','AMOR_REDUIT'),); - IMPR_TABLE(TABLE=tabfreq); - - for jj in range(NFREQ): - FRQ[jj][ii]=tabfreq['FREQ',jj+1] - if FRQ_max < FRQ[jj][ii]: - FRQ_max=FRQ[jj][ii]; - - if NFREQ_f>0: - # frequences des modes en flexion - tabfr_f = RECU_TABLE(CO=L_MODEf[ii],NOM_PARA=('FREQ','AMOR_REDUIT'),) - IMPR_TABLE(TABLE=tabfr_f); - for jj in range(NFREQ_f): - FRQ_f[jj][ii]=tabfr_f['FREQ',jj+1]; - AMO_f[jj][ii]=tabfr_f['AMOR_REDUIT',jj+1]; - if abs(AMO_f[jj][ii])0: - # frequences des modes en torsion - tabfr_t = RECU_TABLE(CO=L_MODEt[ii],NOM_PARA='FREQ',) - #IMPR_TABLE(TABLE=tabfr_t); - for jj in range(NFREQ_t): - FRQ_t[jj][ii]=tabfr_t['FREQ',jj+1] - - DETRUIRE(CONCEPT=_F(NOM=(tabfr_t)),INFO=1) - - if NFREQ_l>0: - # frequences des modes en traction / compression - tabfr_l = RECU_TABLE(CO=L_MODEl[ii],NOM_PARA='FREQ',) - #IMPR_TABLE(TABLE=tabfr_l); - for jj in range(NFREQ_l): - FRQ_l[jj][ii]=tabfr_l['FREQ',jj+1] - - DETRUIRE(CONCEPT=_F(NOM=(tabfr_l)),INFO=1) - - DETRUIRE(CONCEPT=_F(NOM=(tabfreq)),INFO=1) - - - RESULT = [FRQ,FRQ_f,FRQ_t, FRQ_l, FRQ_max, AMO_f]; - return RESULT - - -#------------------------------------------------------------------------------------------------ - -def TRI_MODE_MACf(self, MACf,NFREQ_f, NVT_f, IV) : -#Tri des frequences par calcul des coefficients MAC - - - DETRUIRE =self.get_cmd('DETRUIRE') - - # base mode 1 - tmacf =Numeric.zeros((NFREQ_f,NFREQ_f),Numeric.Float); - #chaine='MAC1111' - #aster.affiche('RESULTAT', chaine) - #chaine=str(IV); - #aster.affiche('RESULTAT', chaine) - #IMPR_TABLE(TABLE=MACf) - for jj in range(NFREQ_f): - # base mode 2 - for ll in range(NFREQ_f): - nmac= NFREQ_f*jj+ll - #print nmac - tmacf[jj][ll]=MACf['MAC',nmac+1] - chaine='Modes de flexion' - aster.affiche('RESULTAT', chaine) - affiche_tab(tmacf,NFREQ_f, NFREQ_f); - - for j2 in range(NFREQ_f): - XMAX=0.0 - JREC=int(NVT_f[j2][IV+1]-1); - #print "JREC" - #print JREC - for j1 in range(NFREQ_f): - - #print tmacf[j1][JREC] - #print XMAX - if tmacf[j1][JREC] > XMAX: - XMAX=tmacf[j1][JREC] - I1B=j1+1 - #chaine='XMAX ' + str(XMAX)+ ' I1B ' + str(I1B); - #aster.affiche('RESULTAT', chaine) - # test d'existance de I1B dans le tableau de connexion - I1B_exist =0; - for jj in range(j2): - if I1B == NVT_f[jj][IV]: - I1B_exist =1; - if I1B_exist ==0: # IB1 n'existe pas - NVT_f[j2][IV]= I1B; - else: - NVT_f[j2][IV]=0; - DETRUIRE(CONCEPT=_F(NOM=(MACf)),INFO=1); - - return NVT_f - -#------------------------------------------------------------------------------------------------ - -def TRI_MODE_MACt(self, MACt,NFREQ_t, NVT_t, IV) : -#Tri des frequences par calcul des coefficients MAC - - - DETRUIRE =self.get_cmd('DETRUIRE') - - # base mode 1 - tmact =Numeric.zeros((NFREQ_t,NFREQ_t),Numeric.Float); - #chaine='TRI_MODE_MACt' - #aster.affiche('RESULTAT', chaine) - #chaine=str(IV); - #aster.affiche('RESULTAT', chaine) - #IMPR_TABLE(TABLE=MACt) - for jj in range(NFREQ_t): - # base mode 2 - for ll in range(NFREQ_t): - nmac= NFREQ_t*jj+ll - #print nmac - tmact[jj][ll]=MACt['MAC',nmac+1] - chaine='Modes en torsion' - aster.affiche('RESULTAT', chaine) - affiche_tab(tmact,NFREQ_t, NFREQ_t); - - for j2 in range(NFREQ_t): - XMAX=0.0 - JREC=int(NVT_t[j2][IV+1]-1); - #print "JREC" - #print JREC - for j1 in range(NFREQ_t): - - #print tmact[j1][JREC] - #print XMAX - if tmact[j1][JREC] > XMAX: - XMAX=tmact[j1][JREC] - I1B=j1+1 - #NVT_t[j2][IV]= I1B - # test d'existance de I1B dans le tableau de connexion - I1B_exist =0; - for jj in range(j2): - if I1B == NVT_t[jj][IV]: - I1B_exist =1; # IB1 existe deja - if I1B_exist ==0: # IB1 n'existe pas - NVT_t[j2][IV]= I1B; - else: - NVT_t[j2][IV]=0; - - DETRUIRE(CONCEPT=_F(NOM=(MACt)),INFO=1); - - return NVT_t - -#------------------------------------------------------------------------------------------------ - -def TRI_MODE_MACl(self, MACl,NFREQ_l, NVT_l, IV) : -#Tri des frequences par calcul des coefficients MAC - - - DETRUIRE =self.get_cmd('DETRUIRE') - - # base mode 1 - tmacl =Numeric.zeros((NFREQ_l,NFREQ_l),Numeric.Float); - #chaine='TRI_MODE_MACl' - #aster.affiche('RESULTAT', chaine) - #chaine=str(IV); - #aster.affiche('RESULTAT', chaine) - #IMPR_TABLE(TABLE=MACl) - for jj in range(NFREQ_l): - # base mode 2 - for ll in range(NFREQ_l): - nmac= NFREQ_l*jj+ll - #print nmac - tmacl[jj][ll]=MACl['MAC',nmac+1] - chaine='Modes en traction/compression' - aster.affiche('RESULTAT', chaine) - affiche_tab(tmacl,NFREQ_l, NFREQ_l); - - for j2 in range(NFREQ_l): - XMAX=0.0 - JREC=int(NVT_l[j2][IV+1]-1); - #print "JREC" - #print JREC - for j1 in range(NFREQ_l): - - #print tmacl[j1][JREC] - #print XMAX - if tmacl[j1][JREC] > XMAX: - XMAX=tmacl[j1][JREC] - I1B=j1+1 - #NVT_l[j2][IV]= I1B - # test d'existance de I1B dans le tableau de connexion - I1B_exist =0; - for jj in range(j2): - if I1B == NVT_l[jj][IV]: - I1B_exist =1; # IB1 existe deja - if I1B_exist ==0: # IB1 n'existe pas - NVT_l[j2][IV]= I1B; - else: - NVT_l[j2][IV]=0; - - DETRUIRE(CONCEPT=_F(NOM=(MACl)),INFO=1); - - return NVT_l - - -#------------------------------------------------------------------------------------------------ - -def CALC_MACf(self, L_MODEf, NFREQ_f) : -#Calcul de la matrice MAC entre les deux bases successives - - MAC_MODES =self.get_cmd('MAC_MODES') - - NBV=len(L_MODEf); - tmacf =Numeric.zeros((NFREQ_f,NFREQ_f),Numeric.Float); - MACf=[0]*NBV - - for ii in range(NBV-1): - if NFREQ_f>0: - MACf[ii]=MAC_MODES(BASE_1=L_MODEf[ii], - BASE_2=L_MODEf[ii+1], - INFO =2, - ); - #IMPR_TABLE(TABLE=MACf[ii]) - - return MACf - - -#------------------------------------------------------------------------------------------------ - -def CALC_MACt(self, L_MODEt, NFREQ_t) : -#Calcul de la matrice MAC entre les deux bases successives - - MAC_MODES =self.get_cmd('MAC_MODES') - - NBV=len(L_MODEt); - tmact =Numeric.zeros((NFREQ_t,NFREQ_t),Numeric.Float); - MACt=[0]*NBV - - for ii in range(NBV-1): - if NFREQ_t>0: - MACt[ii]=MAC_MODES(BASE_1=L_MODEt[ii], - BASE_2=L_MODEt[ii+1], - INFO =2, - ); - #IMPR_TABLE(TABLE=MACt[ii]) - - return MACt - -#----------------------------------------------------------------------------------------------- - -def CALC_MACl(self, L_MODEl, NFREQ_l) : -#Calcul de la matrice MAC entre les deux bases successives - - MAC_MODES =self.get_cmd('MAC_MODES') - - NBV=len(L_MODEl); - tmacl =Numeric.zeros((NFREQ_l,NFREQ_l),Numeric.Float); - MACl=[0]*NBV - - for ii in range(NBV-1): - if NFREQ_l>0: - MACl[ii]=MAC_MODES(BASE_1=L_MODEl[ii], - BASE_2=L_MODEl[ii+1], - INFO =2, - ); - #IMPR_TABLE(TABLE=MACl[ii]) - - return MACl - -#----------------------------------------------------------------------------------------------- - -def CALC_PREC(self,MODEf,NFREQ_f,L_GR_NOEUD, typ_prec) : -#Calcul le sens de precession pour un mode a une vitesse de rotation donnee -#Type de precession, 1 somme, 2 grande orbite - - - POST_RELEVE_T =self.get_cmd('POST_RELEVE_T') - DETRUIRE =self.get_cmd('DETRUIRE') - - XSMIN=1e-2; - NBV=len(MODEf); - NOEU=len(L_GR_NOEUD); - SENS=Numeric.zeros((NFREQ_f, NBV),Numeric.Float); - for ii in range(NBV): - # ------------------------------------------------------------------------- - # Extraire les parties reelles, imaginaires et modules des modes en flexion - # ------------------------------------------------------------------------- - - tabmoR_f=POST_RELEVE_T(ACTION=_F(INTITULE='MODES_REEL', - #GROUP_NO=L_GR_NOEUD, - NOEUD=L_GR_NOEUD, - RESULTAT=MODEf[ii], - NOM_CHAM='DEPL', - TOUT_ORDRE='OUI', - NOM_CMP=('DX','DY','DZ'), - FORMAT_C='REEL', - OPERATION='EXTRACTION',),); - tabmoI_f=POST_RELEVE_T(ACTION=_F(INTITULE='MODES_IMAG', - #GROUP_NO=L_GR_NOEUD, - NOEUD=L_GR_NOEUD, - RESULTAT=MODEf[ii], - NOM_CHAM='DEPL', - TOUT_ORDRE='OUI', - NOM_CMP=('DX','DY','DZ'), - FORMAT_C='IMAG', - OPERATION='EXTRACTION',),); - tabmoN_f=POST_RELEVE_T(ACTION=_F(INTITULE='MODES_MODULE', - #GROUP_NO=L_GR_NOEUD, - NOEUD=L_GR_NOEUD, - RESULTAT=MODEf[ii], - NOM_CHAM='DEPL', - TOUT_ORDRE='OUI', - NOM_CMP=('DX','DY','DZ'), - FORMAT_C='MODULE', - OPERATION='EXTRACTION',),); - - #IMPR_TABLE(TABLE=tabmoR_f); - #IMPR_TABLE(TABLE=tabmoI_f); - #IMPR_TABLE(TABLE=tabmoN_f); - - for jj in range(NFREQ_f): - #Sens de precesion pour un mode a une vitesse donne - modul1 =0.0; - sens1 =0.0; - for ll in range(NOEU): - nmod=NOEU*jj+ll - dy_r = tabmoR_f['DY' ,nmod+1]; - dz_r = tabmoR_f['DZ' ,nmod+1]; - dy_i = tabmoI_f['DY' ,nmod+1]; - dz_i = tabmoI_f['DZ' ,nmod+1]; - dy_m = tabmoN_f['DY' ,nmod+1]; - dz_m = tabmoN_f['DZ' ,nmod+1]; - - if typ_prec == 1 : - #Sens parcours pour un noeud - preces = dy_r*dz_i-dy_i*dz_r ; - #Sens de precession dominant dans une mode - if preces >0: - sens1=sens1+ dy_m + dz_m; - elif preces <0: - sens1=sens1- dy_m - dz_m; - else: - #Sens de precession associe au plus grand orbite - if (dy_m + dz_m) >modul1: - # demi diagonale - modul1= Numeric.sqrt(dy_m*dy_m + dz_m*dy_m); - preces = dy_r*dz_i-dy_i*dz_r ; - if preces >0: - sens1=modul1; - elif preces <0: - sens1=-modul1; - - XS=abs(sens1); - if XS>XSMIN: - SENS[jj][ii]=sens1/XS; - else: - SENS[jj][ii]=0.0; - - DETRUIRE(CONCEPT=_F(NOM=(tabmoR_f, tabmoI_f, tabmoN_f)),INFO=1) - - return SENS - -#------------------------------------------------------------------------------------------------ - -def TRI_MODE_PREC (SENS,NFREQ_f, NVT_f, NBV, OMIN) : -#Tri des modes par une methode de proche en proche avec verification du sens de precession - # base mode 1 - chaine='TRI_MODE_PREC' - aster.affiche('RESULTAT', chaine) - - ND=0 - NI=0 - NBV1 = NBV-1 - for jj in range(NFREQ_f): - jf=NFREQ_f-jj-1; - #chaine='jf ' + str(jf); - #aster.affiche('RESULTAT', chaine) - if SENS[jf][NBV-1]>0.: - ND=ND+1; - for nb in range(NBV1): - nbd=NBV1-nb-1; - #chaine='\n' - #aster.affiche('RESULTAT', chaine) - #chaine='Directe nb ' + str(nb) + ' nbd ' + str(nbd); - #aster.affiche('RESULTAT', chaine) - NID=0; - for ii in range(NFREQ_f): - ifr=NFREQ_f-ii-1; - if SENS[ifr][nbd]>0.5: - NID=NID+1; - if NID==ND: - NVT_f[jf][nbd]=int(ifr+1); - #chaine='ifr ' + str(ifr) + ' NID ' + str(NID)+ ' ND ' + str(ND); - #aster.affiche('RESULTAT', chaine) - #chaine='jf ' + str(jf) + ' nbd ' + str(nbd)+ ' NVT_f ' + str(NVT_f[jf][nbd]); - #aster.affiche('RESULTAT', chaine) - break; - - else : - NI=NI+1 - for nb in range(NBV1): - nbi=NBV1-nb-1; - #chaine='\n' - #aster.affiche('RESULTAT', chaine) - #chaine='Inverse nb ' + str(nb) + ' nbi ' + str(nbi); - #aster.affiche('RESULTAT', chaine) - NIV=0; - for ii in range(NFREQ_f): - ifr=NFREQ_f-ii-1; - if SENS[ifr][nbi]<-0.5: - NIV=NIV+1; - if NIV==NI: - NVT_f[jf][nbi]=int(ifr+1); - #chaine='ifr ' + str(ifr) + ' NIV ' + str(NIV)+ ' NI ' + str(NI); - #aster.affiche('RESULTAT', chaine) - #chaine='jf ' + str(jf) + ' nbi ' + str(nbi)+ ' NVT_f ' + str(NVT_f[jf][nbi]); - #aster.affiche('RESULTAT', chaine) - break; - if(OMIN==0) : - for ii in range(NFREQ_f): - NVT_f[ii][0]=NVT_f[ii][1] - - chaine='Tableau de connexion des Modes de flexion' - aster.affiche('RESULTAT', chaine) - affiche_tabint(NVT_f,NFREQ_f,NBV); - - return NVT_f - -#---------------------------------------------------------------------------------------- - -def TRI_MODE_PREC_DI (SENS,NFREQ_f, NVT_f, NBV, OMIN) : -#Tri des modes par une methode de proche en proche avec verification du sens de precession - # base mode 1 - chaine='TRI_MODE_PREC_DI' - aster.affiche('RESULTAT', chaine) - - NVT_fdir =Numeric.zeros((NFREQ_f, NBV),Numeric.Float); - NVT_finv =Numeric.zeros((NFREQ_f, NBV),Numeric.Float); - nb_prec_dir =NFREQ_f; - nb_prec_inv =NFREQ_f; - for nb in range(NBV): - nbv1=NBV-nb-1; - jd=0; - ji=0; - for jj in range(NFREQ_f): - if SENS[jj][nbv1]>0.: - NVT_fdir[jd][nbv1]=jj+1; - jd=jd+1; - elif SENS[jj][nbv1]<0.: - NVT_finv[ji][nbv1]=jj+1; - ji=ji+1; - # Calcul de nombre minimum de precession directe pour les vitesses - # Calcul de nombre minimum de precession inverse pour les vitesses - - if jd>0: - if nb_prec_dir >jd: - nb_prec_dir =jd; - if ji>0: - if nb_prec_inv >ji: - nb_prec_inv= ji; - - if(OMIN==0) : - for ii in range(NFREQ_f): - NVT_fdir[ii][0]=NVT_fdir[ii][1] - NVT_finv[ii][0]=NVT_finv[ii][1] - - chaine='nb_prev_dir ' + str(nb_prec_dir); - aster.affiche('RESULTAT', chaine) - chaine='Tableau de connexion des Modes de flexion precession directe' - aster.affiche('RESULTAT', chaine) - affiche_tabint(NVT_fdir,NFREQ_f, NBV); - - chaine='nb_prev_inv ' + str(nb_prec_inv); - aster.affiche('RESULTAT', chaine) - chaine='Tableau de connexion des Modes de flexion precession inverse' - aster.affiche('RESULTAT', chaine) - affiche_tabint(NVT_finv,NFREQ_f, NBV); - - # Rassembler les tableaux de connexion - NVTf_prec =Numeric.zeros((NFREQ_f, NBV),Numeric.Int); - for jj in range(NFREQ_f): - jf=0; - jf=int(NVT_fdir[jj][NBV-1]); - if jf>0: - for iv in range(NBV): - NVTf_prec[jf-1][iv]= NVT_fdir[jj][iv]; - jf=0; - jf=int(NVT_finv[jj][NBV-1]); - if jf>0: - for iv in range(NBV): - NVTf_prec[jf-1][iv]= NVT_finv[jj][iv]; - - chaine='\n' - aster.affiche('RESULTAT', chaine) - chaine='NVTf_prec' - aster.affiche('RESULTAT', chaine) - affiche_tabint(NVTf_prec,NFREQ_f, NBV); - - RESULT = [nb_prec_dir,nb_prec_inv, NVTf_prec]; - - return RESULT - - -#---------------------------------------------------------------------------------------- -def affiche_tab(tab1,nbligne, nbcol) : -# affiche un taleau tab1 de nbligne lignes et nbcol colonnes - for jj in range(nbligne): - chaine='' - for ii in range(nbcol): - str1 = '%15.5E' %tab1[jj][ii] - chaine=chaine + ' '+ str1 - aster.affiche('RESULTAT', chaine) - -#---------------------------------------------------------------------------------------- - -def affiche_tabint(tab1,nbligne, nbcol) : -# affiche un taleau tab1 de nbligne lignes et nbcol colonnes - for jj in range(nbligne): - chaine='' - for ii in range(nbcol): - str1 = '%5d' %tab1[jj][ii] - chaine=chaine + ' '+ str1 - aster.affiche('RESULTAT', chaine) - -#---------------------------------------------------------------------------------------- - -def calc_pas(xmin, xmax) : -# calcul de l'echelle valeurs mini-maxi et le pas -# On impose entre 5 et 10 intervalles -# En entree xmin, xmax valeurs mini-maxi, xmin et xmax superieurs ou egaux a zero -# En sortie VAL1, VAL2 et PAS valeurs mini-maxi de l'echelle et le pas - diff=xmax-xmin; - PAS=1.; - VAL1=0.; - C10=10.; - - # diff < 5. - while diff<5.: - diff=diff*C10; - PAS = PAS/C10; - - # diff > 50. - while diff<50.: - diff=diff/C10; - PAS = PAS*C10; - - # 5 <= diff <= 50. - N=int(diff); - if N>=11 and N<=20 : - N=N/2; - PAS=PAS*2.; - elif N>=21 and N<=30 : - N=N/3; - PAS=PAS*3.; - elif N>=31 and N<=40 : - N=N/4; - PAS=PAS*4.; - elif N>=41 and N<=50 : - N=N/5; - PAS=PAS*5.; - - # Calcul des valeurs mini-maxi de l'echelle - while abs(xmin-VAL1)>PAS: - VAL1=VAL1 + PAS; - - VAL2=VAL1 + (N*PAS); - while VAL2 <= xmax: - VAL2=VAL2 + PAS; - - RESULT=[VAL1, VAL2, PAS]; - - return RESULT - -#---------------------------------------------------------------------------------------- - -def color_camp(sens, amortis) : -# determine la couleur et le style du trait -# en entree le sens de precession -# en sortir la couleur, le style du trait ICS IST et le maqueur -# DIRECTE,STABLE vert -# DIRECTE,INSTABLE rouge -# INDIRECTE,STABLE bleu -# INDIRECTE,INSTABLE magenta - - if sens<0: # precession inverse - if amortis<0: # instable - ICS = 10; # magenta - IST = 4; # tiret - IMA = 9; # croix - else: # stable - ICS = 4; # bleu - IST = 4; # tiret - IMA = 0; - else: # precession directe - if amortis<0: # instable - ICS = 2; # rouge - IST = 1; # trait continu - IMA = 8; # plus - else: # stable - ICS = 3; # vert - IST = 1; # trait continu - IMA = 0; - RESULT= [ICS,IST,IMA]; - - return RESULT - -#---------------------------------------------------------------------------------------- -def sup_redon_list(LS): -# Supprimer la redondace dans une liste de reel - LS.sort(); - ii=0 - len_list=len(LS); - while ii < len_list-1: - icount = LS.count(LS[ii]); - if icount >1: - for jj in range(ii+icount-1, ii,-1): - LS.pop(jj); - ii=ii+1 - len_list=len(LS); - -#------------------------------------------------------------------------------------------ -def save_intersec(L_INTER, FINT): -# Sauvegarde dans un fichier les points d'intersection des courbes du diagramme de Campbell -# avec les droites de pente S - chaine='\n' - FINT.write(chaine) - chaine='Points d'' intersection avec les droites Y=SX' - FINT.write(chaine) - for ii in range(len(L_INTER)): - chaine='\n' - FINT.write(chaine) - chaine = 'S = %10.2F' %L_INTER[ii]["pente"] - FINT.write(chaine) - chaine='\n' - FINT.write(chaine) - L_POINT = L_INTER[ii]["point"] - for jj in range(len(L_POINT)): - chaine = 'Vitesse = %10.2F tr/mn' %L_POINT[jj][0] - FINT.write(chaine) - FINT.write('\n') - chaine = 'Frequence = %10.2F HZ' %L_POINT[jj][1] - FINT.write(chaine) - FINT.write('\n') - - chaine='----------------------------' - FINT.write(chaine) - chaine='\n' - chaine=' ' - -#------------------------------------------------------------------------------------------ - - -def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PREC, TYP_TRI, +def impr_diag_campbell_ops(self, MAILLAGE, MODES, NFREQ_camp, TYP_PREC, TYP_TRI, UNIT_FLE, UNIT_TOR, UNIT_LON, UNIT_TOT, UNIT_INT,L_S, **args) : # Macro permettant de tracer le diagramme de Campbell suivant # le type de suivi des modes et le type de calcul de la precession #Type de suivi, 0 SANS_TRI, 1 TRI_PREC, 2 TRI_FORM_MOD #Type de precession, 1 somme, 2 grande orbite + import numpy + from math import pi + import aster + from Accas import _F + from Noyau.N_types import is_float + + from Macro.impr_diag_campbell_utils import ( + CLASS_MODES, EXTR_FREQ, TRI_MODE_MACf, TRI_MODE_MACt, TRI_MODE_MACl, CALC_MACf, + CALC_MACt, CALC_MACl, CALC_PREC, TRI_MODE_PREC_DI, affiche_tab, affiche_tabint, + calc_pas, color_camp, sup_redon_list, sup_redon_listv, save_intersec + ) + # On importe les definitions des commandes a utiliser dans la macro @@ -956,30 +50,63 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE MAC_MODES =self.get_cmd('MAC_MODES') DEFI_LIST_REEL =self.get_cmd('DEFI_LIST_REEL') DEFI_FONCTION =self.get_cmd('DEFI_FONCTION') + EXTR_TABLE =self.get_cmd('EXTR_TABLE') IMPR_FONCTION =self.get_cmd('IMPR_FONCTION') IMPR_RESU =self.get_cmd('IMPR_RESU') + IMPR_TABLE =self.get_cmd('IMPR_TABLE') DEFI_FICHIER =self.get_cmd('DEFI_FICHIER') DETRUIRE =self.get_cmd('DETRUIRE') + # La macro compte pour 1 dans la numerotation des commandes self.set_icmd(1) - L_VIT1=[]; - + + lvit=[None] + # Extraire les vitesses de rotation + nb_temp=0 + while 1 : + try: + print 'nb_temp', nb_temp + lvit[nb_temp] = MODES['VITE_ROTA' ,nb_temp+1]; + nb_temp=nb_temp+1; + lvit.append([None]); + except KeyError: + break + + VITE_ROTA = lvit[0:nb_temp]; + num_vit_tri=sup_redon_listv(VITE_ROTA); + # Recupere les modes suivant l'ordre de la liste des vitesses de rotation + nbV1=len(VITE_ROTA); + lmo=[None]*nbV1 + for ii in range(0,nbV1): + itri = num_vit_tri[ii]; + lmo[ii]=EXTR_TABLE(TYPE_RESU='MODE_MECA', + TABLE=MODES, + NOM_PARA='NOM_SD', + FILTRE=_F(NOM_PARA='NUME_VITE',VALE_I=itri),); + + L_VIT1=[]; + if type(VITE_ROTA)==list: L_VIT1=VITE_ROTA; elif type(VITE_ROTA)==tuple: L_VIT1=list(VITE_ROTA); - elif type(VITE_ROTA)==float: + elif is_float(VITE_ROTA): L_VIT1.append(VITE_ROTA); - # Supprimer la redondance dans la liste - sup_redon_list(L_VIT1); - - nbV=len(L_VIT1); + chaine='\n' + aster.affiche('RESULTAT', chaine) + chaine='Liste triee des vitesses en rad/s' + aster.affiche('RESULTAT', chaine) + for ii in range(nbV): + chaine= '%15.5E' %L_VIT1[ii]; + aster.affiche('RESULTAT', chaine) + + #------------------------------------------------------------------------- # Tester le nombre de frequences calculees pour chaque vitesse de rotation #------------------------------------------------------------------------- @@ -987,7 +114,7 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE nb_FREQ=[]; for ii in range(nbV): # frequences totales - tabfreq = RECU_TABLE(CO= MODES[ii],NOM_PARA='FREQ',); + tabfreq = RECU_TABLE(CO= lmo[ii],NOM_PARA='FREQ',); tab2=tabfreq.EXTR_TABLE(); tabf=tab2.FREQ; nb_FREQ_prec=nb_FREQ; @@ -1029,32 +156,29 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE # ------------------------------------------------------------------ # Classe les modes en flexion, en torsion , en traction/ compression # ------------------------------------------------------------------ - MODEf=[]; - MODEt=[]; - MODEl=[]; + Mf=[]; + Mt=[]; + Ml=[]; # Recuperer les noeuds du maillage # construction des vecteurs jeveux nom_mail=MAILLAGE.nom - #print 'nom_mail' - #print nom_mail lenm=len(nom_mail) nom_mail=nom_mail+' '*(8-lenm) vectnoeu=nom_mail+'.NOMNOE' - #print vectnoeu L_GR_NOEUD=aster.getvectjev(vectnoeu) NOEU=len(L_GR_NOEUD); - C_MODES=CLASS_MODES(self,MODES,NFREQ,NFREQ_camp,L_GR_NOEUD,L_VIT1); + C_MODES=CLASS_MODES(self,lmo,NFREQ,NFREQ_camp,L_GR_NOEUD,L_VIT1); NFREQ_f=C_MODES[0]; NFREQ_t=C_MODES[1]; NFREQ_l=C_MODES[2]; - MODEf=C_MODES[3]; - MODEt=C_MODES[4]; - MODEl=C_MODES[5]; + Mf=C_MODES[3]; + Mt=C_MODES[4]; + Ml=C_MODES[5]; # Initialisation des tableaux de connexion apres classement # en gardant la numerotation globale des modes @@ -1100,7 +224,7 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE #----------------------- #Extraire les frequences #----------------------- - FREQ=EXTR_FREQ(self,MODES,MODEf,MODEt,MODEl, NFREQ, NFREQ_f, NFREQ_t, NFREQ_l); + FREQ=EXTR_FREQ(self,lmo,Mf,Mt,Ml, NFREQ, NFREQ_f, NFREQ_t, NFREQ_l); FRQ=FREQ[0] FRQf=FREQ[1] FRQt=FREQ[2] @@ -1141,7 +265,7 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE # nouveau numerotation de modes par type de mode # Sans tri if NFREQ_f>0 : - NVTf =Numeric.zeros((NFREQ_f, nbV),Numeric.Int); + NVTf =numpy.zeros((NFREQ_f, nbV), int); for ii in range(nbV): for jj in range(NFREQ_f): NVTf[jj][ii]=jj+1; @@ -1152,7 +276,7 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE affiche_tabint(NVTf,NFREQ_f, nbV); if NFREQ_t>0 : - NVTt =Numeric.zeros((NFREQ_t, nbV),Numeric.Int); + NVTt =numpy.zeros((NFREQ_t, nbV), int); for ii in range(nbV): for jj in range(NFREQ_t): NVTt[jj][ii]=jj+1; @@ -1163,7 +287,7 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE affiche_tabint(NVTt,NFREQ_t, nbV); if NFREQ_l>0 : - NVTl =Numeric.zeros((NFREQ_l, nbV),Numeric.Int); + NVTl =numpy.zeros((NFREQ_l, nbV), int); for ii in range(nbV): for jj in range(NFREQ_l): NVTl[jj][ii]=jj+1; @@ -1183,17 +307,23 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE # Calcul de la matrice MAC entre les bases successives en flexion # ------------------------------------------------------------------ if NFREQ_f>0: - LMACf=CALC_MACf(self, MODEf, NFREQ_f) ; - + LMACf=CALC_MACf(self, Mf, NFREQ_f) ; + chaine='\n' + aster.affiche('RESULTAT', chaine) chaine=' Tri par forme des modes TRI_FORM_MOD' aster.affiche('RESULTAT', chaine) + for ii in range(nbV-1): chaine='\n' - aster.affiche('RESULTAT', chaine) - #IMPR_TABLE(TABLE=LMACf[ii]) + aster.affiche('RESULTAT', chaine) iv=nbV-ii-2 - NVTf_mac=TRI_MODE_MACf(self, LMACf[iv],NFREQ_f, NVTf, iv); + + OMIN = L_VIT1[0]; + if(OMIN==0) : + for ii in range(NFREQ_f): + NVTf_mac[ii][0]=NVTf_mac[ii][1] ; + chaine='\n' aster.affiche('RESULTAT', chaine) chaine='Tableau de connexion en flexion' @@ -1204,17 +334,12 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE # Calcul de la matrice MAC entre les bases successives en torsion # ------------------------------------------------------------------ if NFREQ_t>0: - LMACt=CALC_MACt(self, MODEt, NFREQ_t) ; + LMACt=CALC_MACt(self, Mt, NFREQ_t) ; - #chaine='Matrices MAC' - #aster.affiche('RESULTAT', chaine) for ii in range(nbV-1): chaine='\n' - aster.affiche('RESULTAT', chaine) - #IMPR_TABLE(TABLE=LMACt[ii]) - iv=nbV-ii-2 - #chaine='iv torsion' + str(iv); - #aster.affiche('RESULTAT', chaine) + aster.affiche('RESULTAT', chaine) + iv=nbV-ii-2 NVTt=TRI_MODE_MACt(self, LMACt[iv],NFREQ_t, NVTt, iv); chaine='\n' aster.affiche('RESULTAT', chaine) @@ -1226,17 +351,12 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE # Calcul de la matrice MAC entre les bases successives en traction/compression # ---------------------------------------------------------------------------- if NFREQ_l>0: - LMACl=CALC_MACl(self, MODEl, NFREQ_l) ; + LMACl=CALC_MACl(self, Ml, NFREQ_l) ; - #chaine='Matrices MAC' - #aster.affiche('RESULTAT', chaine) for ii in range(nbV-1): chaine='\n' aster.affiche('RESULTAT', chaine) - #IMPR_TABLE(TABLE=LMACl[ii]) - iv=nbV-ii-2 - #chaine='iv traction/compression' + str(iv); - #aster.affiche('RESULTAT', chaine) + iv=nbV-ii-2 NVTl=TRI_MODE_MACl(self, LMACl[iv],NFREQ_l, NVTl, iv); chaine='\n' aster.affiche('RESULTAT', chaine) @@ -1249,19 +369,14 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE # Calcul le sens de precession pour les modes en flexion a une vitesse de rotation donnee #-------------------------------------------------------------------------- if NFREQ_f>0: - SENS=CALC_PREC(self, MODEf,NFREQ_f,L_GR_NOEUD, TYP_PREC); + SENS=CALC_PREC(self, Mf,NFREQ_f,L_GR_NOEUD, TYP_PREC); chaine='\n' aster.affiche('RESULTAT', chaine) chaine='Sens de precession pour les modes en flexion' aster.affiche('RESULTAT', chaine) affiche_tab(SENS,NFREQ_f, nbV); - # ------------------------------------------------------------------------------------ - # Remplissage de deux tableaux separes de connexion pour precession directe et inverse - # ------------------------------------------------------------------------------------ - #OMIN = L_VIT1[0] - #PREC_DI=TRI_MODE_PREC_DI (SENS,NFREQ_f, NVTf, nbV, OMIN); - + # ------------------------------------------------------------------ # Tri des modes en flexion par une methode de proche en proche # avec verification du sens de precession @@ -1269,9 +384,7 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE # ------------------------------------------------------------------ if TYP_TRI==1 : if NFREQ_f>0: - # Vitesses de rotation rangees par ordre croissant OMIN = L_VIT1[0] - #NVTf=TRI_MODE_PREC (SENS,NFREQ_f, NVTf, nbV, OMIN); PREC_DI=TRI_MODE_PREC_DI (SENS,NFREQ_f, NVTf, nbV, OMIN); nb_prec_dir=PREC_DI[0]; nb_prec_inv=PREC_DI[1]; @@ -1290,7 +403,18 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE for ii in range(nbV): OM[ii] = OM[ii]*30./pi; - #FX=DEFI_LIST_REEL(VALE=L_VIT1); + Vitesse_min = min(OM); + Vitesse_max = max(OM); + + OM_int=[OM[ii] for ii in range(len(OM))]; # pour le calcul des points d'intersection + + legende_x= 'Vitesse (tr/mn)'; + if Vitesse_min<0: + if abs(Vitesse_min) > abs(Vitesse_max): + legende_x= 'Vitesse negative, en abscisse la valeur absolue de la vitesse (tr/mn)'; + for ii in range(nbV): + OM[ii] = abs(OM[ii]); + __FX=DEFI_LIST_REEL(VALE=OM); # Mise en page graphique @@ -1336,6 +460,7 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE BVmax = BV[1]; pasV = BV[2]; + print 'BVmin, BVmax, pasV', BVmin, BVmax, pasV # Calcul des bornes et pas de la grille pour les frequences BF = calc_pas(Fmin, Fmax); BFmin = BF[0]; @@ -1350,7 +475,6 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE TITRE1 = 'Diagramme de Campbell'; TITRE2 = 'Modes en flexion' - #mfac ={} DEFI_FICHIER ( ACTION='ASSOCIER', UNITE=UNIT_FLE,) DEFI_FICHIER ( ACTION='ASSOCIER', UNITE=UNIT_TOR,) DEFI_FICHIER ( ACTION='ASSOCIER', UNITE=UNIT_LON,) @@ -1386,8 +510,6 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE A2=AMOf[jf2][iv+1]; # Vitesses - #OM1=L_VIT1[iv]; - #OM2=L_VIT1[iv+1]; OM1=OM[iv]; OM2=OM[iv+1]; S1=SENS[jf1][iv]; @@ -1406,9 +528,16 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE bb = (F2*OM1 - F1*OM2) / (OM1 -OM2) F4 = aa* OM4 + bb - if (A1 >0) and (A1 < A0): + # OM4 en dehors de OM1, OM2 + if OM4 >=OM2: + OM4=-1; + + if OM4 <=OM1: + OM4=-1; + + if (A1 <0) and (abs(A1) < A0): A1 = 0.0 - if (A2 >0) and (A2 < A0): + if (A2 <0) and (abs(A2) < A0): A2 = 0.0 # Tracer le segment pour chaque intervalle avec le code de couleur et @@ -1435,7 +564,6 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE DICO["LEGENDE"] =''; LFONC.append(DICO); - #DETRUIRE(CONCEPT=_F(NOM=(FX1, FY1, FONC)),INFO=1); DETRUIRE(CONCEPT=_F(NOM=(FX1, FY1)),INFO=1); # 2 cas, Changement de sens de precession @@ -1480,7 +608,7 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE DETRUIRE(CONCEPT=_F(NOM=(FX1, FY1, FX2, FY2)),INFO=1); # 3 cas, de changement de stabilite - elif (OM3 == -1) and (OM4 >= 0): + elif (OM3 == -1) and (OM4 >= 0): FX1=DEFI_LIST_REEL(VALE=[OM1,OM4]); # Premiere partie FY1=DEFI_LIST_REEL(VALE=[F1,F4]); @@ -1522,15 +650,15 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE DETRUIRE(CONCEPT=_F(NOM=(FX1, FY1, FX2, FY2)),INFO=1); # 4 et 5 cas de changement de sens de precession et de stabilite - elif (OM3 >= 0) and (OM4 >= 0): - # 4 eme cas + elif (OM3 >= 0) and (OM4 >= 0): + # 4 eme cas if (OM4 < OM3): FX1=DEFI_LIST_REEL(VALE=[OM1,OM4]); # Premiere partie FY1=DEFI_LIST_REEL(VALE=[F1,F4]); FX2=DEFI_LIST_REEL(VALE=[OM4,OM3]); # Deuxieme partie FY2=DEFI_LIST_REEL(VALE=[F4,F3]); - FX2=DEFI_LIST_REEL(VALE=[OM3,OM2]); # Troisieme partie - FY2=DEFI_LIST_REEL(VALE=[F3,F2]); + FX3=DEFI_LIST_REEL(VALE=[OM3,OM2]); # Troisieme partie + FY3=DEFI_LIST_REEL(VALE=[F3,F2]); CS1=color_camp(S1,A1); ICS1=CS1[0]; IST1=CS1[1]; @@ -1588,8 +716,8 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE FY1=DEFI_LIST_REEL(VALE=[F1,F3]); FX2=DEFI_LIST_REEL(VALE=[OM3,OM4]); # Deuxieme partie FY2=DEFI_LIST_REEL(VALE=[F3,F4]); - FX2=DEFI_LIST_REEL(VALE=[OM4,OM2]); # Troisieme partie - FY2=DEFI_LIST_REEL(VALE=[F4,F2]); + FX3=DEFI_LIST_REEL(VALE=[OM4,OM2]); # Troisieme partie + FY3=DEFI_LIST_REEL(VALE=[F4,F2]); CS1=color_camp(S1,A1); ICS1=CS1[0]; IST1=CS1[1]; @@ -1630,7 +758,6 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE FON1.append([]); ll=len(FON1)-1; FON1[ll]= DEFI_FONCTION(NOM_PARA='VITE',VALE_PARA=FX3,VALE_FONC=FY3); - DICO={}; DICO["FONCTION"]=FON1[ll]; DICO["COULEUR"] =ICS3; @@ -1654,7 +781,7 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE SOUS_TITRE = TITRE2, GRILLE_X = pasV, GRILLE_Y = pasF, - LEGENDE_X = 'Vitesse (tr/mn)', + LEGENDE_X = legende_x, LEGENDE_Y = 'FREQ (Hz)', **mfac1); @@ -1667,7 +794,7 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE SOUS_TITRE = TITRE2, GRILLE_X = pasV, GRILLE_Y = pasF, - LEGENDE_X = 'Vitesse (tr/mn)', + LEGENDE_X = legende_x, LEGENDE_Y = 'FREQ (Hz)', **mfac1); nbll = len(FON1) @@ -1712,7 +839,7 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE SOUS_TITRE = TITRE2, GRILLE_X = pasV, GRILLE_Y = pasF, - LEGENDE_X = 'Vitesse (tr/mn)', + LEGENDE_X = legende_x, LEGENDE_Y = 'FREQ (Hz)', **mfac1); @@ -1724,7 +851,7 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE TITRE = TITRE1, GRILLE_X = pasV, GRILLE_Y = pasF, - LEGENDE_X = 'Vitesse (tr/mn)', + LEGENDE_X = legende_x, LEGENDE_Y = 'FREQ (Hz)', **mfac1); @@ -1769,7 +896,7 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE SOUS_TITRE = TITRE2, GRILLE_X = pasV, GRILLE_Y = pasF, - LEGENDE_X = 'Vitesse (tr/mn)', + LEGENDE_X = legende_x, LEGENDE_Y = 'FREQ (Hz)', **mfac1); IMPR_FONCTION( @@ -1780,7 +907,7 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE TITRE = TITRE1, GRILLE_X = pasV, GRILLE_Y = pasF, - LEGENDE_X = 'Vitesse (tr/mn)', + LEGENDE_X = legende_x, LEGENDE_Y = 'FREQ (Hz)', **mfac1); @@ -1793,15 +920,14 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE if NFREQ_f>0: for jj in range(nbV): - DETRUIRE(CONCEPT=_F(NOM=(MODEf[jj])),INFO=1) + DETRUIRE(CONCEPT=_F(NOM=(Mf[jj])),INFO=1) if NFREQ_t>0: for jj in range(nbV): - DETRUIRE(CONCEPT=_F(NOM=(MODEt[jj])),INFO=1) + DETRUIRE(CONCEPT=_F(NOM=(Mt[jj])),INFO=1) if NFREQ_l>0: for jj in range(nbV): - DETRUIRE(CONCEPT=_F(NOM=(MODEl[jj])),INFO=1) + DETRUIRE(CONCEPT=_F(NOM=(Ml[jj])),INFO=1) - #DETRUIRE(CONCEPT=_F(NOM=(FX)),INFO=1) #------------------------------------------------------------------------------------ @@ -1818,7 +944,7 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE L_S1=L_S; elif type(L_S)==tuple: L_S1=list(L_S); - elif type(L_S)==float: + elif is_float(L_S): L_S1.append(L_S); L_S1.append(S); @@ -1861,7 +987,7 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE SOUS_TITRE = TITRE2, GRILLE_X = pasV, GRILLE_Y = pasF, - LEGENDE_X = 'Vitesse (tr/mn)', + LEGENDE_X = legende_x, LEGENDE_Y = 'FREQ (Hz)', **mfac1); @@ -1876,7 +1002,7 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE SOUS_TITRE = TITRE2, GRILLE_X = pasV, GRILLE_Y = pasF, - LEGENDE_X = 'Vitesse (tr/mn)', + LEGENDE_X = legende_x, LEGENDE_Y = 'FREQ (Hz)', **mfac1); if NFREQ_lc>0: @@ -1890,7 +1016,7 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE SOUS_TITRE = TITRE2, GRILLE_X = pasV, GRILLE_Y = pasF, - LEGENDE_X = 'Vitesse (tr/mn)', + LEGENDE_X = legende_x, LEGENDE_Y = 'FREQ (Hz)', **mfac1); @@ -1902,7 +1028,7 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE TITRE = TITRE1, GRILLE_X = pasV, GRILLE_Y = pasF, - LEGENDE_X = 'Vitesse (tr/mn)', + LEGENDE_X = legende_x, LEGENDE_Y = 'FREQ (Hz)', **mfac1); @@ -1928,7 +1054,6 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE # Ecrire dans un fichier texte en sortie DEFI_FICHIER(TYPE='ASCII', UNITE=UNIT_INT,); nomfic='fort.'+str(UNIT_INT); - #FINT1=open('fort.25', 'w') FINT1=open(nomfic, 'w') INTERSEC =[]; @@ -1963,6 +1088,8 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE if P1 >=X1 and P1<=X2: if P2 >= Fmin and P2<=Fmax : + if OM_int[iv]<=0 and OM_int[iv+1]<0 : # Vitesse negative + P1=-P1; XY[ll][0]=P1; XY[ll][1]=P2; # On ajoute une ligne supplementaire @@ -1973,9 +1100,6 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE L_XY=XY[0:ll]; DICO["point"]=L_XY; INTERSEC.append(DICO); - #print "INTERSEC" - #print dir(INTERSEC) - #print INTERSEC # Sauvegarde des points d'intersection FINT1.write('\n') @@ -2010,6 +1134,8 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE if P1 >=X1 and P1<=X2: if P2 >= Fmin and P2<=Fmax : + if OM_int[iv]<=0 and OM_int[iv+1]<0 : # Vitesse negative + P1=-P1; XY[ll][0]=P1; XY[ll][1]=P2; # On ajoute une ligne supplementaire @@ -2057,6 +1183,8 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE if P1 >=X1 and P1<=X2: if P2 >= Fmin and P2<=Fmax : + if OM_int[iv]<=0 and OM_int[iv+1]<0 : # Vitesse negative + P1=-P1; XY[ll][0]=P1; XY[ll][1]=P2; # On ajoute une ligne supplementaire @@ -2076,13 +1204,9 @@ def impr_diag_campbell_ops(self, MAILLAGE, MODES, VITE_ROTA, NFREQ_camp, TYP_PRE del(XY, L_XY) del(INTERSEC, DICO) - #print L_S1, len(L_S1) nbl=len(L_S1) for ii in range(nbl): il =nbl-ii-1; del L_S1[il]; FINT1.close() - -#------------------------------------------------------------------------------------ - diff --git a/Aster/Cata/cataSTA10/Macro/impr_diag_campbell_utils.py b/Aster/Cata/cataSTA10/Macro/impr_diag_campbell_utils.py new file mode 100644 index 00000000..49087aba --- /dev/null +++ b/Aster/Cata/cataSTA10/Macro/impr_diag_campbell_utils.py @@ -0,0 +1,823 @@ +#@ MODIF impr_diag_campbell_utils Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS +# -*- 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. +# ====================================================================== + +# RESPONSABLE TORKHANI M.TORKHANI + +import numpy +import aster +from Accas import _F + +# "self" est l'objet MACRO + + +def CLASS_MODES(self,L_MODES, NFREQ, NFREQ_camp, L_GR_NOEUD, VITE_ROTA) : + """Classification des modes en flexion, en torsion et en traction/compression""" + + POST_RELEVE_T =self.get_cmd('POST_RELEVE_T') + EXTR_MODE =self.get_cmd('EXTR_MODE') + NORM_MODE =self.get_cmd('NORM_MODE') + DETRUIRE =self.get_cmd('DETRUIRE') + IMPR_TABLE =self.get_cmd('IMPR_TABLE') + + NFREQ_f=0; + NFREQ_t=0; + NFREQ_l=0; + + nbF_f=[]; + nbF_t=[]; + nbF_l=[]; + lflex={}; + ltors={}; + llong={}; + + NBV=len(L_MODES); + + Ntot =numpy.zeros((NFREQ)); + Nflex=numpy.zeros((NFREQ)); + Ntors=numpy.zeros((NFREQ)); + Nlong=numpy.zeros((NFREQ)); + + RESULT=[]; + + NBV=len(L_MODES); + NOEU=len(L_GR_NOEUD); + Mf=[0]*NBV ; + Mt=[0]*NBV ; + Ml=[0]*NBV ; + NVT =numpy.zeros((NFREQ, NBV)); + + NVT_f=0 + NVT_l=0 + NVT_t=0 + + for ii in range(NBV): + # ------------------------------------------------------------------- + # Extraire les modes en module, definir les differents types de modes + # ------------------------------------------------------------------- + + tabmoN=POST_RELEVE_T(ACTION=_F(INTITULE='MODES_MODULE', + NOEUD=L_GR_NOEUD, + RESULTAT=L_MODES[ii], + NOM_CHAM='DEPL', + TOUT_ORDRE='OUI', + NOM_CMP=('DX','DY','DZ', 'DRX', 'DRY', 'DRZ'), + FORMAT_C='MODULE', + OPERATION='EXTRACTION',),); + jj =0; + for jj in range(NFREQ): + Ntot[jj] =0.0 + Nflex[jj] =0.0 + Ntors[jj] =0.0 + Nlong[jj] =0.0 + for ll in range(NOEU): + nmod=NOEU*jj+ll + dx = tabmoN['DX' ,nmod+1] + dy = tabmoN['DY' ,nmod+1] + dz = tabmoN['DZ' ,nmod+1] + drx = tabmoN['DRX',nmod+1] + dry = tabmoN['DRY',nmod+1] + drz = tabmoN['DRZ',nmod+1] + Ntot1 = dx**2+dy**2+dz**2+drx**2+dry**2+drz**2 + Nflex1 = dy**2+dz**2+dry**2+drz**2 + Ntors1 = drx**2 + Nlong1 = dx**2 + Ntot[jj] = Ntot[jj] + Ntot1 + Nflex[jj] = Nflex[jj] + Nflex1 + Ntors[jj] = Ntors[jj] + Ntors1 + Nlong[jj] = Nlong[jj] + Nlong1 + + Ntot[jj] = numpy.sqrt(Ntot[jj]) + if Ntot[jj] > 0: + Nflex[jj] = numpy.sqrt(Nflex[jj])/ Ntot[jj] + Ntors[jj] = numpy.sqrt(Ntors[jj])/ Ntot[jj] + Nlong[jj] = numpy.sqrt(Nlong[jj])/ Ntot[jj] + + + DETRUIRE(CONCEPT=_F(NOM=(tabmoN)),INFO=1) + + jf=0; + jt=0; + jl=0; + + for jj in range(NFREQ): + NVT[jj][ii]=jj+1; + if (Nflex[jj]> Ntors[jj]) and (Nflex[jj]> Nlong[jj]): + lflex[(ii,jf)]=jj+1; + jf=jf+1; + + + elif (Ntors[jj]> Nflex[jj]) and (Ntors[jj]> Nlong[jj]): + ltors[(ii,jt)]=jj+1; + jt=jt+1; + + + elif (Nlong[jj]> Nflex[jj]) and (Nlong[jj]> Ntors[jj]): + llong[(ii,jl)]=jj+1; + jl=jl+1; + + nbF_f.append(jf); + nbF_t.append(jt); + nbF_l.append(jl); + + NFREQ_f = min(nbF_f) + NFREQ_t = min(nbF_t) + NFREQ_l = min(nbF_l) + + if NFREQ_f>0: + NVT_f =numpy.zeros((NFREQ_f, NBV), int); + l_f =numpy.zeros((NBV, NFREQ_f), int); + if NFREQ_t>0: + NVT_t =numpy.zeros((NFREQ_t, NBV), int); + l_t =numpy.zeros((NBV, NFREQ_t), int); + if NFREQ_l>0: + NVT_l =numpy.zeros((NFREQ_l, NBV), int); + l_l =numpy.zeros((NBV, NFREQ_l), int); + else: + NVT_l = 0; + + for ii in range(NBV): + for jj in range(NFREQ_f): + NVT_f[jj][ii]=lflex[ii,jj]; + l_f[ii][jj] =lflex[ii,jj]; + + for jj in range(NFREQ_t): + NVT_t[jj][ii]=ltors[ii,jj]; + l_t[ii][jj] =ltors[ii,jj]; + + for jj in range(NFREQ_l): + NVT_l[jj][ii]=llong[ii,jj]; + l_l[ii][jj] =llong[ii,jj]; + + for ii in range(NBV): + # ---------------------------------------------- + # Extraire la base des modes en flexion + # ---------------------------------------------- + if NFREQ_f >0: + lmodef =list(l_f[ii]); + Mf[ii] = EXTR_MODE ( FILTRE_MODE = _F ( MODE = L_MODES[ii], + NUME_MODE = lmodef) + ); + + Mf[ii]= NORM_MODE (MODE=Mf[ii], + reuse = Mf[ii], + NORME='TRAN', + ); + + # ---------------------------------------------- + # Extraire la base des modes en torsion + # ---------------------------------------------- + if NFREQ_t >0: + lmodet =list(l_t[ii]); + Mt[ii] = EXTR_MODE ( FILTRE_MODE = _F ( MODE = L_MODES[ii], + NUME_MODE = lmodet) + ); + Mt[ii]= NORM_MODE (MODE=Mt[ii], + reuse = Mt[ii], + AVEC_CMP=('DRX','DRY', 'DRZ'), + ); + + # ---------------------------------------------- + # Extraire la base des modes en longi + # ---------------------------------------------- + if NFREQ_l >0: + lmodel =list(l_l[ii]); + Ml[ii] = EXTR_MODE ( FILTRE_MODE = _F ( MODE = L_MODES[ii], + NUME_MODE = lmodel) + ); + + Ml[ii]= NORM_MODE (MODE=Ml[ii], + reuse = Ml[ii], + NORME='TRAN', + ); + + # ----------------------------------------------------------- + # Nombre de frequences par type pour le diagramme de Campbell + # ----------------------------------------------------------- + NFREQ_fc=0; + for jj in range(NFREQ_f): + if NVT_f[jj][NBV-1]<= NFREQ_camp: + NFREQ_fc=NFREQ_fc+1; + + NFREQ_tc=0; + for jj in range(NFREQ_t): + if NVT_t[jj][NBV-1]<= NFREQ_camp: + NFREQ_tc=NFREQ_tc+1; + + NFREQ_lc=0; + for jj in range(NFREQ_l): + if NVT_l[jj][NBV-1]<= NFREQ_camp: + NFREQ_lc=NFREQ_lc+1; + + RESULT =[NFREQ_f,NFREQ_t,NFREQ_l,Mf,Mt,Ml,NVT,NVT_f,NVT_t,NVT_l,NFREQ_fc,NFREQ_tc,NFREQ_lc] + + return RESULT + + +#------------------------------------------------------------------------------------------------ +def EXTR_FREQ(self,L_MODES, L_MODEf,L_MODEt,L_MODEl, NFREQ, NFREQ_f, NFREQ_t, NFREQ_l) : + """Extraire les frequences""" + RECU_TABLE =self.get_cmd('RECU_TABLE') + IMPR_TABLE =self.get_cmd('IMPR_TABLE') + DETRUIRE =self.get_cmd('DETRUIRE') + + RESULT=[]; + + NBV =len(L_MODES); + FRQ =numpy.zeros((NFREQ,NBV)); + FRQ_f =numpy.zeros((NFREQ_f,NBV)); + FRQ_t =numpy.zeros((NFREQ_t,NBV)); + FRQ_l =numpy.zeros((NFREQ_l,NBV)); + AMO_f =numpy.zeros((NFREQ_f,NBV)); + FRQ_max = 0.0; + EPSI =1.E-10; + for ii in range(NBV): + + # frequences totales + tabfreq = RECU_TABLE(CO=L_MODES[ii],NOM_PARA=('NUME_MODE','FREQ','AMOR_REDUIT'),); + + for jj in range(NFREQ): + FRQ[jj][ii]=tabfreq['FREQ',jj+1] + if FRQ_max < FRQ[jj][ii]: + FRQ_max=FRQ[jj][ii]; + + if NFREQ_f>0: + # frequences des modes en flexion + tabfr_f = RECU_TABLE(CO=L_MODEf[ii],NOM_PARA=('FREQ','AMOR_REDUIT'),) + for jj in range(NFREQ_f): + FRQ_f[jj][ii]=tabfr_f['FREQ',jj+1]; + AMO_f[jj][ii]=tabfr_f['AMOR_REDUIT',jj+1]; + if abs(AMO_f[jj][ii])0: + # frequences des modes en torsion + tabfr_t = RECU_TABLE(CO=L_MODEt[ii],NOM_PARA='FREQ',) + + for jj in range(NFREQ_t): + FRQ_t[jj][ii]=tabfr_t['FREQ',jj+1] + + DETRUIRE(CONCEPT=_F(NOM=(tabfr_t)),INFO=1) + + if NFREQ_l>0: + # frequences des modes en traction / compression + tabfr_l = RECU_TABLE(CO=L_MODEl[ii],NOM_PARA='FREQ',) + + for jj in range(NFREQ_l): + FRQ_l[jj][ii]=tabfr_l['FREQ',jj+1] + + DETRUIRE(CONCEPT=_F(NOM=(tabfr_l)),INFO=1) + + DETRUIRE(CONCEPT=_F(NOM=(tabfreq)),INFO=1) + + + RESULT = [FRQ,FRQ_f,FRQ_t, FRQ_l, FRQ_max, AMO_f]; + return RESULT + + +#------------------------------------------------------------------------------------------------ + +def TRI_MODE_MACf(self, MACf,NFREQ_f, NVT_f, IV) : + """Tri des frequences par calcul des coefficients MAC""" + + + DETRUIRE =self.get_cmd('DETRUIRE') + + # base mode 1 + tmacf =numpy.zeros((NFREQ_f,NFREQ_f)); + + for jj in range(NFREQ_f): + # base mode 2 + for ll in range(NFREQ_f): + nmac= NFREQ_f*jj+ll + tmacf[jj][ll]=MACf['MAC',nmac+1] + chaine='MAC Modes de flexion' + aster.affiche('RESULTAT', chaine) + affiche_tab(tmacf,NFREQ_f, NFREQ_f); + + for j2 in range(NFREQ_f): + XMAX=0.0 + JREC=int(NVT_f[j2][IV+1]-1); + for j1 in range(NFREQ_f): + + if tmacf[j1][JREC] > XMAX: + XMAX=tmacf[j1][JREC] + I1B=j1+1 + # test d'existance de I1B dans le tableau de connexion + I1B_exist =0; + for jj in range(j2): + if I1B == NVT_f[jj][IV]: + I1B_exist =1; + if I1B_exist ==0: # IB1 n'existe pas + NVT_f[j2][IV]= I1B; + else: + NVT_f[j2][IV]=0; + + DETRUIRE(CONCEPT=_F(NOM=(MACf)),INFO=1); + + return NVT_f + +#------------------------------------------------------------------------------------------------ + +def TRI_MODE_MACt(self, MACt,NFREQ_t, NVT_t, IV) : + """Tri des frequences par calcul des coefficients MAC""" + + + DETRUIRE =self.get_cmd('DETRUIRE') + + # base mode 1 + tmact =numpy.zeros((NFREQ_t,NFREQ_t)); + + for jj in range(NFREQ_t): + # base mode 2 + for ll in range(NFREQ_t): + nmac= NFREQ_t*jj+ll + tmact[jj][ll]=MACt['MAC',nmac+1] + chaine='MAC Modes en torsion' + aster.affiche('RESULTAT', chaine) + affiche_tab(tmact,NFREQ_t, NFREQ_t); + + for j2 in range(NFREQ_t): + XMAX=0.0 + JREC=int(NVT_t[j2][IV+1]-1); + for j1 in range(NFREQ_t): + + if tmact[j1][JREC] > XMAX: + XMAX=tmact[j1][JREC] + I1B=j1+1 + # test d'existance de I1B dans le tableau de connexion + I1B_exist =0; + for jj in range(j2): + if I1B == NVT_t[jj][IV]: + I1B_exist =1; # IB1 existe deja + if I1B_exist ==0: # IB1 n'existe pas + NVT_t[j2][IV]= I1B; + else: + NVT_t[j2][IV]=0; + + DETRUIRE(CONCEPT=_F(NOM=(MACt)),INFO=1); + + return NVT_t + +#------------------------------------------------------------------------------------------------ +def TRI_MODE_MACl(self, MACl,NFREQ_l, NVT_l, IV) : + """Tri des frequences par calcul des coefficients MAC""" + + DETRUIRE =self.get_cmd('DETRUIRE') + + # base mode 1 + tmacl =numpy.zeros((NFREQ_l,NFREQ_l)); + + for jj in range(NFREQ_l): + # base mode 2 + for ll in range(NFREQ_l): + nmac= NFREQ_l*jj+ll + tmacl[jj][ll]=MACl['MAC',nmac+1] + chaine='MAC Modes en traction/compression' + aster.affiche('RESULTAT', chaine) + affiche_tab(tmacl,NFREQ_l, NFREQ_l); + + for j2 in range(NFREQ_l): + XMAX=0.0 + JREC=int(NVT_l[j2][IV+1]-1); + for j1 in range(NFREQ_l): + + if tmacl[j1][JREC] > XMAX: + XMAX=tmacl[j1][JREC] + I1B=j1+1 + # test d'existance de I1B dans le tableau de connexion + I1B_exist =0; + for jj in range(j2): + if I1B == NVT_l[jj][IV]: + I1B_exist =1; # IB1 existe deja + if I1B_exist ==0: # IB1 n'existe pas + NVT_l[j2][IV]= I1B; + else: + NVT_l[j2][IV]=0; + + DETRUIRE(CONCEPT=_F(NOM=(MACl)),INFO=1); + + return NVT_l + + +#------------------------------------------------------------------------------------------------ +def CALC_MACf(self, L_MODEf, NFREQ_f) : + """Calcul de la matrice MAC entre les deux bases successives""" + + MAC_MODES =self.get_cmd('MAC_MODES') + + NBV=len(L_MODEf); + tmacf =numpy.zeros((NFREQ_f,NFREQ_f)); + MACf=[0]*NBV + + for ii in range(NBV-1): + if NFREQ_f>0: + MACf[ii]=MAC_MODES(BASE_1=L_MODEf[ii], + BASE_2=L_MODEf[ii+1], + INFO =2, + ); + return MACf + + +#------------------------------------------------------------------------------------------------ +def CALC_MACt(self, L_MODEt, NFREQ_t) : + """Calcul de la matrice MAC entre les deux bases successives""" + + MAC_MODES =self.get_cmd('MAC_MODES') + + NBV=len(L_MODEt); + tmact =numpy.zeros((NFREQ_t,NFREQ_t)); + MACt=[0]*NBV + + for ii in range(NBV-1): + if NFREQ_t>0: + MACt[ii]=MAC_MODES(BASE_1=L_MODEt[ii], + BASE_2=L_MODEt[ii+1], + INFO =1, + ); + return MACt + +#----------------------------------------------------------------------------------------------- +def CALC_MACl(self, L_MODEl, NFREQ_l) : + """Calcul de la matrice MAC entre les deux bases successives """ + + MAC_MODES =self.get_cmd('MAC_MODES') + + NBV=len(L_MODEl); + tmacl =numpy.zeros((NFREQ_l,NFREQ_l)); + MACl=[0]*NBV + + for ii in range(NBV-1): + if NFREQ_l>0: + MACl[ii]=MAC_MODES(BASE_1=L_MODEl[ii], + BASE_2=L_MODEl[ii+1], + INFO =1, + ); + return MACl + +#----------------------------------------------------------------------------------------------- +def CALC_PREC(self,Mf,NFREQ_f,L_GR_NOEUD, typ_prec) : + """Calcul le sens de precession pour un mode a une vitesse de rotation donnee + Type de precession, 1 somme, 2 grande orbite""" + + POST_RELEVE_T =self.get_cmd('POST_RELEVE_T') + DETRUIRE =self.get_cmd('DETRUIRE') + IMPR_TABLE =self.get_cmd('IMPR_TABLE') + + XSMIN=1e-2; + NBV=len(Mf); + NOEU=len(L_GR_NOEUD); + SENS=numpy.zeros((NFREQ_f, NBV)); + for ii in range(NBV): + # ------------------------------------------------------------------------- + # Extraire les parties reelles, imaginaires et modules des modes en flexion + # ------------------------------------------------------------------------- + + tabmoR_f=POST_RELEVE_T(ACTION=_F(INTITULE='MODES_REEL', + NOEUD=L_GR_NOEUD, + RESULTAT=Mf[ii], + NOM_CHAM='DEPL', + TOUT_ORDRE='OUI', + NOM_CMP=('DX','DY','DZ'), + FORMAT_C='REEL', + OPERATION='EXTRACTION',),); + tabmoI_f=POST_RELEVE_T(ACTION=_F(INTITULE='MODES_IMAG', + NOEUD=L_GR_NOEUD, + RESULTAT=Mf[ii], + NOM_CHAM='DEPL', + TOUT_ORDRE='OUI', + NOM_CMP=('DX','DY','DZ'), + FORMAT_C='IMAG', + OPERATION='EXTRACTION',),); + tabmoN_f=POST_RELEVE_T(ACTION=_F(INTITULE='MODES_MODULE', + NOEUD=L_GR_NOEUD, + RESULTAT=Mf[ii], + NOM_CHAM='DEPL', + TOUT_ORDRE='OUI', + NOM_CMP=('DX','DY','DZ'), + FORMAT_C='MODULE', + OPERATION='EXTRACTION',),); + + + for jj in range(NFREQ_f): + #Sens de precesion pour un mode a une vitesse donne + modul1 =0.0; + sens1 =0.0; + for ll in range(NOEU): + nmod=NOEU*jj+ll + dy_r = tabmoR_f['DY' ,nmod+1]; + dz_r = tabmoR_f['DZ' ,nmod+1]; + dy_i = tabmoI_f['DY' ,nmod+1]; + dz_i = tabmoI_f['DZ' ,nmod+1]; + dy_m = tabmoN_f['DY' ,nmod+1]; + dz_m = tabmoN_f['DZ' ,nmod+1]; + + if typ_prec == 1 : + #Sens parcours pour un noeud + preces = dy_r*dz_i-dy_i*dz_r ; + #Sens de precession dominant dans une mode + if preces >0: + sens1=sens1+ dy_m + dz_m; + elif preces <0: + sens1=sens1- dy_m - dz_m; + else: + #Sens de precession associe au plus grand orbite + lk= numpy.sqrt(dy_m*dy_m + dz_m*dz_m); + if lk > modul1: + # demi diagonale + modul1=lk + preces = dy_r*dz_i-dy_i*dz_r ; + if preces >0: + sens1=modul1; + elif preces <0: + sens1=-modul1; + + XS=abs(sens1); + if XS>XSMIN: + SENS[jj][ii]=sens1/XS; + else: + SENS[jj][ii]=0.0; + + DETRUIRE(CONCEPT=_F(NOM=(tabmoR_f, tabmoI_f, tabmoN_f)),INFO=1) + + return SENS + +#------------------------------------------------------------------------------------------------ +def TRI_MODE_PREC_DI (SENS,NFREQ_f, NVT_f, NBV, OMIN) : + """Tri des modes par une methode de proche en proche avec verification du sens de precession""" + # base mode 1 + chaine='TRI_MODE_PREC_DI' + aster.affiche('RESULTAT', chaine) + + NVT_fdir =numpy.zeros((NFREQ_f, NBV)); + NVT_finv =numpy.zeros((NFREQ_f, NBV)); + nb_prec_dir =NFREQ_f; + nb_prec_inv =NFREQ_f; + for nb in range(NBV): + nbv1=NBV-nb-1; + jd=0; + ji=0; + for jj in range(NFREQ_f): + if SENS[jj][nbv1]>=0.: + NVT_fdir[jd][nbv1]=jj+1; + jd=jd+1; + elif SENS[jj][nbv1]<0.: + NVT_finv[ji][nbv1]=jj+1; + ji=ji+1; + # Calcul de nombre minimum de precession directe pour les vitesses + # Calcul de nombre minimum de precession inverse pour les vitesses + + if jd>0: + if nb_prec_dir >jd: + nb_prec_dir =jd; + if ji>0: + if nb_prec_inv >ji: + nb_prec_inv= ji; + + if(OMIN==0.0) : + for ii in range(NFREQ_f): + NVT_fdir[ii][0]=NVT_fdir[ii][1] + NVT_finv[ii][0]=NVT_finv[ii][1] + + chaine='nb_prev_dir ' + str(nb_prec_dir); + aster.affiche('RESULTAT', chaine) + chaine='Tableau de connexion des Modes de flexion precession directe' + aster.affiche('RESULTAT', chaine) + affiche_tabint(NVT_fdir,NFREQ_f, NBV); + + chaine='nb_prev_inv ' + str(nb_prec_inv); + aster.affiche('RESULTAT', chaine) + chaine='Tableau de connexion des Modes de flexion precession inverse' + aster.affiche('RESULTAT', chaine) + affiche_tabint(NVT_finv,NFREQ_f, NBV); + + # Rassembler les tableaux de connexion + NVTf_prec =numpy.zeros((NFREQ_f, NBV), int); + for jj in range(NFREQ_f): + jf=0; + jf=int(NVT_fdir[jj][NBV-1]); + if jf>0: + for iv in range(NBV): + NVTf_prec[jf-1][iv]= NVT_fdir[jj][iv]; + jf=0; + jf=int(NVT_finv[jj][NBV-1]); + if jf>0: + for iv in range(NBV): + NVTf_prec[jf-1][iv]= NVT_finv[jj][iv]; + + chaine='\n' + aster.affiche('RESULTAT', chaine) + chaine='Tableau de connexion des Modes de flexion' + aster.affiche('RESULTAT', chaine) + affiche_tabint(NVTf_prec,NFREQ_f, NBV); + + RESULT = [nb_prec_dir,nb_prec_inv, NVTf_prec]; + + return RESULT + + +#---------------------------------------------------------------------------------------- +def affiche_tab(tab1,nbligne, nbcol) : + """affiche un taleau tab1 de nbligne lignes et nbcol colonnes""" + for jj in range(nbligne): + chaine='' + for ii in range(nbcol): + str1 = '%15.5E' %tab1[jj][ii] + chaine=chaine + ' '+ str1 + aster.affiche('RESULTAT', chaine) + + +#---------------------------------------------------------------------------------------- +def affiche_tabint(tab1,nbligne, nbcol) : + """affiche un taleau tab1 de nbligne lignes et nbcol colonnes""" + for jj in range(nbligne): + chaine='' + for ii in range(nbcol): + str1 = '%5d' %tab1[jj][ii] + chaine=chaine + ' '+ str1 + aster.affiche('RESULTAT', chaine) + + +#---------------------------------------------------------------------------------------- +def calc_pas(xmin, xmax) : + """calcul de l'echelle valeurs mini-maxi et le pas + On impose entre 5 et 10 intervalles + En entree xmin, xmax valeurs mini-maxi, xmin et xmax superieurs ou egaux a zero + En sortie VAL1, VAL2 et PAS valeurs mini-maxi de l'echelle et le pas + """ + diff=xmax-xmin; + PAS=1.; + VAL1=0.; + C10=10.; + + # diff < 5. + while diff<5.: + diff=diff*C10; + PAS = PAS/C10; + + # diff > 50. + while diff<50.: + diff=diff/C10; + PAS = PAS*C10; + + # 5 <= diff <= 50. + N=int(diff); + if N>=11 and N<=20 : + N=N/2; + PAS=PAS*2.; + elif N>=21 and N<=30 : + N=N/3; + PAS=PAS*3.; + elif N>=31 and N<=40 : + N=N/4; + PAS=PAS*4.; + elif N>=41 and N<=50 : + N=N/5; + PAS=PAS*5.; + + # Calcul des valeurs mini-maxi de l'echelle + while abs(xmin-VAL1)>PAS: + VAL1=VAL1 + PAS; + + VAL2=VAL1 + (N*PAS); + while VAL2 <= xmax: + VAL2=VAL2 + PAS; + + RESULT=[VAL1, VAL2, PAS]; + + return RESULT + +#---------------------------------------------------------------------------------------- +def color_camp(sens, amortis) : + """determine la couleur et le style du trait + en entree le sens de precession + en sortir la couleur, le style du trait ICS IST et le marqueur + DIRECTE,STABLE vert + DIRECTE,INSTABLE rouge + INDIRECTE,STABLE bleu + INDIRECTE,INSTABLE magenta + """ + + if sens<0: # precession inverse + if amortis<0.0: # instable + ICS = 10; # magenta + IST = 4; # tiret + IMA = 9; # croix + else: # stable + ICS = 4; # bleu + IST = 4; # tiret + IMA = 0; + else: # precession directe + if amortis<0.0: # instable + ICS = 2; # rouge + IST = 1; # trait continu + IMA = 8; # plus + else: # stable + ICS = 3; # vert + IST = 1; # trait continu + IMA = 0; + RESULT= [ICS,IST,IMA]; + + return RESULT + +#---------------------------------------------------------------------------------------- +def sup_redon_list(LS): + """Supprimer la redondace dans une liste de reel""" + LS.sort(); + LS_min=min(LS); + LS_max=max(LS); + if LS_min<0: + if abs(LS_min) > abs(LS_max): + LS.reverse(); + ii=0 + len_list=len(LS); + while ii < len_list-1: + icount = LS.count(LS[ii]); + if icount >1: + for jj in range(ii+icount-1, ii,-1): + LS.pop(jj); + ii=ii+1 + len_list=len(LS); + + +#---------------------------------------------------------------------------------------- +def sup_redon_listv(LS): + """Supprimer la redondace dans une liste de vitesses""" + + LS_init=[LS[ii] for ii in range(len(LS))]; # Liste de vitesses initiale sans rangement + LS.sort(); + LS_min=min(LS); + LS_max=max(LS); + if LS_min<0: + if abs(LS_min) > abs(LS_max): + LS.reverse(); + + ii=0 + len_list=len(LS); + while ii < len_list-1: + icount = LS.count(LS[ii]); + if icount >1: + for jj in range(ii+icount-1, ii,-1): + LS.pop(jj); + ii=ii+1 + len_list=len(LS); + + + nbV1=len_list; + num_vit_tri =numpy.zeros((nbV1), int); + for ii in range(0,nbV1): + vit = LS[ii]; + num_vit_tri[ii] = LS_init.index(vit); + + print 'LS', LS + print 'LS_init', LS_init + return num_vit_tri + + +#---------------------------------------------------------------------------------------- +def save_intersec(L_INTER, FINT): + """Sauvegarde dans un fichier les points d'intersection des courbes du diagramme de Campbell + avec les droites de pente S + """ + chaine='\n' + FINT.write(chaine) + chaine='Points d'' intersection avec les droites Y=SX' + FINT.write(chaine) + for ii in range(len(L_INTER)): + chaine='\n' + FINT.write(chaine) + chaine = 'S = %10.2F' %L_INTER[ii]["pente"] + FINT.write(chaine) + chaine='\n' + FINT.write(chaine) + L_POINT = L_INTER[ii]["point"] + for jj in range(len(L_POINT)): + chaine = 'Vitesse = %10.2F tr/mn' %L_POINT[jj][0] + FINT.write(chaine) + FINT.write('\n') + chaine = 'Frequence = %10.2F HZ' %L_POINT[jj][1] + FINT.write(chaine) + FINT.write('\n') + + chaine='----------------------------' + FINT.write(chaine) + chaine='\n' + chaine=' ' + diff --git a/Aster/Cata/cataSTA10/Macro/lire_fonction_ops.py b/Aster/Cata/cataSTA10/Macro/lire_fonction_ops.py index 870ca6b4..99000615 100644 --- a/Aster/Cata/cataSTA10/Macro/lire_fonction_ops.py +++ b/Aster/Cata/cataSTA10/Macro/lire_fonction_ops.py @@ -1,4 +1,4 @@ -#@ MODIF lire_fonction_ops Macro DATE 16/10/2007 AUTEUR REZETTE C.REZETTE +#@ MODIF lire_fonction_ops Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -18,7 +18,8 @@ # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -import os.path, Numeric +import os.path as osp +import numpy class LectureBlocError(Exception): pass @@ -53,13 +54,13 @@ def lire_blocs(nomfich, SEPAR): if lignes==[]: pass # dans ce cas, on a plusieurs lignes délimitant 2 fonctions else: - blocs.append(Numeric.array(lignes)) + blocs.append(numpy.array(lignes)) info(len(blocs), len(lignes), llen) lignes=[] llen=0 fich.close() if len(lignes) > 0 : - blocs.append(Numeric.array(lignes)) + blocs.append(numpy.array(lignes)) info(len(blocs), len(lignes), llen) return blocs @@ -161,7 +162,7 @@ def lire_fonction_ops(self,FORMAT,TYPE,SEPAR,INDIC_PARA,UNITE, # Lecture de la fonction dans un fichier d unité logique UNITE UL = UniteAster() nomfich=UL.Nom(UNITE) - if not os.path.isfile(nomfich): + if not osp.isfile(nomfich): UTMESS('F','FONCT0_41',valk=nomfich) # fonction(_c) ou nappe en sortie diff --git a/Aster/Cata/cataSTA10/Macro/lire_table_ops.py b/Aster/Cata/cataSTA10/Macro/lire_table_ops.py index 80927fff..5273ab51 100644 --- a/Aster/Cata/cataSTA10/Macro/lire_table_ops.py +++ b/Aster/Cata/cataSTA10/Macro/lire_table_ops.py @@ -1,4 +1,4 @@ -#@ MODIF lire_table_ops Macro DATE 16/10/2007 AUTEUR REZETTE C.REZETTE +#@ MODIF lire_table_ops Macro DATE 15/03/2010 AUTEUR COURTOIS M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -127,7 +127,7 @@ def lire_table_ops(self, **args): UL = UniteAster() nomfich=UL.Nom(UNITE) if not os.path.isfile(nomfich): - UTMESS('F', nompro, "le fichier '%s' est introuvable" % nomfich) + UTMESS('F', 'FONCT0_41', valk=nomfich) texte = open(nomfich,'r').read() # remet UNITE dans son état initial diff --git a/Aster/Cata/cataSTA10/Macro/macr_adap_mail_ops.py b/Aster/Cata/cataSTA10/Macro/macr_adap_mail_ops.py index 14874e19..5b016ad3 100644 --- a/Aster/Cata/cataSTA10/Macro/macr_adap_mail_ops.py +++ b/Aster/Cata/cataSTA10/Macro/macr_adap_mail_ops.py @@ -1,4 +1,4 @@ -#@ MODIF macr_adap_mail_ops Macro DATE 24/11/2008 AUTEUR GNICOLAS G.NICOLAS +#@ MODIF macr_adap_mail_ops Macro DATE 15/03/2010 AUTEUR GNICOLAS G.NICOLAS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -6,7 +6,7 @@ # 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. +# (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 @@ -22,7 +22,7 @@ """ Traitement des macros MACR_ADAP_MAIL/MACR_INFO_MAIL """ -__revision__ = "V1.2" +__revision__ = "V1.3" # def macr_adap_mail_ops ( self, INFO, VERSION_HOMARD, MAILLAGE_FRONTIERE, @@ -37,6 +37,7 @@ def macr_adap_mail_ops ( self, # args.keys()[1:] est la liste des valeurs suivantes dans cette liste # args.keys(mot_cle) represente le contenu de la variable mot_cle dans la macro appelante. # +### print 'glop' ### print args ### print args.keys() ### if len (args.keys())>0 : print args.keys()[0] @@ -71,7 +72,7 @@ def macr_adap_mail_ops ( self, # dico["RESULTAT"] = f ; concept ASTER du resutat associe # dico["NOM_CHAM"] = f ; string ; Nom ASTER du champ # dico["CHAM_GD"] = f ; concept ASTER du champ de grandeur associee -# dico["COMPOSANTE"] = f ; string ; Nom ASTER de la composante (dans le cas de l'indicateur) +# dico["COMPOSANTE"] = f ; liste ; Liste des noms ASTER des composante de l'indicateur # dico["NUME_ORDRE"] = f ; entier ; Numero d'ordre du champ # dico["INST"] = f ; entier ; Instant du champ # dico["PRECISION"] = f ; entier ; Precision sur l'instant du champ @@ -94,7 +95,9 @@ def macr_adap_mail_ops ( self, import aster import string import os - import shutil + from types import ListType, TupleType + EnumTypes = (ListType, TupleType) +#gn import shutil # global Liste_Passages # @@ -124,7 +127,7 @@ def macr_adap_mail_ops ( self, LIRE_MAILLAGE = self.get_cmd("LIRE_MAILLAGE") LIRE_CHAMP = self.get_cmd("LIRE_CHAMP") # -# 1.4. ==> Le nom du programme HOMARD e lancer +# 1.4. ==> Le nom du programme HOMARD a lancer # repertoire_outils = aster.repout() homard = repertoire_outils + "homard" @@ -137,6 +140,7 @@ def macr_adap_mail_ops ( self, liste_maillages = [] liste_champs = [] liste_zones = [] + liste_front_analytiques = [] dico_indi = {} # LISTE_ADAPTATION_LIBRE = ("RAFF_DERA" , "RAFFINEMENT" , "DERAFFINEMENT") @@ -155,7 +159,10 @@ def macr_adap_mail_ops ( self, # if ( self.nom == "MACR_ADAP_MAIL" ) : # - mode_homard = "ADAP" + if args["ADAPTATION"] == "MODIFICATION" : + mode_homard = "MODI" + else : + mode_homard = "ADAP" # # 2.1.1. ==> Les concepts "maillage" # @@ -213,12 +220,23 @@ def macr_adap_mail_ops ( self, #gn print "Avant appel a aster.mdnoch, lresu = ",lresu,", noresu =", noresu ,", nomsym = ", nomsym ,", nopase = ", nopase dico["NOM_MED"] = aster.mdnoch ( lresu, noresu, nomsym, nopase ) #gn print "==> dico[\"NOM_MED\"] = ", dico["NOM_MED"] - dico["COMPOSANTE"] = args["NOM_CMP_INDICA"] +# + if args.has_key("NOM_CMP_INDICA") : + if args["NOM_CMP_INDICA"] is not None : + if not type(args["NOM_CMP_INDICA"]) in EnumTypes : + l_aux = [args["NOM_CMP_INDICA"]] + else : + l_aux = [] + les_composantes = args["NOM_CMP_INDICA"] + for composante in les_composantes : + l_aux.append(composante) + dico["COMPOSANTE"] = l_aux +# liste_champs.append(dico) dico_indi = dico ### print dico # -# 2.1.3. ==> Les champs e mettre e jour +# 2.1.3. ==> Les champs a mettre a jour # #gn print "\n.. Debut de 2.1.3." # @@ -235,11 +253,11 @@ def macr_adap_mail_ops ( self, # dico = {} dico["Type_Champ"] = "CHAMP_MAJ" - liste_aux = [ "CHAM_MAJ", "TYPE_CHAM" ] + l_aux = [ "CHAM_MAJ", "TYPE_CHAM" ] if ( maj_cham["RESULTAT"] != None ) : lresu = 1 - liste_aux.append("RESULTAT") - liste_aux.append("NOM_CHAM") + l_aux.append("RESULTAT") + l_aux.append("NOM_CHAM") if ( maj_cham["NUME_ORDRE"] != None ) : dico["NUME_ORDRE"] = maj_cham["NUME_ORDRE"] elif ( maj_cham["INST"] != None ) : @@ -253,10 +271,10 @@ def macr_adap_mail_ops ( self, dico["SENSIBILITE"] = maj_cham["SENSIBILITE"] else : lresu = 0 - liste_aux.append("CHAM_GD") + l_aux.append("CHAM_GD") noresu = maj_cham["CHAM_GD"].nom nomsym = " " - for cle in liste_aux : + for cle in l_aux : dico[cle] = maj_cham[cle] #gn print "dico = ", dico # @@ -278,17 +296,18 @@ def macr_adap_mail_ops ( self, if args.has_key("ZONE") : # if args["ZONE"] is not None : + l_aux = ['TYPE', 'X_MINI', 'X_MAXI', 'Y_MINI', 'Y_MAXI', 'Z_MINI', 'Z_MAXI', 'X_CENTRE', 'Y_CENTRE', 'Z_CENTRE', 'RAYON', 'RAYON_INT', 'RAYON_EXT', 'X_AXE', 'Y_AXE', 'Z_AXE', 'X_BASE', 'Y_BASE', 'Z_BASE', 'HAUTEUR' ] les_zones = args["ZONE"] # - for zone in les_zones : -### print zone -### print type(zone) - dico = {} - for aux in ['X_MINI', 'X_MAXI', 'Y_MINI', 'Y_MAXI', 'Z_MINI', 'Z_MAXI', 'X_CENTRE', 'Y_CENTRE', 'Z_CENTRE', 'RAYON'] : - if ( zone[aux] != None ) : - dico[aux] = zone[aux] + for zone in les_zones : +### print zone +### print type(zone) + dico = {} + for aux in l_aux : + if ( zone[aux] != None ) : + dico[aux] = zone[aux] ### print dico - liste_zones.append(dico) + liste_zones.append(dico) # ### print liste_zones # @@ -304,9 +323,10 @@ def macr_adap_mail_ops ( self, dico["Action"] = "A_ecrire" liste_maillages.append(dico) # -# 2.3. ==> Suivi de frontiere +# 2.3. ==> Suivi d'une frontiere +# 2.3.1. ==> Suivi d'une frontiere maillee # -#gn print "\n.. Debut de 2.3." +#gn print "\n.. Debut de 2.3.1." # if ( MAILLAGE_FRONTIERE != None ) : # @@ -316,6 +336,30 @@ def macr_adap_mail_ops ( self, dico["Action"] = "A_ecrire" liste_maillages.append(dico) # +# 2.3.2. ==> Suivi d'une frontiere analytique +# +#gn print "\n.. Debut de 2.3.2." +# + if args.has_key("FRONTIERE_ANALYTIQUE") : +# + if args["FRONTIERE_ANALYTIQUE"] is None : + les_front_analytiques = [] + else : + les_front_analytiques = args["FRONTIERE_ANALYTIQUE"] +# + for frontiere in les_front_analytiques : + l_aux = [ "TYPE", "GROUP_MA", "RAYON", "X_CENTRE", "Y_CENTRE", "Z_CENTRE"] + if ( frontiere["TYPE"] == "CYLINDRE" ) : + l_aux.append("X_AXE") + l_aux.append("Y_AXE") + l_aux.append("Z_AXE") + dico = {} + for aux in l_aux : + dico[aux] = frontiere[aux] +#gn print dico +# + liste_front_analytiques.append(dico) +# # 2.4. ==> Le numero de version de HOMARD # Remarque : dans la donnee de la version de HOMARD, il faut remplacer # le _ de la donnee par un ., qui est interdit dans la @@ -336,6 +380,17 @@ def macr_adap_mail_ops ( self, #gn print ".... VERSION_HOMARD = ", VERSION_HOMARD #gn print ".... version_perso = ", version_perso # +# 2.54. ==> Les messages d'information +# +#gn print "\n.. Debut de 2.5." +#gn print args["INTERPENETRATION"] + if ( args["INTERPENETRATION"] == "OUI" ) : + if ( mode_homard == "INFO" ) : + UTMESS('I','HOMARD0_6') + else : + UTMESS('A','HOMARD0_7') +# UTMESS('I','HOMARD0_6',valk='glop') +# #==================================================================== # 3. Preparation du lancement des commandes #==================================================================== @@ -377,8 +432,8 @@ def macr_adap_mail_ops ( self, Nom_Rep_local = Nom_Concept_Maillage_N + "_" + mode_homard + "_" + str(numero_passage_fonction) Rep_Calc_HOMARD_local = os.path.join(".", Nom_Rep_local) Rep_Calc_HOMARD_global = os.path.join(Rep_Calc_ASTER, Nom_Rep_local) -### print "Rep_Calc_HOMARD_local = ", Rep_Calc_HOMARD_local -### print "Rep_Calc_HOMARD_global = ", Rep_Calc_HOMARD_global +#gn print "Rep_Calc_HOMARD_local = ", Rep_Calc_HOMARD_local +#gn print "Rep_Calc_HOMARD_global = ", Rep_Calc_HOMARD_global # # 3.2.2. ==> En adaptation : il faut repartir du repertoire de l'iteration precedente # @@ -386,13 +441,13 @@ def macr_adap_mail_ops ( self, # if ( mode_homard == "ADAP" ) : # -# 3.2.2.1. ==> On recherche si dans les passages deje effectues, il en existe un +# 3.2.2.1. ==> On recherche si dans les passages deja effectues, il en existe un # dont le maillage d'arrivee etait l'actuel maillage d'entree. Si c'est # le cas, cela veut dire que l'adaptation en cours est la suite d'une # precedente. On doit donc utiliser le meme repertoire. Le numero # d'iteration est celui de l'adaptation precedente augmente de 1. # -#gn print "\.. Debut de 3.2.2.1." +#gn print "\.. Debut de 3.2.2.1." # for dico in Liste_Passages : if ( dico["Maillage_NP1"] == Nom_Concept_Maillage_N ) : @@ -402,7 +457,7 @@ def macr_adap_mail_ops ( self, # # 3.2.2.2. ==> Memorisation de ce passage # -#gn print "\.. Debut de 3.2.2.2." +#gn print "\.. Debut de 3.2.2.2." # # 3.2.2.2.1. ==> Enregistrement d'un nouveau cas de figure # @@ -442,7 +497,7 @@ def macr_adap_mail_ops ( self, os.mkdir(Rep_Calc_HOMARD_global) except os.error,codret_partiel : self.cr.warn("Code d'erreur de mkdir : " + str(codret_partiel[0]) + " : " + codret_partiel[1]) - UTMESS("F",'HOMARD0_4',valk=Rep_Calc_HOMARD_global) + UTMESS("F", 'HOMARD0_4', valk=Rep_Calc_HOMARD_global) # #==================================================================== # 4. Ecriture des commandes de creation des donnees MED @@ -468,14 +523,14 @@ def macr_adap_mail_ops ( self, ### print "fichier_aster_vers_homard = ",fichier_aster_vers_homard # # 4.1.2. ==> De HOMARD vers ASTER -# - if ( mode_homard == "ADAP" ) : +# + if ( mode_homard in [ "ADAP", "MODI" ] ) : unite_fichier_homard_vers_aster = unite_fichier_aster_vers_homard + 1 fichier_homard_vers_aster = os.path.join(Rep_Calc_ASTER,"fort." + str(unite_fichier_homard_vers_aster)) ### print "fichier_homard_vers_aster = ",fichier_homard_vers_aster # # 4.2. La definition du fichier de ASTER vers HOMARD -# +# DEFI_FICHIER ( ACTION= "ASSOCIER", UNITE = unite_fichier_aster_vers_homard, TYPE = "LIBRE", @@ -502,18 +557,19 @@ def macr_adap_mail_ops ( self, **motscfa ) # # 4.4. Le(s) champ(s) -# Attention : il se peut que l'on demande la mise e jour du champ qui a servi comme +# Attention : il se peut que l'on demande la mise à jour du champ qui a servi comme # indicateur d'erreur. Si c'est le cas, il ne faut pas demander son # impression sinon il y a plantage d'IMPR_RESU qui ne sait pas substituer # deux champs. D'ailleurs, c'est plus economique ainsi ! -# Remarque : pour l'adaptation, on ne demande a priori qu'une composante du champ d'indicateur. -# s'il y a demande de mise e jour, toutes les composantes sont concernees. Il faut +# Remarque : pour l'adaptation, on peut ne demander qu'un nombre reduit de composante du +# champ d'indicateur. +# s'il y a demande de mise a jour, toutes les composantes sont concernees. Il faut # donc dans ce cas imprimer le champ total. # dico["Type_Champ"] = o ; string ; "INDICATEUR" ou "CHAMP_MAJ" # dico["RESULTAT"] = f ; concept ASTER du resutat associe # dico["NOM_CHAM"] = f ; string ; Nom ASTER du champ # dico["CHAM_GD"] = f ; concept ASTER du champ de grandeur associee -# dico["COMPOSANTE"] = f ; string ; Nom ASTER de la composante (dans le cas de l'indicateur) +# dico["COMPOSANTE"] = f ; liste ; Liste des noms ASTER des composante de l'indicateur # dico["NUME_ORDRE"] = f ; entier ; Numero d'ordre du champ # dico["INST"] = f ; entier ; Instant du champ # dico["PRECISION"] = f ; entier ; Precision sur l'instant du champ @@ -528,13 +584,13 @@ def macr_adap_mail_ops ( self, if len(dico_indi) > 0 : indic_est_deja_imprime = 0 if dico_indi.has_key("RESULTAT") : - liste_aux = [ "RESULTAT", "NOM_CHAM" ] + l_aux = [ "RESULTAT", "NOM_CHAM" ] else : - liste_aux = [ "CHAM_GD" ] + l_aux = [ "CHAM_GD" ] else : indic_est_deja_imprime = 1 - liste_aux = [ ] -#gn print ".. Au debut de la boucle, liste_aux = ",liste_aux + l_aux = [ ] +#gn print ".. Au debut de la boucle, l_aux = ",l_aux #gn print ".. Au debut de la boucle, indic_est_deja_imprime = ",indic_est_deja_imprime # liste_champs_imprime = [] @@ -547,7 +603,7 @@ def macr_adap_mail_ops ( self, if not indic_est_deja_imprime : # Est-ce le meme champ ? on_a_le_champ = 1 - for cle in liste_aux : + for cle in l_aux : if ( dico.has_key(cle) ) : ### print "...... dico_indi[cle] = ",dico_indi[cle] ### print "...... dico[cle] = ",dico[cle] @@ -598,7 +654,10 @@ def macr_adap_mail_ops ( self, if ( dico[cle] != None ) : motscsi[cle] = dico[cle] if dico.has_key("COMPOSANTE") : - motscsi["NOM_CMP"] = dico["COMPOSANTE"] + if ( len(dico["COMPOSANTE"]) == 1 ) : + motscsi["NOM_CMP"] = dico["COMPOSANTE"][0] + else : + motscsi["NOM_CMP"] = dico["COMPOSANTE"] if dico.has_key("SENSIBILITE") : motscsi["SENSIBILITE"] = dico["SENSIBILITE"] motscfa = {} @@ -626,12 +685,16 @@ def macr_adap_mail_ops ( self, dico_configuration["Rep_Calc_HOMARD_global"] = Rep_Calc_HOMARD_global dico_configuration["VERSION_HOMARD"] = VERSION_HOMARD dico_configuration["version_perso"] = version_perso + if args.has_key("UNITE") : + UNITE = args["UNITE"] + fichier_conf_suppl = os.path.join(Rep_Calc_ASTER,"fort." + str(UNITE)) + dico_configuration["fichier_conf_suppl"] = fichier_conf_suppl # dico_configuration["niter"] = niter dico_configuration["Fichier_ASTER_vers_HOMARD"] = fichier_aster_vers_homard - if ( mode_homard == "ADAP" ) : + if ( mode_homard in [ "ADAP", "MODI" ] ) : dico_configuration["Fichier_HOMARD_vers_ASTER"] = fichier_homard_vers_aster -# +# # 5.2. ==> Les noms med des maillages # for dico in liste_maillages : @@ -644,10 +707,10 @@ def macr_adap_mail_ops ( self, for dico in liste_champs : dico_aux = {} if ( dico["Type_Champ"] == "INDICATEUR" ) : - liste_aux = [ "NOM_MED", "COMPOSANTE" ] + l_aux = [ "NOM_MED", "COMPOSANTE" ] if dico.has_key("NUME_ORDRE") : - liste_aux.append("NUME_ORDRE") - for cle in liste_aux : + l_aux.append("NUME_ORDRE") + for cle in l_aux : if ( dico[cle] != None ) : dico_aux[cle] = dico[cle] dico_configuration["Indicateur"] = dico_aux @@ -662,25 +725,25 @@ def macr_adap_mail_ops ( self, l_aux = [dico] prem = 0 else : - l_aux = dico_configuration["Zones"] + l_aux = dico_configuration["Zones_raffinement"] l_aux.append(dico) - dico_configuration["Zones"] = l_aux -### if dico_configuration.has_key("Zones") : -### print "dico_configuration[Zones] = ", dico_configuration["Zones"] + dico_configuration["Zones_raffinement"] = l_aux +### if dico_configuration.has_key("Zones_raffinement") : +### print "dico_configuration[Zones_raffinement] = ", dico_configuration["Zones_raffinement"] # -# 5.5. ==> La mise e jour de champs +# 5.5. ==> La mise a jour de champs # prem = 1 for dico in liste_champs : dico_aux = {} if ( dico["Type_Champ"] == "CHAMP_MAJ" ) : - liste_aux = [ "NOM_MED", "COMPOSANTE" ] + l_aux = [ "NOM_MED", "COMPOSANTE" ] if dico.has_key("NUME_ORDRE") : - liste_aux.append("NUME_ORDRE") + l_aux.append("NUME_ORDRE") else : for cle in [ "RESULTAT", "NOM_CHAM", "INST", "PRECISION", "CRITERE" ] : - liste_aux.append(cle) - for cle in liste_aux : + l_aux.append(cle) + for cle in l_aux : if dico.has_key(cle) : if ( dico[cle] != None ) : dico_aux[cle] = dico[cle] @@ -695,7 +758,21 @@ def macr_adap_mail_ops ( self, #gn if dico_configuration.has_key("Champs") : #gn print "dico_configuration[Champs] = ", dico_configuration["Champs"] # -# 5.6. ==> Appel de la fonction de creation +# 5.6. ==> Les eventuelles frontieres analytiques +# + prem = 1 + for dico in liste_front_analytiques : + if prem : + l_aux = [dico] + prem = 0 + else : + l_aux = dico_configuration["Frontiere_analytique"] + l_aux.append(dico) + dico_configuration["Frontiere_analytique"] = l_aux +#gn if dico_configuration.has_key("Frontiere_analytique") : +#gn print "dico_configuration[Frontiere_analytique] = ", dico_configuration["Frontiere_analytique"] +# +# 5.7. ==> Appel de la fonction de creation # donnees_homard = creation_donnees_homard.creation_donnees_homard ( self.nom, args, dico_configuration ) if ( INFO >= 4 ) : @@ -707,7 +784,7 @@ def macr_adap_mail_ops ( self, else : Nom_Fichier_Donnees = "0" # -# 5.7. ==> Impression eventuelle des fichiers crees +# 5.8. ==> Impression eventuelle des fichiers crees # #gn print "Repertoire ",Rep_Calc_HOMARD_global #gn os.system("ls -la "+Rep_Calc_HOMARD_global) @@ -743,15 +820,18 @@ def macr_adap_mail_ops ( self, #gn fichier_aster_vers_homard_2 = os.path.join("/tmp" , "fort." + str(unite_fichier_aster_vers_homard)) #gn shutil.copyfile(fichier_aster_vers_homard, fichier_aster_vers_homard_2) # - iaux = INFO + if ( INFO == 1 ) : + iaux = INFO + else : + iaux = 2 EXEC_LOGICIEL ( ARGUMENT = (Rep_Calc_HOMARD_global, # nom du repertoire VERSION_HOMARD, # version de homard - str(iaux), # niveau d information + str(INFO), # niveau d information Nom_Fichier_Donnees, # fichier de donnees HOMARD str(version_perso), # version personnelle de homard ? ), LOGICIEL = homard, - INFO = INFO, + INFO = iaux, ) #gn import time #gn time.sleep(3600) @@ -776,7 +856,7 @@ def macr_adap_mail_ops ( self, # ==> la variable maillage_a_lire est identifiee e l'argument "MAILLAGE_NP1" #==================================================================== # - if ( mode_homard == "ADAP" ) : + if ( mode_homard in [ "ADAP", "MODI" ] ) : # # 7.1. ==> Le maillage # On inhibe l'alarme MODELISA5_49 qui apparait car on fait VERIF=NON @@ -828,37 +908,44 @@ def macr_adap_mail_ops ( self, # #==================================================================== # 8. Menage des fichiers devenus inutiles +# Il est important de faire le menage des fichiers MED, qui sont +# les plus gros. # On doit imperativement garder le dernier fichier homard produit # En mode d'information, on garde egalement les fichiers textes #==================================================================== # - liste_aux = [fichier_aster_vers_homard] - liste_aux_bis = os.listdir(Rep_Calc_HOMARD_global) - for fic in liste_aux_bis : + l_aux = [fichier_aster_vers_homard] + if ( mode_homard in [ "ADAP", "MODI" ] ) : + l_aux.append(fichier_homard_vers_aster) +# + l_aux_bis = os.listdir(Rep_Calc_HOMARD_global) + for fic in l_aux_bis : fic_total = os.path.join(Rep_Calc_HOMARD_global, fic) - liste_aux.append(fic_total) - liste_aux_bis = [] + l_aux.append(fic_total) +# + l_aux_bis = [] if ( mode_homard == "ADAP" ) : - liste_aux.append(fichier_homard_vers_aster) fic = os.path.join(Rep_Calc_HOMARD_global, fic_homard_niterp1) - liste_aux_bis.append(fic) + l_aux_bis.append(fic) #gn os.system("cp " + Rep_Calc_HOMARD_global + "/* $HOME/aster") # - for fic in liste_aux : - if fic not in liste_aux_bis : + for fic in l_aux : + if ( INFO >= 3 ) : + print "Examen du fichier ", fic + if fic not in l_aux_bis : if ( INFO >= 3 ) : - print "Destruction du fichier ", fic + print "==> Destruction du fichier" if os.path.isfile(fic) : try : os.remove(fic) except os.error,codret_partiel : self.cr.warn("Code d'erreur de remove : " + str(codret_partiel[0]) + " : " + codret_partiel[1]) - UTMESS("F",'HOMARD0_5',valk=fic) + UTMESS("F", 'HOMARD0_5', valk=fic) +# #gn print "Repertoire ",Rep_Calc_HOMARD_global -#gn os.system("ls -la "+Rep_Calc_HOMARD_global) -#gn print "Repertoire ",Rep_Calc_ASTER -#gn os.system("ls -la "+Rep_Calc_ASTER) #gn print os.listdir(Rep_Calc_HOMARD_global) +#gn print "Repertoire ",Rep_Calc_ASTER +#gn print os.listdir(Rep_Calc_ASTER) # #==================================================================== # C'est fini ! @@ -866,7 +953,7 @@ def macr_adap_mail_ops ( self, # ### if ( mode_homard == "ADAP" and niter == 3 ) : ### if ( niter == 2 ) : -### import time -### time.sleep(3600) +#gn import time +#gn time.sleep(3600) # return diff --git a/Aster/Cata/cataSTA10/Macro/macr_ascouf_calc_ops.py b/Aster/Cata/cataSTA10/Macro/macr_ascouf_calc_ops.py index 66f28157..5464de33 100644 --- a/Aster/Cata/cataSTA10/Macro/macr_ascouf_calc_ops.py +++ b/Aster/Cata/cataSTA10/Macro/macr_ascouf_calc_ops.py @@ -1,4 +1,4 @@ -#@ MODIF macr_ascouf_calc_ops Macro DATE 03/08/2009 AUTEUR COURTOIS M.COURTOIS +#@ MODIF macr_ascouf_calc_ops Macro DATE 22/12/2009 AUTEUR ABBAS M.ABBAS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -42,6 +42,7 @@ def macr_ascouf_calc_ops(self,TYPE_MAILLAGE,CL_BOL_P2_GV,MAILLAGE,MODELE,CHAM_MA AFFE_MATERIAU =self.get_cmd('AFFE_MATERIAU' ) AFFE_CARA_ELEM =self.get_cmd('AFFE_CARA_ELEM' ) AFFE_CHAR_THER_F =self.get_cmd('AFFE_CHAR_THER_F') + DEFI_CONTACT =self.get_cmd('DEFI_CONTACT') THER_LINEAIRE =self.get_cmd('THER_LINEAIRE' ) AFFE_CHAR_MECA =self.get_cmd('AFFE_CHAR_MECA' ) STAT_NON_LINE =self.get_cmd('STAT_NON_LINE' ) @@ -313,12 +314,13 @@ def macr_ascouf_calc_ops(self,TYPE_MAILLAGE,CL_BOL_P2_GV,MAILLAGE,MODELE,CHAM_MA # chargement mecanique : verif contact levres # if TYPE_MAILLAGE in ('FISS_COUDE','FISS_AXIS_DEB'): - _chcont = AFFE_CHAR_MECA( MODELE = modele , - CONTACT =_F(GROUP_MA_MAIT = 'FACE1', - GROUP_MA_ESCL = 'FACE2', - METHODE='VERIF', - GROUP_MA_FOND='FONDFISS', - TOLE_INTERP = -1.E-6,),) + _chcont = DEFI_CONTACT( MODELE = modele , + FORMULATION = 'DISCRETE', + TOLE_INTERP = -1.E-6, + ZONE =_F(GROUP_MA_MAIT = 'FACE1', + GROUP_MA_ESCL = 'FACE2', + ALGO_CONT = 'VERIF', + GROUP_MA_FOND = 'FONDFISS'),) # # --- commande STAT_NON_LINE --- # @@ -339,8 +341,10 @@ def macr_ascouf_calc_ops(self,TYPE_MAILLAGE,CL_BOL_P2_GV,MAILLAGE,MODELE,CHAM_MA else : mcfex.append(_F(CHARGE=_chtor[i],)) i=i+1 + + contact = None if TYPE_MAILLAGE in ('FISS_COUDE','FISS_AXIS_DEB'): - mcfex.append(_F(CHARGE=_chcont,)) + contact = _chcont motscles['EXCIT'] =mcfex # mcfci=[] # mot clé facteur COMP_INCR :obligatoire pour les noeuds discrets @@ -382,10 +386,18 @@ def macr_ascouf_calc_ops(self,TYPE_MAILLAGE,CL_BOL_P2_GV,MAILLAGE,MODELE,CHAM_MA motscles ['RECH_LINEAIRE'] =dRechlin motscles ['INCREMENT' ] =dIncrem self.DeclareOut('nomres',self.sd) - nomres = STAT_NON_LINE( MODELE = modele , - CHAM_MATER = affmth , - CARA_ELEM = carael , - INFO = INFO , **motscles) + + if contact==None: + nomres = STAT_NON_LINE( MODELE = modele , + CHAM_MATER = affmth , + CARA_ELEM = carael , + INFO = INFO , **motscles) + else : + nomres = STAT_NON_LINE( MODELE = modele , + CHAM_MATER = affmth , + CARA_ELEM = carael , + CONTACT = contact, + INFO = INFO , **motscles) # # --- commande CALC_ELEM --- # diff --git a/Aster/Cata/cataSTA10/Macro/macr_aspic_calc_ops.py b/Aster/Cata/cataSTA10/Macro/macr_aspic_calc_ops.py index 2ab5b99c..86eb0430 100644 --- a/Aster/Cata/cataSTA10/Macro/macr_aspic_calc_ops.py +++ b/Aster/Cata/cataSTA10/Macro/macr_aspic_calc_ops.py @@ -1,4 +1,4 @@ -#@ MODIF macr_aspic_calc_ops Macro DATE 03/08/2009 AUTEUR COURTOIS M.COURTOIS +#@ MODIF macr_aspic_calc_ops Macro DATE 22/12/2009 AUTEUR ABBAS M.ABBAS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -40,6 +40,7 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,C AFFE_MATERIAU =self.get_cmd('AFFE_MATERIAU' ) AFFE_CARA_ELEM =self.get_cmd('AFFE_CARA_ELEM' ) AFFE_CHAR_THER_F =self.get_cmd('AFFE_CHAR_THER_F') + DEFI_CONTACT =self.get_cmd('DEFI_CONTACT' ) THER_LINEAIRE =self.get_cmd('THER_LINEAIRE' ) AFFE_CHAR_MECA =self.get_cmd('AFFE_CHAR_MECA' ) STAT_NON_LINE =self.get_cmd('STAT_NON_LINE' ) @@ -300,13 +301,13 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,C mcfond = ('FOND_SUP','FOND_INF') else : mcfond = ('FONDFISS') - _chcont = AFFE_CHAR_MECA( MODELE = modele , - CONTACT =_F(GROUP_MA_MAIT = 'LEVRCORP', - GROUP_MA_ESCL = 'LEVRTUBU', - METHODE='VERIF', - TOLE_INTERP = -1.e-6, - GROUP_MA_FOND=mcfond,),) - + _chcont = DEFI_CONTACT( MODELE = modele , + FORMULATION = 'DISCRETE', + TOLE_INTERP = -1.E-6, + ZONE =_F(GROUP_MA_MAIT = 'LEVRCORP', + GROUP_MA_ESCL = 'LEVRTUBU', + ALGO_CONT = 'VERIF', + GROUP_MA_FOND = mcfond,),) # # --- commande STAT_NON_LINE --- @@ -335,8 +336,13 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,C else : mcfex.append(_F(CHARGE=_chtrt[i],)) i=i+1 + + contact = None if TYPE_MAILLAGE[:4]=='FISS' : - mcfex.append(_F(CHARGE=_chcont,)) + if mcfond == 'FONDFISS' : + contact = _chcont + + motscles['EXCIT'] =mcfex # mcfci=[] # mot clé facteur COMP_INCR :obligatoire pour les noeuds discrets @@ -378,10 +384,22 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,C motscles ['RECH_LINEAIRE'] =dRechlin motscles ['INCREMENT' ] =dIncrem self.DeclareOut('nomres',self.sd) - nomres = STAT_NON_LINE( MODELE = modele , - CHAM_MATER = affmth , - CARA_ELEM = carael , - INFO = INFO , **motscles) + + + if contact==None: + nomres = STAT_NON_LINE( MODELE = modele , + CHAM_MATER = affmth , + CARA_ELEM = carael , + INFO = INFO , **motscles) + else : + nomres = STAT_NON_LINE( MODELE = modele , + CHAM_MATER = affmth , + CARA_ELEM = carael , + CONTACT = contact, + INFO = INFO , **motscles) + + + # nomres = CALC_ELEM( reuse = nomres, RESULTAT = nomres , diff --git a/Aster/Cata/cataSTA10/Macro/macr_ecla_pg_ops.py b/Aster/Cata/cataSTA10/Macro/macr_ecla_pg_ops.py index 8bfada76..db6c0ba5 100644 --- a/Aster/Cata/cataSTA10/Macro/macr_ecla_pg_ops.py +++ b/Aster/Cata/cataSTA10/Macro/macr_ecla_pg_ops.py @@ -1,28 +1,28 @@ -#@ MODIF macr_ecla_pg_ops Macro DATE 09/11/2004 AUTEUR VABHHTS J.PELLET +#@ MODIF macr_ecla_pg_ops Macro DATE 02/02/2010 AUTEUR PELLET J.PELLET # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== # COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG -# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY -# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY -# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR -# (AT YOUR OPTION) ANY LATER VERSION. -# -# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT -# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF -# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU -# GENERAL PUBLIC LICENSE FOR MORE DETAILS. -# -# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE -# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, -# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== ######################################################################## def macr_ecla_pg_ops(self,RESULTAT,MAILLAGE,RESU_INIT,MODELE_INIT, TOUT, GROUP_MA, MAILLE, SHRINK, TAILLE_MIN, - NOM_CHAM, TOUT_ORDRE, NUME_ORDRE, LIST_ORDRE, INST, LIST_INST, PRECISION, CRITERE, + NOM_CHAM, TOUT_ORDRE, NUME_ORDRE, LIST_ORDRE, INST, LIST_INST, PRECISION, CRITERE, **args): """ Ecriture de la macro macr_ecla_pg @@ -39,33 +39,32 @@ def macr_ecla_pg_ops(self,RESULTAT,MAILLAGE,RESU_INIT,MODELE_INIT, # La macro compte pour 1 dans la numerotation des commandes self.set_icmd(1) - + # Appel à CREA_MAILLAGE : motscles={} if TOUT : motscles['TOUT'] =TOUT if GROUP_MA : motscles['GROUP_MA'] =GROUP_MA if MAILLE : motscles['MAILLE'] =MAILLE - + self.DeclareOut('ma2',MAILLAGE) ma2=CREA_MAILLAGE(ECLA_PG=_F( MODELE = MODELE_INIT, NOM_CHAM=NOM_CHAM, SHRINK = SHRINK, TAILLE_MIN=TAILLE_MIN, **motscles )); - - + + # Appel à CREA_RESU : - typ2=AsType(RESU_INIT).__name__ - if TOUT_ORDRE : motscles['TOUT_ORDRE'] =TOUT_ORDRE - if NUME_ORDRE : motscles['NUME_ORDRE'] =NUME_ORDRE - if LIST_ORDRE : motscles['LIST_ORDRE'] =LIST_ORDRE - if LIST_INST : motscles['LIST_INST'] =LIST_INST - if INST : motscles['INST'] =INST - if TOUT_ORDRE : motscles['TOUT_ORDRE'] =TOUT_ORDRE + typ2=AsType(RESU_INIT).__name__ + if TOUT_ORDRE : motscles['TOUT_ORDRE'] =TOUT_ORDRE + if NUME_ORDRE != None : motscles['NUME_ORDRE'] =NUME_ORDRE + if LIST_ORDRE : motscles['LIST_ORDRE'] =LIST_ORDRE + if LIST_INST : motscles['LIST_INST'] =LIST_INST + if INST != None : motscles['INST'] =INST self.DeclareOut('resu2',RESULTAT) resu2=CREA_RESU( OPERATION='ECLA_PG', TYPE_RESU=string.upper(typ2), ECLA_PG=_F( MODELE_INIT= MODELE_INIT, RESU_INIT=RESU_INIT, NOM_CHAM=NOM_CHAM, MAILLAGE= ma2, **motscles )); - return ier + return ier ############################################################################################ diff --git a/Aster/Cata/cataSTA10/Macro/macr_ecre_calc_ops.py b/Aster/Cata/cataSTA10/Macro/macr_ecre_calc_ops.py index afef7e74..3f81fc79 100644 --- a/Aster/Cata/cataSTA10/Macro/macr_ecre_calc_ops.py +++ b/Aster/Cata/cataSTA10/Macro/macr_ecre_calc_ops.py @@ -1,21 +1,21 @@ -#@ MODIF macr_ecre_calc_ops Macro DATE 05/10/2009 AUTEUR ASSIRE A.ASSIRE +#@ MODIF macr_ecre_calc_ops Macro DATE 21/04/2010 AUTEUR BOTTONI M.BOTTONI # -*- 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. # ====================================================================== @@ -31,7 +31,7 @@ def macr_ecre_calc_ops( LOGICIEL, VERSION, ENTETE, - COURBES, + #COURBES, IMPRESSION, INFO, **args): @@ -44,12 +44,18 @@ def macr_ecre_calc_ops( import os, string, types, shutil import aster from Accas import _F - from Noyau.N_utils import AsType + #from Noyau.N_utils import AsType from Utilitai.Utmess import UTMESS from Utilitai.System import ExecCommand ier=0 + + # PARAMETRES DEBUG + debug = True + + + # Concept sortant self.DeclareOut('__TAB',TABLE) self.DeclareOut('__DEB',DEBIT) @@ -57,16 +63,15 @@ def macr_ecre_calc_ops( # La macro compte pour 1 dans la numerotation des commandes self.set_icmd(1) - # Parametres - # Niveaux de debug - debug1 = (INFO>1) - debug2 = (INFO>2) - + # Info + info2 = (INFO==2) + if debug : + info2=True # Parametres Developpeur tmp_ecrevisse = "tmp_ecrevisse" - fichier_data = "data.dat" - defaut = '00' + fichier_data = "data.dat" + defaut = '00' # IMPORTATION DE COMMANDES ASTER EXEC_LOGICIEL = self.get_cmd("EXEC_LOGICIEL") @@ -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/cataSTA10/Macro/macr_ecrevisse_ops.py b/Aster/Cata/cataSTA10/Macro/macr_ecrevisse_ops.py index 2cbd64a3..def648cb 100644 --- a/Aster/Cata/cataSTA10/Macro/macr_ecrevisse_ops.py +++ b/Aster/Cata/cataSTA10/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 21/04/2010 AUTEUR BOTTONI M.BOTTONI # -*- 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, @@ -37,6 +37,7 @@ def macr_ecrevisse_ops(self,reuse, IMPRESSION, CHAM_MATER, CARA_ELEM, + CONTACT, EXCIT_MECA, EXCIT_THER, COMP_INCR, @@ -47,7 +48,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 +59,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 +93,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 +107,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 +152,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 +197,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 +217,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 +264,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 +303,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 +320,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 +365,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,29 +377,29 @@ 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, CARA_ELEM = CARA_ELEM, + CONTACT = CONTACT, EXCIT = _dEXCIT_MECA, COMP_INCR = _F(**dCOMP_INCR), INCREMENT = _F(LIST_INST=LES_PAS, NUME_INST_INIT=_nume_ordre, NUME_INST_FIN=_nume_ordre+1,), @@ -407,13 +414,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 +453,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 +479,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 +508,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 +559,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 +589,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 +621,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 +649,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 +669,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 +705,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/cataSTA10/Macro/macr_fiabilite_ops.py b/Aster/Cata/cataSTA10/Macro/macr_fiabilite_ops.py index fae50474..d49b4f72 100644 --- a/Aster/Cata/cataSTA10/Macro/macr_fiabilite_ops.py +++ b/Aster/Cata/cataSTA10/Macro/macr_fiabilite_ops.py @@ -1,4 +1,4 @@ -#@ MODIF macr_fiabilite_ops Macro DATE 27/11/2006 AUTEUR GNICOLAS G.NICOLAS +#@ MODIF macr_fiabilite_ops Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -18,9 +18,12 @@ # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== - # RESPONSABLE GNICOLAS G.NICOLAS -# + +import os +import sys + + def macr_fiabilite_ops(self, INFO, LOGICIEL, VERSION, UNITE_ESCL, MESS_ASTER, @@ -43,10 +46,7 @@ def macr_fiabilite_ops(self, INFO, from Accas import _F from Macro import fiabilite_mefisto import aster - import os - import string - import sys - import Numeric + import numpy # #____________________________________________________________________ # @@ -180,16 +180,16 @@ def macr_fiabilite_ops(self, INFO, if la_variable["VALE_MOY_PHY"] is None : v_moy_loi = la_variable["VALE_MOY"] sigma_loi = la_variable["ECART_TYPE"] - aux = Numeric.exp(0.5*sigma_loi*sigma_loi+v_moy_loi) + aux = numpy.exp(0.5*sigma_loi*sigma_loi+v_moy_loi) v_moy_physique = v_min_loi + aux else : v_moy_physique = la_variable["VALE_MOY_PHY"] aux = la_variable["ECART_TYPE_PHY"]/(la_variable["VALE_MOY_PHY"]-la_variable["VALE_MIN"]) aux1 = 1. + aux*aux - aux2 = Numeric.sqrt(aux1) - v_moy_loi = Numeric.log((la_variable["VALE_MOY_PHY"]-la_variable["VALE_MIN"])/aux2) - aux2 = Numeric.log(aux1) - sigma_loi = Numeric.sqrt(aux2) + aux2 = numpy.sqrt(aux1) + v_moy_loi = numpy.log((la_variable["VALE_MOY_PHY"]-la_variable["VALE_MIN"])/aux2) + aux2 = numpy.log(aux1) + sigma_loi = numpy.sqrt(aux2) # # 3.1.4. ==> loi normale tronquée : transfert des moyenne, mini/maxi et écart-type # on définit une moyennne comme étant la médiane des extremes. @@ -250,8 +250,7 @@ def macr_fiabilite_ops(self, INFO, #____________________________________________________________________ # # - VERSION = string.replace(VERSION, "_", ".") - VERSION = string.replace(VERSION, "N", "n") + VERSION = VERSION.replace("_", ".").replace("N", "n") # EXEC_LOGICIEL ( ARGUMENT = (Rep_Calc_LOGICIEL_global, # nom du repertoire LOGICIEL, # nom du logiciel de fiabilité diff --git a/Aster/Cata/cataSTA10/Macro/macr_lign_coupe_ops.py b/Aster/Cata/cataSTA10/Macro/macr_lign_coupe_ops.py index ec6285fe..d7e18ab3 100644 --- a/Aster/Cata/cataSTA10/Macro/macr_lign_coupe_ops.py +++ b/Aster/Cata/cataSTA10/Macro/macr_lign_coupe_ops.py @@ -1,4 +1,4 @@ -#@ MODIF macr_lign_coupe_ops Macro DATE 16/11/2009 AUTEUR DURAND C.DURAND +#@ MODIF macr_lign_coupe_ops Macro DATE 13/04/2010 AUTEUR PELLET J.PELLET # -*- 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,82 +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 - 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 +682,8 @@ def macr_lign_coupe_ops(self,RESULTAT,CHAM_GD,UNITE_MAILLAGE,LIGN_COUPE, if nomgd[:6] == 'TEMP_R' : TYPE_RESU='EVOL_THER' elif nomgd[:6] == 'DEPL_R' : TYPE_RESU='EVOL_ELAS' elif nomgd[:6] == 'EPSI_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' @@ -674,7 +694,8 @@ def macr_lign_coupe_ops(self,RESULTAT,CHAM_GD,UNITE_MAILLAGE,LIGN_COUPE, RESULTAT=__resuch l_mailla=aster.getvectjev(n_modele.ljust(8)+'.MODELE .LGRF') n_mailla=string.strip(l_mailla[0]) - dime=aster.getvectjev(n_mailla.ljust(8)+'.DIME')[5] + # le maillage est-il 2D ou 3D ? + iret,dime,kbid = aster.dismoi('F','DIM_GEOM',n_mailla,'MAILLAGE') collgrma=aster.getcolljev(n_mailla.ljust(8)+'.GROUPEMA') typma=aster.getvectjev(n_mailla.ljust(8)+'.TYPMAIL') connex=aster.getcolljev(n_mailla.ljust(8)+'.CONNEX') @@ -809,9 +830,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 +861,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 +905,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 +931,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) @@ -928,7 +951,6 @@ def macr_lign_coupe_ops(self,RESULTAT,CHAM_GD,UNITE_MAILLAGE,LIGN_COUPE, self.DeclareOut('nomres',self.sd) dictab=__tabitm.EXTR_TABLE() - ### Ajout de la colonne theta if len(arcgma)>0: coltab=[] diff --git a/Aster/Cata/cataSTA10/Macro/macr_recal_ops.py b/Aster/Cata/cataSTA10/Macro/macr_recal_ops.py index 472a8187..bc6067c5 100644 --- a/Aster/Cata/cataSTA10/Macro/macr_recal_ops.py +++ b/Aster/Cata/cataSTA10/Macro/macr_recal_ops.py @@ -1,4 +1,4 @@ -#@ MODIF macr_recal_ops Macro DATE 13/10/2009 AUTEUR COURTOIS M.COURTOIS +#@ MODIF macr_recal_ops Macro DATE 26/05/2010 AUTEUR ASSIRE A.ASSIRE # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -19,56 +19,20 @@ # ====================================================================== # RESPONSABLE ASSIRE A.ASSIRE -import os, sys, copy, math -from glob import glob -import Numeric +import os +import sys +import copy +import math +import glob + +import numpy as NP +from recal import * debug = False INFO = 1 NOMPRO = 'MACR_RECAL' -fichier_export = None -mode_python = False -type_fonctionnelle = 'float' - - -# -------------------------------------------------------------------------------------------------- -def Ecriture_Fonctionnelle(output_file, type_fonctionnelle, fonctionnelle): - - try: os.remove(output_file) - except: pass - - f=open(output_file, 'w') - if type_fonctionnelle == 'vector': - fonctionnelle = str(fonctionnelle.tolist()) - fonctionnelle = fonctionnelle.replace('[','') - fonctionnelle = fonctionnelle.replace(']','') - f.write(str(fonctionnelle)) - f.close() - - -# -------------------------------------------------------------------------------------------------- -def Ecriture_Derivees(output_file, derivees): - - try: os.remove(output_file) - except: pass - - # On sort si il n'y a pas de derivees a imprimer - if not derivees: return - - txt = '' - a = derivees - for l in range(len(a[:,0])): - ligne = [] - for c in range(len(a[0,:])): - ligne.append( str(a[l,c]) ) - txt += ','.join(ligne) + '\n' - - f=open(output_file, 'w') - f.write(txt) - f.close() - # -------------------------------------------------------------------------------------------------- def Sortie(LIST_NOM_PARA, LIST_PARA, val, CALCUL_ASTER, Mess): @@ -85,8 +49,7 @@ def Sortie(LIST_NOM_PARA, LIST_PARA, val, CALCUL_ASTER, Mess): from Macro.reca_controles import gestion from Utilitai.Utmess import UTMESS, MessageLog - if CALCUL_ASTER.METHODE != 'EXTERNE': - UTMESS('I','RECAL0_1', valk=str(CALCUL_ASTER.evaluation_fonction), cc=Mess.get_filename()) + UTMESS('I','RECAL0_39', valk=str(CALCUL_ASTER.evaluation_fonction), cc=Mess.get_filename()) LIST_NOM_PARA_ALPHA = [ para[0] for para in LIST_PARA ] LIST_NOM_PARA_ALPHA.sort() @@ -98,47 +61,6 @@ def Sortie(LIST_NOM_PARA, LIST_PARA, val, CALCUL_ASTER, Mess): return nomres -# -------------------------------------------------------------------------------------------------- -def macr_recal_externe( RESU_EXP, LIST_PARA, RESU_CALC, UNITE_ESCL=3, POIDS=None, LIST_DERIV=None, - ITER_MAXI=10, ITER_FONC_MAXI=100, RESI_GLOB_RELA=1.e-6, UNITE_RESU=91, PARA_DIFF_FINI=0.001, - GRAPHIQUE=None, SUIVI_ESCLAVE='NON', METHODE='EXTERNE', INFO=1, **args ): - """ - Entree du mode EXTERNE (ici macr_recal_ops.py est traite comme un fichier Python et non pas par le superviseur Aster) - """ - - METHODE='EXTERNE' - - # Mot-cle GRAPHIQUE - if GRAPHIQUE: - GRAPHIQUE0 = {'PILOTE': '', 'AFFICHAGE': 'TOUTE_ITERATION', 'UNITE': 90, 'FORMAT': 'XMGRACE'} - for k in GRAPHIQUE0.keys(): - if not GRAPHIQUE.has_key(k): GRAPHIQUE[k] = GRAPHIQUE0[k] - - if optparse_prefix_graph: args['prefix_graph'] = opts.prefix_graph - else: args['prefix_graph'] = os.getcwd() + os.sep + 'graph' - - # Les parametres passes sur la ligne de commande surchargent les parametres de la commande MACR_RECAL - if optparse_INFO: INFO=opts.INFO - if optparse_follow_output: - if opts.follow_output == True: SUIVI_ESCLAVE='OUI' - else: SUIVI_ESCLAVE='NON' - - if optparse_objective: - if type_fonctionnelle=='vector': args['FONCTIONNELLE']='VECTORIELLE' - else: args['FONCTIONNELLE']='SCALAIRE' - - if optparse_gradient: - if opts.gradient=='normal': args['GRADIENT']='NORMAL' - elif opts.gradient=='adim': args['GRADIENT']='ADIMENSIONNE' - else: args['GRADIENT']='NON_CALCULE' - - - fonctionnelle, gradient = macr_recal(UNITE_ESCL, RESU_EXP, POIDS, LIST_PARA, LIST_DERIV, RESU_CALC, - ITER_MAXI, ITER_FONC_MAXI, RESI_GLOB_RELA, UNITE_RESU, PARA_DIFF_FINI, - GRAPHIQUE, SUIVI_ESCLAVE, METHODE, INFO, **args ) - - return fonctionnelle, gradient - # -------------------------------------------------------------------------------------------------- def force_list(obj, typref=list): """Retourne 'obj' sous forme d'une liste de 'typref'. @@ -152,18 +74,29 @@ def force_list(obj, typref=list): obj = [obj,] return obj + # -------------------------------------------------------------------------------------------------- -def macr_recal_ops(self,UNITE_ESCL, RESU_EXP, POIDS, LIST_PARA, LIST_DERIV, RESU_CALC, - ITER_MAXI, ITER_FONC_MAXI, RESI_GLOB_RELA,UNITE_RESU,PARA_DIFF_FINI, - GRAPHIQUE, SUIVI_ESCLAVE, METHODE, INFO, **args ): - """Macro commande realisant le recalage de modeles Aster""" +def get_absolute_path(path): + """Retourne le chemin absolu en suivant les liens éventuels. + """ + if os.path.islink(path): + path = os.path.realpath(path) + res = os.path.normpath(os.path.abspath(path)) + return res + + + +# -------------------------------------------------------------------------------------------------- +def macr_recal_ops(self,UNITE_ESCL, RESU_EXP, POIDS, LIST_PARA, RESU_CALC, ITER_MAXI, ITER_FONC_MAXI, RESI_GLOB_RELA,UNITE_RESU,PARA_DIFF_FINI, GRAPHIQUE, METHODE, INFO, **args ): + """ Macro commande realisant le recalage de modeles Aster """ + # Initialisation du compteur d'erreurs ier=0 import aster import Macro from Cata import cata - from Cata.cata import DEFI_LIST_REEL, CREA_TABLE, TEST_TABLE + from Cata.cata import DEFI_LIST_REEL, CREA_TABLE, TEST_TABLE, INCLUDE from Cata.cata import OPER, MACRO from Macro import reca_message @@ -189,30 +122,32 @@ def macr_recal_ops(self,UNITE_ESCL, RESU_EXP, POIDS, LIST_PARA, LIST_DERIV, RESU self.current_context[k]= v self.current_context['_F']=cata.__dict__['_F'] - macr_recal(UNITE_ESCL, force_list(RESU_EXP, Numeric.ArrayType), POIDS, force_list(LIST_PARA), LIST_DERIV, force_list(RESU_CALC), + macr_recal(self, UNITE_ESCL, force_list(RESU_EXP, NP.ndarray), POIDS, force_list(LIST_PARA), force_list(RESU_CALC), ITER_MAXI, ITER_FONC_MAXI, RESI_GLOB_RELA,UNITE_RESU,PARA_DIFF_FINI, - GRAPHIQUE, SUIVI_ESCLAVE, METHODE, INFO, **args) + GRAPHIQUE, METHODE, INFO, **args) aster.onFatalError(prev_onFatalError) return # -------------------------------------------------------------------------------------------------- -def macr_recal(UNITE_ESCL, RESU_EXP, POIDS, LIST_PARA, LIST_DERIV, RESU_CALC, +def macr_recal(self, UNITE_ESCL, RESU_EXP, POIDS, LIST_PARA, RESU_CALC, ITER_MAXI, ITER_FONC_MAXI, RESI_GLOB_RELA,UNITE_RESU,PARA_DIFF_FINI, - GRAPHIQUE, SUIVI_ESCLAVE, METHODE, INFO, **args ): + GRAPHIQUE, METHODE, INFO, **args ): from Utilitai.Utmess import UTMESS - # Import d'as_profil - if os.environ.has_key('ASTER_ROOT'): - sys.path.append(os.path.join(os.environ['ASTER_ROOT'], 'ASTK', 'ASTK_SERV', 'lib')) - else: - try: sys.path.append(os.path.join(aster.repout, '..', 'ASTK', 'ASTK_SERV', 'lib')) - except: pass + if os.environ.has_key('ASTER_ROOT'): ASTER_ROOT = os.environ['ASTER_ROOT'] + else: ASTER_ROOT = os.path.join(aster.repout, '..') + + try: + sys.path.append(os.path.join(ASTER_ROOT, 'ASTK', 'ASTK_SERV', 'lib')) + sys.path.append(os.path.join(ASTER_ROOT, 'lib', 'python%s.%s' % (sys.version_info[0], sys.version_info[1] ) , 'site-packages')) + except: pass try: - from as_profil import ASTER_PROFIL - except: - UTMESS('F','RECAL0_2') + from asrun.profil import ASTER_PROFIL + except Exception, e: + print e + UTMESS('F','RECAL0_2') import Macro, Utilitai from Macro import reca_message @@ -220,59 +155,131 @@ def macr_recal(UNITE_ESCL, RESU_EXP, POIDS, LIST_PARA, LIST_DERIV, RESU_CALC, from Macro import reca_interp from Macro import reca_utilitaires from Macro import reca_calcul_aster + from Macro import recal from Macro.reca_controles import gestion - if( METHODE != 'EXTERNE'): - from Utilitai.optimize import fmin, line_search, line_search_BFGS, approx_fprime, approx_fhess_p, fminBFGS, fminNCG + from Utilitai.optimize import fmin, line_search, line_search_BFGS, approx_fprime, approx_fhess_p, fminBFGS, fminNCG - if( METHODE == 'EXTERNE'): - pass + import Macro + from Cata import cata + from Cata.cata import OPER, MACRO + from Accas import _F + #from Cata.cata import * + # Declaration de toutes les commandes Aster + import cata + for k,v in cata.__dict__.items() : + if isinstance(v, (OPER, MACRO)): + self.current_context[k]= v + self.current_context['_F']=cata.__dict__['_F'] + + + #_____________________________________________ + # + # RECUPERATION DU PROFIL DU CALCUL MAITRE + #_____________________________________________ + # Lecture du fichier .export dans le repertoire temporaire d'execution + list_export = glob.glob('*.export') + if len(list_export) == 0: UTMESS('F','RECAL0_4') + elif len(list_export) >1: UTMESS('F','RECAL0_5') + prof = ASTER_PROFIL(list_export[0]) + + + #_____________________________________________ + # + # PARAMETRES + #_____________________________________________ + TOLE_PARA = args['TOLE_PARA'] + TOLE_FONC = args['TOLE_FONC'] + + # Pour les calculs esclaves + CALCUL_ESCLAVE = {}.fromkeys( ['LANCEMENT', 'MODE', 'MEMOIRE', 'TEMPS', 'CLASSE', 'ACTUALISATION', 'memjeveux_esclave', 'mem_aster', 'NMAX_SIMULT', ] ) + + dESCLAVE=args['CALCUL_ESCLAVE'][0].cree_dict_valeurs(args['CALCUL_ESCLAVE'][0].mc_liste) + for i in dESCLAVE.keys(): + if dESCLAVE[i]==None : del dESCLAVE[i] + + CALCUL_ESCLAVE['LANCEMENT'] = dESCLAVE['LANCEMENT'] + if dESCLAVE.has_key('MODE'): CALCUL_ESCLAVE['MODE'] = dESCLAVE['MODE'] + else: CALCUL_ESCLAVE['MODE'] = prof['mode'][0].upper() + if dESCLAVE.has_key('MEMOIRE'): CALCUL_ESCLAVE['MEMOIRE'] = dESCLAVE['MEMOIRE'] + else: CALCUL_ESCLAVE['MEMOIRE'] = prof['memjob'][0] + if dESCLAVE.has_key('TEMPS'): CALCUL_ESCLAVE['TEMPS'] = dESCLAVE['TEMPS'] + else: CALCUL_ESCLAVE['TEMPS'] = prof['tps_job'][0] + if dESCLAVE.has_key('CLASSE'): CALCUL_ESCLAVE['CLASSE'] = dESCLAVE['CLASSE'] + if dESCLAVE.has_key('ACTUALISATION'): CALCUL_ESCLAVE['ACTUALISATION'] = dESCLAVE['ACTUALISATION'] + + LANCEMENT = CALCUL_ESCLAVE['LANCEMENT'] + + # Parametres de l'algorithme genetique + if args.has_key('NB_PARENTS'): NB_PARENTS = args['NB_PARENTS'] + if args.has_key('NB_FILS'): NB_FILS = args['NB_FILS'] + if args.has_key('ECART_TYPE'): ECART_TYPE = args['ECART_TYPE'] + if args.has_key('ITER_ALGO_GENE'): ITER_ALGO_GENE = args['ITER_ALGO_GENE'] + if args.has_key('RESI_ALGO_GENE'): RESI_ALGO_GENE = args['RESI_ALGO_GENE'] + + if args.has_key('GRAINE'): + UTMESS('A','RECAL0_43') + GRAINE = args['GRAINE'] else: - if GRAPHIQUE: - dGRAPHIQUE=GRAPHIQUE[0].cree_dict_valeurs(GRAPHIQUE[0].mc_liste) - if dGRAPHIQUE.has_key('FORMAT') and dGRAPHIQUE['FORMAT'] == 'GNUPLOT': - # On essaie d'importer Gnuplot -> PAS DE GRAPHIQUE - try: - import Gnuplot - except ImportError: - GRAPHIQUE == None - if INFO>=1: UTMESS('A','RECAL0_3') + GRAINE = None + + # Parametres concernant le recalage d'un modele dynamique + if args.has_key('DYNAMIQUE'): DYNAMIQUE = args['DYNAMIQUE'] + else: DYNAMIQUE = None #_____________________________________________ # - # VERIFICATION PREALABLE SUR MEM_ASTER + # VERIFICATION PREALABLE SUR GNUPLOT #_____________________________________________ - # Lecture du fichier .export - list_export = glob('*.export') - if len(list_export) == 0: - UTMESS('F','RECAL0_4') - elif len(list_export) >1: - UTMESS('F','RECAL0_5') + if GRAPHIQUE: + dGRAPHIQUE=GRAPHIQUE[0].cree_dict_valeurs(GRAPHIQUE[0].mc_liste) + if dGRAPHIQUE.has_key('FORMAT') and dGRAPHIQUE['FORMAT'] == 'GNUPLOT': + # On essaie d'importer Gnuplot -> PAS DE GRAPHIQUE + try: + import Gnuplot + except ImportError: + GRAPHIQUE == None + UTMESS('A','RECAL0_3') - prof = ASTER_PROFIL(list_export[0]) - try: - mem_aster = float(prof['mem_aster'][0]) - except ValueError: - mem_aster = 100.0 - memjeveux = prof.args.get('memjeveux') + #_____________________________________________ + # + # VERIFICATION PREALABLE SUR MEM_ASTER + #_____________________________________________ - if mem_aster in (0., 100.): - if INFO>=1: UTMESS('A','RECAL0_6') - mem_aster = 0. - if not memjeveux: - UTMESS('F','RECAL0_7') + if LANCEMENT == 'DISTRIBUTION': + + # Recuperation des parametres mem_aster et memjeveux + try: + mem_aster = float(prof['mem_aster'][0]) + except ValueError: + mem_aster = 100.0 + memjeveux = prof.args.get('memjeveux') + + if mem_aster in (0., 100.): + if CALCUL_ESCLAVE['MODE']=='INTERACTIF': UTMESS('A','RECAL0_6') + mem_aster = 0. + if not memjeveux: + UTMESS('F','RECAL0_7') + + try: + if mem_aster == 0.: + memjeveux_esclave = float(memjeveux) + else: + memjeveux_esclave = float(memjeveux) / float(mem_aster) * 100. - float(memjeveux) + except: + UTMESS('F','RECAL0_8') + + CALCUL_ESCLAVE['memjeveux_esclave'] = memjeveux_esclave + #CALCUL_ESCLAVE['mem_aster'] = mem_aster + UTMESS('I','RECAL0_9', valr=memjeveux_esclave) - try: - if mem_aster == 0.: - memjeveux_esclave = float(memjeveux) - else: - memjeveux_esclave = float(memjeveux) / float(mem_aster) * 100. - float(memjeveux) - except: - UTMESS('F','RECAL0_8') - if INFO>=1: UTMESS('I','RECAL0_9', valr=memjeveux_esclave) + if CALCUL_ESCLAVE['MODE']=='BATCH': + if CALCUL_ESCLAVE['CLASSE']: classe = CALCUL_ESCLAVE['CLASSE'] + else: classe = ' -auto- ' + UTMESS('I','RECAL0_69', valk=( str(CALCUL_ESCLAVE['TEMPS']), str(CALCUL_ESCLAVE['MEMOIRE']), classe ) ) #_____________________________________________ @@ -280,51 +287,37 @@ def macr_recal(UNITE_ESCL, RESU_EXP, POIDS, LIST_PARA, LIST_DERIV, RESU_CALC, # INITIALISATIONS #_____________________________________________ - # Liste des parametres utilisant la sensibilité - if not LIST_DERIV: LIST_DERIV = {} - LIST_SENSI = LIST_DERIV.keys() - # Stocke l'ordre initial des parametres pour restituer dans le bon ordre les valeurs en sortie de la macro LIST_NOM_PARA = [ para[0] for para in LIST_PARA ] # On classe les parametres - LIST_SENSI.sort() LIST_PARA.sort() - # Defini si on utilise le mot-clé SENSIBILITE pour IMPR_TABLE ou non - if len(LIST_SENSI) >0: table_sensibilite = True - else: table_sensibilite = False - - # Defini si on ajoute l'echo des calculs esclaves dans le mess du calcul maitre - follow_output = False - if SUIVI_ESCLAVE and SUIVI_ESCLAVE=='OUI': follow_output = True -# if( METHODE == 'EXTERNE') and mode_python: follow_output = opts.follow_output - - # Pour les algorithmes d'optimize, on a des limitations + # Pour les algorithmes d'optimize.py, on a des limitations if METHODE in ['FMIN', 'FMINBFGS', 'FMINNCG']: - # On ne peut tracer qu'a la derniere iteration - if GRAPHIQUE: - if GRAPHIQUE['AFFICHAGE']=='TOUTE_ITERATION': UTMESS('I', 'RECAL0_10', valk=METHODE) - # Les bornes ne sont pas gerees - UTMESS('I','RECAL0_11', valk=METHODE) + # On ne peut tracer qu'a la derniere iteration + if GRAPHIQUE: + if GRAPHIQUE['AFFICHAGE']=='TOUTE_ITERATION': UTMESS('I', 'RECAL0_10', valk=METHODE) + # Les bornes ne sont pas gerees + UTMESS('I','RECAL0_11', valk=METHODE) + #_______________________________________________ # # GESTION DE L'OPTION FACULTATIVE POUR LES POIDS #_______________________________________________ - if( POIDS == None): - POIDS=Numeric.ones(len(RESU_EXP)) + + if( POIDS == None): POIDS = NP.ones(len(RESU_EXP)) #_____________________________________________ # # GESTION DES ERREURS DE SYNTAXE #_____________________________________________ + texte_erreur, texte_alarme = gestion(UNITE_ESCL,LIST_PARA,RESU_CALC,RESU_EXP,POIDS,GRAPHIQUE,UNITE_RESU,METHODE) - if (texte_erreur != ""): - UTMESS('F', "RECAL0_12", valk=texte_erreur) - if (texte_alarme != ""): - UTMESS('A', "RECAL0_12", valk=texte_alarme) + if (texte_erreur != ""): UTMESS('F', "RECAL0_12", valk=texte_erreur) + if (texte_alarme != ""): UTMESS('A', "RECAL0_12", valk=texte_alarme) #_____________________________________________ @@ -332,188 +325,161 @@ def macr_recal(UNITE_ESCL, RESU_EXP, POIDS, LIST_PARA, LIST_DERIV, RESU_CALC, # INITIALISATIONS #_____________________________________________ - if( METHODE != 'EXTERNE'): - iter = 0 - restant,temps_iter=0.,0. - restant,temps_iter,err=reca_utilitaires.temps_CPU(restant,temps_iter) - - para,val,borne_inf,borne_sup = reca_utilitaires.transforme_list_Num(LIST_PARA,RESU_EXP) - - # Pour l'algorithme externe, les valeurs sont celles lues dans le fichier input.txt - if( METHODE == 'EXTERNE') and mode_python: val = val_externe - + iter = 0 + restant, temps_iter =0., 0. + restant, temps_iter, err = reca_utilitaires.temps_CPU(restant, temps_iter) + para, val, borne_inf, borne_sup = reca_utilitaires.transforme_list_Num(LIST_PARA, RESU_EXP) val_init = copy.copy(val) - # OBJET "PARAMETRES GLOBAUX" - PARAMETRES = reca_calcul_aster.PARAMETRES( - METHODE=METHODE, - UNITE_RESU=UNITE_RESU, - INFO=INFO, - fich_output='./REPE_OUT/output_esclave.txt', - mode_include=False, - follow_output=follow_output, - table_sensibilite=table_sensibilite, - memjeveux_esclave=memjeveux_esclave, - PARA_DIFF_FINI=PARA_DIFF_FINI, - ITER_MAXI=ITER_MAXI, - ITER_FONC_MAXI=ITER_FONC_MAXI, - ) - - if( METHODE == 'EXTERNE'): - PARAMETRES.fich_output = './tmp_macr_recal/output_esclave.txt' - type_fonctionnelle = 'float' - if args.has_key('FONCTIONNELLE') and args['FONCTIONNELLE'] == 'VECTORIELLE': - PARAMETRES.vector_output = True - type_fonctionnelle = 'vector' - - # On utilise le critere en erreur plutot que normalise - elif METHODE in ['FMIN', 'FMINBFGS', 'FMINNCG']: PARAMETRES.error_output = True + # Fonctionnelle en sortie (vectorielle ou scalaire) + if METHODE in ['FMIN', 'FMINBFGS', 'FMINNCG', 'GENETIQUE', 'HYBRIDE']: vector_output = False + else: vector_output = True # OBJET "CALCUL" - CALCUL_ASTER = reca_calcul_aster.CALCUL_ASTER(PARAMETRES, UL=UNITE_ESCL, para=para, reponses=RESU_CALC, LIST_SENSI=LIST_SENSI, LIST_DERIV=LIST_DERIV) + CALCUL_ASTER = reca_calcul_aster.CALCUL_ASTER( + jdc = self, + METHODE = METHODE, + UNITE_ESCL = UNITE_ESCL, + UNITE_RESU = UNITE_RESU, + para = para, + reponses = RESU_CALC, + PARA_DIFF_FINI = PARA_DIFF_FINI, + vector_output = vector_output, + DYNAMIQUE = DYNAMIQUE, + #LANCEMENT = LANCEMENT, + CALCUL_ESCLAVE = CALCUL_ESCLAVE, + INFO = INFO, + ) + + CALCUL_ASTER.RESU_EXP = RESU_EXP + CALCUL_ASTER.RESU_CALC = RESU_CALC + CALCUL_ASTER.LIST_PARA = LIST_PARA - # Instances des classes pour le calcul de l'erreur et le dimensionnemnt/adim - Simul = reca_interp.Sim_exp(RESU_EXP,POIDS) - Dim = reca_algo.Dimension(copy.copy(val_init),para) - CALCUL_ASTER.Simul = Simul + # Instances des classes pour le calcul de l'erreur et le dimensionnemnt/adim + Dim = reca_algo.Dimension(copy.copy(val_init)) + CALCUL_ASTER.Simul = reca_interp.Sim_exp(RESU_EXP,POIDS) CALCUL_ASTER.Dim = Dim CALCUL_ASTER.reca_algo = reca_algo - if (GRAPHIQUE): - CALCUL_ASTER.UNITE_GRAPHIQUE = GRAPHIQUE['UNITE'] + if (GRAPHIQUE): CALCUL_ASTER.UNITE_GRAPHIQUE = GRAPHIQUE['UNITE'] + # Dans le cas de la dynamique avec appariement manual des MAC, on passe la flag correspondant a True + if METHODE == 'HYBRIDE': + if (DYNAMIQUE!=None and DYNAMIQUE['APPARIEMENT_MANUEL']=='OUI'): CALCUL_ASTER.graph_mac=True # Instance de la classe gérant l'affichage des resultats du calcul de l'optimisation Mess = reca_message.Message(para,RESU_EXP,copy.copy(val_init),UNITE_RESU) + Mess.initialise() + +# # Calcul de F +# erreur = CALCUL_ASTER.calcul_F(val) +# # Calcul de F et G +# erreur, residu, A_nodim, A = CALCUL_ASTER.calcul_FG(val) +# sys.exit() + - if( METHODE != 'EXTERNE'): - Mess.initialise() - if INFO>=1: UTMESS('I','RECAL0_13', valk=METHODE, cc=Mess.get_filename()) + # Mode INCLUDE : on doit executer les commandes PRE ici + if LANCEMENT=='INCLUSION': + UNITE_INCLUDE=UNITE_ESCL + recal.make_include_files(UNITE_INCLUDE=UNITE_INCLUDE, calcul=RESU_CALC, parametres=LIST_PARA) + pre = "fort.%s.pre" % UNITE_INCLUDE + #if os.path.isfile(pre): recal.execfile(filename) #------------------------------------------------------------------------------- - # Methode EXTERNE (en fait juste une evaluation de la fonction puis on sort) + # Pas d'optimisation (juste une evaluation de la fonctionnelle pour le point courant) + #------------------------------------------------------------------------------- # - if( METHODE == 'EXTERNE'): - - # On sauvegarde le fichier esclave si celui-ci est fort.UL (sinon il sera ecrase) - fic_esclave = './fort.'+str(UNITE_ESCL) - txt_old_esclave = None - if os.path.isfile(fic_esclave): - f = open(fic_esclave,'r') - txt_old_esclave = f.read() - f.close() - -# try: os.remove('./fort.'+str(UNITE_ESCL)) -# except: pass - - # Fichier bilan - txt = '\nPARAMETRES : ' + str([ para[0] for para in LIST_PARA ]) + ' ' + str(val) - Mess.ecrire(txt) - - # Execution de l'esclave - if args.has_key('GRADIENT') and args['GRADIENT']!='NON_CALCULE': - - # Calcul de F et G - fonctionnelle, residu, A_nodim, A = CALCUL_ASTER.calcul_FG(val) - - # Ecriture du fichier grad.txt contenant les derivees - if args['GRADIENT'] == 'ADIMENSIONNE': gradient = A - else: gradient = A_nodim - - # Ecriture du fichier contenant le gradient - if not mode_python: Ecriture_Derivees(output_file='./fort.1901', derivees=gradient) - - else: - # Calcul de F - fonctionnelle = CALCUL_ASTER.calcul_F(val) - gradient = None - - # Ecriture du fichier contenant la fonctionnelle - if not mode_python: Ecriture_Fonctionnelle(output_file='./fort.1900', type_fonctionnelle=type_fonctionnelle, fonctionnelle=fonctionnelle) - - # Fichier bilan - if type(fonctionnelle) == float: txt = '---> fonctionnelle : ' + str(fonctionnelle) - else: txt = '---> norme fonctionnelle : ' + str( math.sqrt( (Numeric.sum( [x**2 for x in fonctionnelle] )) ) ) - Mess.ecrire(txt) - - # Affichage de la valeur de la fonctionnelle - if mode_python and opts.INFO==-1: print txt - - # Affichage de la norme du gradient (AA: a remplacer par une formule de norme L2 !!) - if gradient: - norme = 0 - for l in range(len(gradient[:,0])): - for c in range(len(gradient[0,:])): - norme += ( gradient[l,c] * gradient[l,c] ) - norme = math.sqrt(norme) - txt = '---> norme du gradient : ' + str(norme) - Mess.ecrire(txt) - if mode_python and opts.INFO==-1: print txt - - - try: os.remove('./fort.'+str(UNITE_ESCL)) - except: pass - - # On remet l'ancien fichier esclave si c'etait fort.UL - if txt_old_esclave: - f = open(fic_esclave,'w') - f.write(txt_old_esclave) - f.close() - - - L_F = CALCUL_ASTER.L - iter = None - - # On va ensuite jusqu'au bout (pour l'impression des graphes) - + if ITER_MAXI<=0: + erreur = CALCUL_ASTER.calcul_F(val) + residu = 0 + iter = 0 + L_F = CALCUL_ASTER.Lcalc[0] + CALCUL_ASTER.evaluation_fonction = 1 #------------------------------------------------------------------------------- # Algorithme FMIN (pas d'adimensionnement car n'utilise pas de gradient) + #------------------------------------------------------------------------------- # - elif( METHODE == 'FMIN'): - val, fval, warnflag = fmin(CALCUL_ASTER.calcul_F, val, maxiter=ITER_MAXI, maxfun=ITER_FONC_MAXI, fulloutput=1) + elif (METHODE == 'FMIN'): + UTMESS('I','RECAL0_13', valk=METHODE, cc=Mess.get_filename()) + val, fval, warnflag = fmin(CALCUL_ASTER.calcul_F, val, maxiter=ITER_MAXI, maxfun=ITER_FONC_MAXI, fulloutput=1) - iter_fonc = CALCUL_ASTER.evaluation_fonction + iter_fonc = CALCUL_ASTER.evaluation_fonction + if warnflag==1: UTMESS('I','RECAL0_54', cc=Mess.get_filename()) + if warnflag==2: UTMESS('I','RECAL0_55', cc=Mess.get_filename()) + Mess.affiche_etat_final_convergence(iter,ITER_MAXI,iter_fonc,ITER_FONC_MAXI, RESI_GLOB_RELA,residu=0,Act=[]) + Mess.affiche_fonctionnelle(fval) + Mess.affiche_valeurs(val) + nomres = Sortie(LIST_NOM_PARA, LIST_PARA, val, CALCUL_ASTER, Mess) + return - Mess.ecrire("\nDerniere iteration : ") - Mess.affiche_etat_final_convergence(iter,ITER_MAXI,iter_fonc,ITER_FONC_MAXI, RESI_GLOB_RELA,residu=0,Act=[]) - Mess.affiche_fonctionnelle(fval) - Mess.affiche_valeurs(val) - if warnflag==1: Mess.ecrire("Attention : le nombre maximum d'evaluations de la fonction (ITER_FONC_MAXI) a ete atteint") - if warnflag==2: Mess.ecrire("Attention : le nombre maximum d'iteration de l'algorithme (ITER_MAXI) a ete atteint") - nomres = Sortie(LIST_NOM_PARA, LIST_PARA, val, CALCUL_ASTER, Mess) + #------------------------------------------------------------------------------- + # Algorithme GENETIQUE (pas d'adimensionnement car n'utilise pas de gradient) + #------------------------------------------------------------------------------- + # + elif (METHODE == 'GENETIQUE'): + UTMESS('I','RECAL0_13', valk=METHODE, cc=Mess.get_filename()) + from Macro.reca_evol import evolutivo + nb_parents = NB_PARENTS + nb_fils = NB_FILS + nb_iter = ITER_ALGO_GENE + sigma = ECART_TYPE + err_min = RESI_ALGO_GENE + graine = GRAINE + val = evolutivo(CALCUL_ASTER,val,nb_iter,err_min,nb_parents,nb_fils,sigma, borne_inf, borne_sup,graine) + nomres = Sortie(LIST_NOM_PARA, LIST_PARA,val, CALCUL_ASTER, Mess) return - else: - #------------------------------------------------------------------------------- - # Pour tous les autres methodes, on adimensionne - - # Calcul d'initialisation de F, ici L_deriv_sensible ne contient que les termes calculés par la sensibilité, les autres termes sont nuls - L_init, L_deriv_sensible = CALCUL_ASTER.calcul_Aster(val, INFO) - - L_J_init, erreur = Simul.multi_interpole(L_init, RESU_CALC) - J_init = Simul.norme_J(copy.copy(L_J_init),copy.copy(L_J_init),UNITE_RESU) - J = J_init - - A = Simul.sensibilite(CALCUL_ASTER, L_init, L_deriv_sensible, val, PARA_DIFF_FINI) - A = Dim.adim_sensi(A) - l = reca_algo.lambda_init(Numeric.matrixmultiply(Numeric.transpose(A),A)) + #------------------------------------------------------------------------------- + # Pour tous les autres methodes, on adimensionne + #------------------------------------------------------------------------------- + # + else: - gradient_init =reca_algo.calcul_gradient(A,erreur) #utile pour le test de convergence, on prend les valeurs dimensionnées - residu = reca_algo.test_convergence(gradient_init,erreur,A,Numeric.zeros(len(gradient_init),Numeric.Float)) - - Mess.affiche_result_iter(iter,J,val,residu,Numeric.array([])) - # On teste un manque de temps CPU - restant,temps_iter,err=reca_utilitaires.temps_CPU(restant,temps_iter) - if (err==1): - ier=ier+1 - return ier + #------------------------------------------------------------------------------- + # Si METHODE=='HYBRIDE', on lance d'abord l'algo genetique et ensuite celui de + # Levenberg-Marquardt qui demarre avec le jeu de parametres issu de genetique + if (METHODE == 'HYBRIDE'): + from Macro.reca_evol import evolutivo + nb_parents = NB_PARENTS + nb_fils = NB_FILS + nb_iter = ITER_ALGO_GENE + sigma = ECART_TYPE + err_min = RESI_ALGO_GENE + graine = GRAINE + val_gene = evolutivo(CALCUL_ASTER,val,nb_iter,err_min,nb_parents,nb_fils,sigma, borne_inf, borne_sup,graine) + val = copy.copy(val_gene) + val_init = copy.copy(val) + # AA ? CALCUL_ASTER.graph_mac = True + + + # Calcul de F et G + erreur, residu, A_nodim, A = CALCUL_ASTER.calcul_FG(val) + E = CALC_ERROR(experience=RESU_EXP, X0=val, calcul=RESU_CALC, poids=POIDS) + E.CalcError(CALCUL_ASTER.Lcalc) + E.CalcSensibilityMatrix(CALCUL_ASTER.Lcalc, val, dX=None, pas=PARA_DIFF_FINI) + + L_init = E.L_init + L_J_init = E.L_J_init + J_init = E.J_init + J = E.J + A = E.A + A_nodim = E.A_nodim + erreur = E.erreur + residu = E.residu + gradient_init = E.gradient_init + + # Calcul du lambda_init + l = reca_algo.lambda_init(NP.dot(NP.transpose(A),A)) + + + Mess.affiche_result_iter(iter,J,val,residu,NP.array([])) CALCUL_ASTER.L_init = L_init CALCUL_ASTER.L_J_init = L_J_init @@ -522,35 +488,46 @@ def macr_recal(UNITE_ESCL, RESU_EXP, POIDS, LIST_PARA, LIST_DERIV, RESU_CALC, CALCUL_ASTER.gradient_init = gradient_init CALCUL_ASTER.residu_init = residu + # On teste un manque de temps CPU + restant,temps_iter,err=reca_utilitaires.temps_CPU(restant,temps_iter) + if (err==1): + ier=ier+1 + return ier + #------------------------------------------------------------------------------- # Methode FMINBFGS et FMINNCG - + #------------------------------------------------------------------------------- + # if METHODE in ['FMINBFGS', 'FMINNCG']: + + UTMESS('I','RECAL0_13', valk=METHODE, cc=Mess.get_filename()) + # Derivees - fprime=CALCUL_ASTER.calcul_G + f = CALCUL_ASTER.calcul_F2 + fprime = CALCUL_ASTER.calcul_G warnflag=0 - if args.has_key('GRADIENT') and args['GRADIENT'] == 'NON_CALCULE': fprime=None + if args.has_key('GRADIENT') and args['GRADIENT'] == 'NON_CALCULE': + f = CALCUL_ASTER.calcul_F + fprime = None if fprime: UTMESS('I','RECAL0_14') else: UTMESS('I','RECAL0_15') # Lancement de l'optimisation if METHODE == 'FMINBFGS': - val, fval, func_calls, grad_calls, warnflag = fminBFGS(CALCUL_ASTER.calcul_F, val, fprime=fprime, maxiter=ITER_MAXI, avegtol=RESI_GLOB_RELA, fulloutput=1) + val, fval, func_calls, grad_calls, warnflag = fminBFGS(f=f, x0=val, fprime=fprime, maxiter=ITER_MAXI, avegtol=RESI_GLOB_RELA, fulloutput=1) elif METHODE == 'FMINNCG': - val, fval, func_calls, grad_calls, hcalls, warnflag = fminNCG(CALCUL_ASTER.calcul_F, val, fprime=fprime, fhess_p=None, fhess=None, maxiter=ITER_MAXI, avextol=RESI_GLOB_RELA, fulloutput=1) + val, fval, func_calls, grad_calls, hcalls, warnflag = fminNCG(f=f, x0=val, fprime=fprime, fhess_p=None, fhess=None, maxiter=ITER_MAXI, avextol=RESI_GLOB_RELA, fulloutput=1) # Affichage des messages de sortie iter_fonc = CALCUL_ASTER.evaluation_fonction - Mess.ecrire("\nDerniere iteration : ") - Mess.affiche_etat_final_convergence(iter,ITER_MAXI,iter_fonc,ITER_FONC_MAXI, RESI_GLOB_RELA,residu=0,Act=[]) + if warnflag: UTMESS('I','RECAL0_55', cc=Mess.get_filename()) + Mess.affiche_etat_final_convergence(iter,ITER_MAXI,iter_fonc,ITER_FONC_MAXI, RESI_GLOB_RELA, residu=0, Act=[]) Mess.affiche_fonctionnelle(fval) Mess.affiche_valeurs(val) -# if warnflag==1: Mess.ecrire("\nAttention : le nombre maximum d'evaluations de la fonction (ITER_FONC_MAXI) a ete atteint") -# if warnflag==2: Mess.ecrire("\nAttention : le nombre maximum d'iteration de la methode (ITER_MAXI) a ete atteint") # Permet d'avoir un diagnostic NOOK pour le job if warnflag: iter=ITER_MAXI @@ -559,55 +536,91 @@ def macr_recal(UNITE_ESCL, RESU_EXP, POIDS, LIST_PARA, LIST_DERIV, RESU_CALC, residu = fval - - #------------------------------------------------------------------------------- # Methode Levenberg-Marquardt - else: - - #_____________________________________________ + #------------------------------------------------------------------------------- + elif METHODE in ['LEVENBERG', 'HYBRIDE']: + + #___________________________________________________________ # - # BOUCLE PRINCIPALE DE L'ALGORITHME - #_____________________________________________ + # BOUCLE PRINCIPALE DE L'ALGORITHME de Levenberg-Marquardt + #___________________________________________________________ + + UTMESS('I','RECAL0_13', valk=METHODE, cc=Mess.get_filename()) epsilon = 10.*RESI_GLOB_RELA - while((residu > RESI_GLOB_RELA) & (iter=2: UTMESS('I','RECAL0_93', valk=str(val_externe)) - if optparse_INFO and opts.INFO == -1: print '\n'+ str(val_externe) - - - # ------------------------------------------------------------------- - # Efface les fichiers d'entree et de sortie - try: os.remove(input_file) - except: pass - try: os.remove(output_file) - except: pass - try: os.remove(output_grad) - except: pass - - - - - # -------------------------------------------------------------------------------------------------------- - # -------------------------------------------------------------------------------------------------------- - # -------------------------------------------------------------------------------------------------------- - # Ci-dessous on extrait le fichier de commande jusqu'a la commande MACR_RECAL exclue (fichiernew) - # Puis la commande MACR_RECAL (commandenew) - # Ensuite on annule l'effet des commandes Aster et on evalue en Python les deux chaines de textes - - # Lecture du fichier .comm - f=open(nom_comm,'r') - fichier=f.read() - f.close - - # Extraction des deux parties dans le fichier de commande - fichiernew=None - commandenew=None - nb_par=-99 - txt1='MACR_RECAL' - txt2='(' - txt3=')' - for ligne in fichier.split('\n'): - if ligne.find( txt1 )!=-1 and ligne.find( txt2 )!=-1 and ligne.strip()[0]!='#': - nb_par=0 - index_deb1 = fichier.index(ligne) - fichiernew=fichier[:index_deb1] -# if debug: print 80*'*' + 2*'\n'+fichiernew+80*'*' + 2*'\n' - if fichiernew and ligne.find( txt2 )!=-1: nb_par+=1 - if fichiernew and ligne.find( txt3 )!=-1: nb_par-=1 - if fichiernew and nb_par==0: - index_fin1 = fichier.index(ligne)+len(ligne) - commandenew=fichier[index_deb1:index_fin1] - - # Remplace le nom de concept a gauche du signe egal - index_deb2 = commandenew.index(txt1) - commandenew='fonctionnelle, gradient='+commandenew[index_deb2:]+ '\n' - - if debug: print 80*'*' + 2*'\n'+commandenew+80*'*' + 2*'\n' - break - if not fichiernew or not commandenew: - UTMESS('F','RECAL0_92', valk=nom_comm) - - - # ------------------------------------------------------------------- - # Import du module Utilitai - sys.path.append(os.path.join(os.getcwd(), 'Python')) - sys.path.append(os.path.join(os.environ['ASTER_ROOT'], os.environ['ASTER_VERSION'], 'bibpyt')) - try: - import Utilitai - from Utilitai.System import ExecCommand - except: - UTMESS('F','RECAL0_91') - - - # ------------------------------------------------------------------- - # On annule les commandes Aster du fichier maitre .comm - def DEBUT(*args, **kwargs): pass - def FIN(*args, **kwargs): pass - def MACR_RECAL(*args, **kwargs): pass - def _F(*args, **kwargs): return kwargs - def DEFI_LIST_REEL(*args, **kwargs): pass - def DEFI_FONCTION(*args, **kwargs): pass - def TEST_FONCTION(*args, **kwargs): pass - def DEFI_CONSTANTE(*args, **kwargs): pass - - - # ------------------------------------------------------------------- - # Evaluation du fichier de commande Aster jusqu'a MACR_RECAL - lance_aster = False - try: - exec(fichiernew) - except: - txt = "Le mode EXTERNE tourne en mode degrade. Lire la documentation." - UTMESS('A','RECAL0_90') - lance_aster = True - else: - exec(commandenew.replace(txt1, 'macr_recal_externe')) -# try: -# exec(commandenew.replace(txt1, 'macr_recal_externe')) -# except Exception, err: -# print err -# txt = "Erreur lors de l'execution de la commande MACR_RECAL" -# UTMESS('F','RECAL0_12',valk=txt) - - Ecriture_Fonctionnelle(output_file, type_fonctionnelle, fonctionnelle) - Ecriture_Derivees(output_grad, gradient) - - - - # -------------------------------------------------------------------------------------------------------- - # -------------------------------------------------------------------------------------------------------- - # -------------------------------------------------------------------------------------------------------- - # Si l'evaluation du fichier de commande Aster jusqu'a MACR_RECAL a echoue, on execute Aster "normalement" - if lance_aster: - - _PARAM_ = '_PARAM_' - new_fichier_comm = os.getcwd() + os.sep + 'tmp_comm' - new_fichier_export = os.getcwd() + os.sep + fichier_export.split('/')[-1] + '_new' - - # Lecture du fichier .comm - f=open(nom_comm,'r') - fichier=f.read() - f.close - - # ------------------------------------------------------------------- - # Modification du fichier .comm (changement des valeurs, ecriture du resultat dans un fichier) - if INFO==2: UTMESS('I','RECAL0_89',valk=nom_comm) - f = open(nom_comm, 'r') - ok1 = ok3 = ok4 = False - txt = '' - for ligne in f: - if ligne.find('MACR_RECAL')!=-1 and ligne.strip()[0]!='#': # On determine le nom du concept sortant de MACR_RECAL - ok3 = True - _RESU_ = ligne.split('=')[0].strip() - txt += ligne - elif ligne.strip()[:len(_PARAM_)] == _PARAM_: # On change les parametres : la variables _PARAM_ - ok1 = True - txt += _PARAM_ + " = " + str(val_externe) + '\n' - elif ligne.find('METHODE')!=-1 and ligne.strip()[0]!='#': # On verifie bien que la methode externe est choisi - if ligne.find("EXTERNE")!=-1: - ok4 = True - txt += ligne - else: txt += ligne - f.close() - - if not ok1: UTMESS('F','RECAL0_88',valk=_PARAM_) - if not ok3: UTMESS('F','RECAL0_87') - if not ok4: UTMESS('F','RECAL0_86') - - txt = txt.replace('_RESU_', _RESU_) - - # Ecriture du nouveau fichier comm temporaire - if INFO==2: UTMESS('I','RECAL0_85',valk=new_fichier_comm) - f = open(new_fichier_comm, 'w') - f.write(txt) - f.close() - - # On remplace dans l'export par le nouveau .comm - prof = ASTER_PROFIL(fichier_export) - for lab in ('data', 'resu'): - l_fr = getattr(prof, lab) - l_tmp = l_fr[:] - for dico in l_tmp: - # fichiers - if not dico['isrep']: - # On remplace par le nouveau .comm - if dico['type'] == 'comm' and dico['ul'] == '1': - dico['path'] = new_fichier_comm - -# if lab == 'resu': -# dico['path'] = os.path.join(tmp_macr_recal, os.path.basename(dico['path'])) - - # On ajoute au profil le fichier output.txt (unite logique 1900) - try: os.remove('./fort.1900') - except: pass - if not output_file.find(os.sep)!=-1: output_file = os.getcwd() + os.sep + output_file - prof.Set('R', {'type':'libr', 'isrep':False, 'path': output_file, 'ul':1900, 'compr': False} ) - - # On ajoute au profil le fichier grad.txt (unite logique 1901) - if optparse_gradient and opts.gradient!='no': - try: os.remove('./fort.1901') - except: pass - output_grad = opts.gradient - if not output_grad.find(os.sep)!=-1: output_grad = os.getcwd() + os.sep + output_grad - prof.Set('R', {'type':'libr', 'isrep':False, 'path': output_grad, 'ul':1901, 'compr': False} ) - - - # Ecriture du nouveau fichier export - try: - if INFO==2: UTMESS('I','RECAL0_85',valk=new_fichier_export) - prof.WriteExportTo(new_fichier_export) - except: - UTMESS('F','RECAL0_84',valk=new_fichier_export) - if debug: prof.WriteExportTo('/tmp/exp') - - - # chemin vers as_run - if os.environ.has_key('ASTER_ROOT'): - as_run = os.path.join(os.environ['ASTER_ROOT'], 'ASTK', 'ASTK_SERV', 'bin', 'as_run') - else: - as_run = 'as_run' - if INFO>=1: UTMESS('A', 'RECAL0_83') - - - # Import du module Utilitai - sys.path.append(os.path.join(os.environ['ASTER_ROOT'], os.environ['ASTER_VERSION'], 'bibpyt')) - try: - import Utilitai - from Utilitai.System import ExecCommand - except: - UTMESS('F','RECAL0_91') - - - # Lancement d'Aster avec le deuxieme export - cmd = '%s %s' % (as_run, new_fichier_export) - if INFO>=2: UTMESS('I','EXECLOGICIEL0_8',valk=cmd) - iret, txt_output = ExecCommand(cmd, follow_output=opts.follow_output,verbose=opts.follow_output) - if INFO>=2: UTMESS('I','EXECLOGICIEL0_12',valk=cmd) - - try: os.remove(new_fichier_comm) - except: pass - try: os.remove(new_fichier_export) - except: pass - - diff --git a/Aster/Cata/cataSTA10/Macro/macro_elas_mult_ops.py b/Aster/Cata/cataSTA10/Macro/macro_elas_mult_ops.py index 0d5a4139..6e05cae2 100644 --- a/Aster/Cata/cataSTA10/Macro/macro_elas_mult_ops.py +++ b/Aster/Cata/cataSTA10/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 23/03/2010 AUTEUR COURTOIS M.COURTOIS # -*- 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,27 @@ 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) + assert len(lchar1) > 0 + + + 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 +146,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 : @@ -153,46 +164,45 @@ def macro_elas_mult_ops(self,MODELE,CHAM_MATER,CARA_ELEM,NUME_DDL, motscle2={} if CHAM_MATER : motscle2['CHAM_MATER']=CHAM_MATER if CARA_ELEM : motscle2['CARA_ELEM']=CARA_ELEM - if CHAM_MATER or CARA_ELEM : - if ielas : - motscles['AFFE']=[] - for m in CAS_CHARGE: - motscles['AFFE'].append(_F(MODELE=MODELE, - CHAM_GD=nomchn[iocc], - NOM_CAS=m['NOM_CAS'], - **motscle2) ) - iocc=iocc+1 - else : - motscles['AFFE']=[] - for m in CAS_CHARGE: - motscles['AFFE'].append(_F(MODELE=MODELE, - CHAM_GD=nomchn[iocc], - NUME_MODE=m['MODE_FOURIER'], - TYPE_MODE=m['TYPE_MODE'], - **motscle2) ) - iocc=iocc+1 - else: - if ielas : - motscles['AFFE']=[] - for m in CAS_CHARGE: - motscles['AFFE'].append(_F(MODELE=MODELE, - CHAM_GD=nomchn[iocc], - NOM_CAS=m['NOM_CAS'],) ) - iocc=iocc+1 - else : - motscles['AFFE']=[] - for m in CAS_CHARGE: - motscles['AFFE'].append(_F(MODELE=MODELE, - CHAM_GD=nomchn[iocc], - NUME_MODE=m['MODE_FOURIER'], - TYPE_MODE=m['TYPE_MODE'],) ) - iocc=iocc+1 - + if ielas : + motscles['AFFE']=[] + for m in CAS_CHARGE: + if len(lcharg[iocc]) > 0 : + motscles['AFFE'].append(_F(MODELE=MODELE, + CHAM_GD=nomchn[iocc], + NOM_CAS=m['NOM_CAS'], + CHARGE=lcharg[iocc], + **motscle2) ) + else : + motscles['AFFE'].append(_F(MODELE=MODELE, + CHAM_GD=nomchn[iocc], + NOM_CAS=m['NOM_CAS'], + **motscle2) ) + iocc=iocc+1 + else : + motscles['AFFE']=[] + for m in CAS_CHARGE: + if len(lcharg[iocc]) > 0 : + motscles['AFFE'].append(_F(MODELE=MODELE, + CHAM_GD=nomchn[iocc], + NUME_MODE=m['MODE_FOURIER'], + TYPE_MODE=m['TYPE_MODE'], + CHARGE=lcharg[iocc], + **motscle2) ) + else : + motscles['AFFE'].append(_F(MODELE=MODELE, + CHAM_GD=nomchn[iocc], + NUME_MODE=m['MODE_FOURIER'], + TYPE_MODE=m['TYPE_MODE'], + **motscle2) ) + iocc=iocc+1 + if self.reuse: + motscles['reuse'] = self.reuse nomres=CREA_RESU(OPERATION='AFFE',TYPE_RESU=tyresu,NOM_CHAM='DEPL',**motscles) ##################################################################### -# boucle sur les items de CAS_CHARGE pour CALC_ELEM ete CALC_NO +# boucle sur les items de CAS_CHARGE pour CALC_ELEM et CALC_NO iocc=0 for m in CAS_CHARGE: @@ -204,72 +214,41 @@ def macro_elas_mult_ops(self,MODELE,CHAM_MATER,CARA_ELEM,NUME_DDL, liste_el=[] liste_no=[] if type(m['OPTION'])==types.StringType: - if m['OPTION'] in ('FORC_NODA','REAC_NODA', + liste_option=(m['OPTION'],) + else : + liste_option=m['OPTION'] + for option in liste_option : + if option in ( 'FORC_NODA','REAC_NODA', 'EPSI_NOEU_DEPL','SIGM_NOEU_DEPL','EFGE_NOEU_DEPL', - 'EQUI_NOEU_SIGM','EQUI_NOEU_EPSI','FLUX_NOEU_TEMP',): + 'EQUI_NOEU_SIGM','EQUI_NOEU_EPSI',): nbno=nbno+1 - liste_no.append(m['OPTION']) + liste_no.append(option) else: nbel=nbel+1 - liste_el.append(m['OPTION']) - else: - for opt in m['OPTION']: - if opt in ('FORC_NODA','REAC_NODA', - 'EPSI_NOEU_DEPL','SIGM_NOEU_DEPL','EFGE_NOEU_DEPL', - 'EQUI_NOEU_SIGM','EQUI_NOEU_EPSI','FLUX_NOEU_TEMP',): - nbno=nbno+1 - liste_no.append(opt) - else: - nbel=nbel+1 - liste_el.append(opt) - - lreac=0 + liste_el.append(option) + if nbel: motscles={} - if CHAM_MATER : motscles['CHAM_MATER'] =CHAM_MATER - if CARA_ELEM : motscles['CARA_ELEM'] =CARA_ELEM if ielas: motscles['NOM_CAS']=m['NOM_CAS'] 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)) 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), **motscles) if nbno: motscles={} - if CHAM_MATER : motscles['CHAM_MATER'] =CHAM_MATER - if CARA_ELEM : motscles['CARA_ELEM'] =CARA_ELEM if ielas: motscles['NOM_CAS']=m['NOM_CAS'] 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)) CALC_NO(reuse=nomres, RESULTAT=nomres, - MODELE=MODELE, OPTION=tuple(liste_no), - **motscles) + **motscles) # fin de la boucle sur les items de CAS_CHARGE ##################################################################### diff --git a/Aster/Cata/cataSTA10/Macro/macro_expans_ops.py b/Aster/Cata/cataSTA10/Macro/macro_expans_ops.py index 96da78d9..44f99c68 100644 --- a/Aster/Cata/cataSTA10/Macro/macro_expans_ops.py +++ b/Aster/Cata/cataSTA10/Macro/macro_expans_ops.py @@ -1,4 +1,4 @@ -#@ MODIF macro_expans_ops Macro DATE 16/11/2009 AUTEUR COURTOIS M.COURTOIS +#@ MODIF macro_expans_ops Macro DATE 28/01/2010 AUTEUR BODEL C.BODEL # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -19,17 +19,14 @@ # ====================================================================== -# MODIF : 24/07/2007. BODEL : suppression du mc NUME_DDL. Le nume_ddl par -# defaut pour PROJ_CHAMP est celui du modèle expérimental. - def macro_expans_ops( self, MODELE_CALCUL, MODELE_MESURE, - NUME_DDL=None, - RESU_NX=None, - RESU_EX=None, - RESU_ET=None, - RESU_RD=None, + NUME_DDL, + RESU_NX, + RESU_EX, + RESU_ET, + RESU_RD, MODES_NUM=None, MODES_EXP=None, RESOLUTION=None, @@ -58,7 +55,8 @@ def macro_expans_ops( self, # on cree un resultat RESU_NX par extraction de NUME_ORDREs is_nume_num = 1 else: - if RESU_NX: UTMESS('A','MEIDEE0_6',valk=['MODELE_MESURE','RESU_EX']) + if RESU_NX: + UTMESS('A','MEIDEE0_6',valk=['MODELE_MESURE','RESU_EX']) if MODELE_MESURE['NUME_MODE'] or MODELE_MESURE['NUME_ORDRE']: # On cree un RESU_EX par extraction de NUME_ORDREs is_nume_exp = 1 @@ -76,9 +74,10 @@ def macro_expans_ops( self, # Extraction des modes numériques # ------------------------------- if not is_nume_num: - RESU_NX = RESU_NUM + resu_nx = RESU_NUM else: - self.DeclareOut( "RESU_NX", RESU_NX ) + if RESU_NX: + self.DeclareOut( "RESU_NX", RESU_NX ) mfact = {'MODE':RESU_NUM} if MODELE_CALCUL['NUME_MODE']: mfact.update({'NUME_MODE':MODELE_CALCUL['NUME_MODE']}) @@ -86,14 +85,16 @@ def macro_expans_ops( self, mfact.update({'NUME_ORDRE':MODELE_CALCUL['NUME_ORDRE']}) RESU_NX = EXTR_MODE( FILTRE_MODE = mfact ) + resu_nx = RESU_NX # Extraction des modes expérimentaux # ---------------------------------- if not is_nume_exp: - RESU_EX = RESU_EXP + resu_ex = RESU_EXP else: - self.DeclareOut( "RESU_EX", RESU_EX ) + if RESU_EX: + self.DeclareOut( "RESU_EX", RESU_EX ) mfact = {'MODE':RESU_EXP} if MODELE_MESURE['NUME_MODE']: mfact.update({'NUME_MODE':MODELE_MESURE['NUME_MODE']}) @@ -101,25 +102,26 @@ def macro_expans_ops( self, mfact.update({'NUME_ORDRE':MODELE_MESURE['NUME_ORDRE']}) RESU_EX = EXTR_MODE( FILTRE_MODE = mfact ) + resu_ex = RESU_EX - # Projection des modes experimentaux - on passe le mot-clef + # Projection des modes experimentaux - on passe le mot-cle # RESOLUTION directement à PROJ_MESU_MODAL - # --------------------------------------------------------- + # -------------------------------------------------------- # Mot-clé facteur de résolution - mfact = [] for m in RESOLUTION: if m['METHODE'] == 'SVD': - mfact.append({'METHODE':'SVD','EPS':m['EPS']}) - if m['METHODE'] == 'LU': - mfact.append({'METHODE':'LU'}) - if m['REGUL'] != 'NON': - if m['COEF_PONDER']: - mfact.append({'COEF_PONDER':m['COEF_PONDER']}) - if m['COEF_PONDER_F']: - mfact.append({'COEF_PONDER_F':m['COEF_PONDER_F']}) + mfact={'METHODE':'SVD','EPS':m['EPS']} + if m['REGUL'] != 'NON': + mfact.update({'REGUL':m['REGUL']}) + if m['COEF_PONDER']: + mfact.update({'COEF_PONDER':m['COEF_PONDER']}) + if m['COEF_PONDER_F']: + mfact.update({'COEF_PONDER_F':m['COEF_PONDER_F']}) + elif m['METHODE'] == 'LU': + mfact = {'METHODE':'LU'} # Paramètres à garder : si on étend des mode_meca, on conserve les # freq propres, amortissements réduits, et masses généralisées. Pour @@ -135,10 +137,10 @@ def macro_expans_ops( self, try: - __PROJ = PROJ_MESU_MODAL(MODELE_CALCUL = _F( BASE=RESU_NX, + __PROJ = PROJ_MESU_MODAL(MODELE_CALCUL = _F( BASE=resu_nx, MODELE=MOD_CALCUL, ), - MODELE_MESURE = _F( MESURE=RESU_EX, + MODELE_MESURE = _F( MESURE=resu_ex, MODELE=MOD_MESURE, NOM_CHAM=NOM_CHAM, ), @@ -151,9 +153,9 @@ def macro_expans_ops( self, # Phase de reconstruction des donnees mesurees sur le maillage # numerique # ------------------------------------------------------------ - self.DeclareOut( "RESU_ET", RESU_ET ) + if RESU_ET: + self.DeclareOut( "RESU_ET", RESU_ET ) RESU_ET = REST_GENE_PHYS( RESU_GENE = __PROJ, - MODE_MECA = RESU_NX, TOUT_ORDRE = 'OUI', NOM_CHAM = NOM_CHAM); @@ -161,13 +163,12 @@ def macro_expans_ops( self, # Restriction des modes mesures etendus sur le maillage capteur # ------------------------------------------------------------- - self.DeclareOut( "RESU_RD", RESU_RD ) - refd1 = aster.getvectjev(RESU_EXP.nom.ljust(19)+".REFD") - refd2 = aster.getvectjev(RESU_EX.nom.ljust(19)+".REFD") + if RESU_RD: + self.DeclareOut( "RESU_RD", RESU_RD ) nume=None - if RESU_EX.REFD.get(): - tmp = RESU_EX.REFD.get()[3] + if resu_ex.REFD.get(): + tmp = resu_ex.REFD.get()[3] if tmp.strip() : nume = self.get_concept(tmp) elif NUME_DDL: diff --git a/Aster/Cata/cataSTA10/Macro/macro_matr_asse_ops.py b/Aster/Cata/cataSTA10/Macro/macro_matr_asse_ops.py index a3089492..81180d68 100644 --- a/Aster/Cata/cataSTA10/Macro/macro_matr_asse_ops.py +++ b/Aster/Cata/cataSTA10/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 13/04/2010 AUTEUR PELLET J.PELLET # -*- 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/cataSTA10/Macro/macro_miss_3d_ops.py b/Aster/Cata/cataSTA10/Macro/macro_miss_3d_ops.py index 7e015759..c86c2775 100644 --- a/Aster/Cata/cataSTA10/Macro/macro_miss_3d_ops.py +++ b/Aster/Cata/cataSTA10/Macro/macro_miss_3d_ops.py @@ -1,4 +1,4 @@ -#@ MODIF macro_miss_3d_ops Macro DATE 13/05/2008 AUTEUR DEVESA G.DEVESA +#@ MODIF macro_miss_3d_ops Macro DATE 16/02/2010 AUTEUR COURTOIS M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -23,14 +23,15 @@ def macro_miss_3d_ops(self,UNITE_IMPR_ASTER,UNITE_OPTI_MISS, UNITE_MODELE_SOL,UNITE_RESU_IMPE, PROJET,REPERTOIRE,OPTION,VERSION, - UNITE_RESU_FORC,PARAMETRE,**args): + UNITE_RESU_FORC,TABLE_SOL,PARAMETRE,**args): """ Ecriture de la macro MACRO_MISS_3D """ import types from Accas import _F - from Utilitai.Utmess import UTMESS - from types import TupleType, ListType + from Utilitai.Utmess import UTMESS, MessageError + from Utilitai.Table import Table + from Miss.miss_fichier_sol import fichier_sol ier=0 # On importe les definitions des commandes a utiliser dans la macro @@ -72,6 +73,7 @@ def macro_miss_3d_ops(self,UNITE_IMPR_ASTER,UNITE_OPTI_MISS, MODUL2='MISS_PTAS' elif OPTION['MODULE']=='PRE_MISS': MODUL2='GTASTER' + ETUDE = PROJET BASE = REPERTOIRE @@ -81,6 +83,17 @@ def macro_miss_3d_ops(self,UNITE_IMPR_ASTER,UNITE_OPTI_MISS, primp = 'fort.'+str(UNITE_RESU_IMPE) prfor = 'fort.'+str(UNITE_RESU_FORC) + if TABLE_SOL != None : + + tabsol = TABLE_SOL.EXTR_TABLE() + try: + texte = fichier_sol(tabsol) + except MessageError, err: + UTMESS('F', err.id_message, valk=err.valk, vali=err.vali, valr=err.valr) + fdsol=open(pdsol,'w') + fdsol.write(texte) + fdsol.close() + l_para = ['FREQ_MIN','FREQ_MAX','FREQ_PAS','Z0','RFIC','SURF', 'FICH_RESU_IMPE','FICH_RESU_FORC','TYPE','DREF','ALGO', 'OFFSET_MAX','OFFSET_NB','SPEC_MAX','SPEC_NB','ISSF', @@ -101,7 +114,7 @@ def macro_miss_3d_ops(self,UNITE_IMPR_ASTER,UNITE_OPTI_MISS, else: dpara[cle] = '0' if PARAMETRE != None and PARAMETRE[cle] != None: - if type(PARAMETRE[cle]) in (TupleType, ListType): + if type(PARAMETRE[cle]) in (tuple, list): dpara[cle] = repr(' '.join([str(s) for s in PARAMETRE[cle]])) else: dpara[cle] = str(PARAMETRE[cle]) @@ -144,6 +157,6 @@ def macro_miss_3d_ops(self,UNITE_IMPR_ASTER,UNITE_OPTI_MISS, pndio, dpara['DIRE_ONDE'], ), - ) + INFO=1,) return ier diff --git a/Aster/Cata/cataSTA10/Macro/observation_ops.py b/Aster/Cata/cataSTA10/Macro/observation_ops.py index 4efc4032..06c66745 100644 --- a/Aster/Cata/cataSTA10/Macro/observation_ops.py +++ b/Aster/Cata/cataSTA10/Macro/observation_ops.py @@ -1,4 +1,4 @@ -#@ MODIF observation_ops Macro DATE 16/11/2009 AUTEUR COURTOIS M.COURTOIS +#@ MODIF observation_ops Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -31,6 +31,7 @@ def observation_ops(self, MODI_REPERE = None, NOM_CHAM = None, FILTRE = None, + EPSI_MOYENNE = None, **args): """ @@ -48,33 +49,357 @@ def observation_ops(self, # importation de commandes import aster - import Numeric from Accas import _F from Utilitai.UniteAster import UniteAster from Utilitai.Utmess import UTMESS - from Cata.cata import mode_meca, dyna_harmo, evol_elas + from Utilitai.Table import Table + from Cata.cata import mode_meca, dyna_harmo, evol_elas,dyna_trans MODI_REPERE = self.get_cmd('MODI_REPERE') PROJ_CHAMP = self.get_cmd('PROJ_CHAMP') CREA_CHAMP = self.get_cmd('CREA_CHAMP') CREA_RESU = self.get_cmd('CREA_RESU') - DEFI_BASE_MODALE = self.get_cmd('DEFI_BASE_MODALE') + POST_RELEVE_T = self.get_cmd('POST_RELEVE_T') DETRUIRE = self.get_cmd('DETRUIRE') # dans **args, on range les options de PROJ_CHAMP facultatives, et dont on # ne sert pas par la suite mcfact = args - # La macro n'est pas encoire capable de traiter les resultats dyna_harmo - if isinstance(RESULTAT, dyna_harmo): - UTMESS('E','UTILITAI7_8') + if NOM_CHAM == 'DEPL': + if isinstance( RESULTAT, dyna_harmo): + TYPE_CHAM = 'NOEU_DEPL_C' + else: + TYPE_CHAM = 'NOEU_DEPL_R' + elif NOM_CHAM == 'EPSI_NOEU_DEPL': + if isinstance( RESULTAT, dyna_harmo): + TYPE_CHAM = 'NOEU_EPSI_C' + else: + TYPE_CHAM = 'NOEU_EPSI_R' + else: + UTMESS('F','ELEMENTS4_48',valk=[NOM_CHAM]) + + if isinstance( RESULTAT, evol_elas): TYPE_RESU='EVOL_ELAS' + if isinstance( RESULTAT, dyna_trans): TYPE_RESU='DYNA_TRANS' + if isinstance( RESULTAT, dyna_harmo): TYPE_RESU='DYNA_HARMO' + if isinstance( RESULTAT, mode_meca): TYPE_RESU='MODE_MECA' + + self.DeclareOut( 'RESU', self.sd) + jdc = CONTEXT.get_current_step().jdc + + # recuperation du maillage associe au modele numerique + _maillag = aster.getvectjev( MODELE_1.nom.ljust(8) + '.MODELE .LGRF' ) + maillage = _maillag[0].strip() + mayanum = self.get_concept(maillage) + + # modele numerique 2D ou 3D + typmod= mayanum.DIME.get() + typmod = typmod[5] + + # recuperation du maillage associe au modele experimental + _maillag = aster.getvectjev( MODELE_2.nom.ljust(8) + '.MODELE .LGRF' ) + maillage = _maillag[0].strip() + mayaexp = self.get_concept(maillage) + + # cham_mater et cara_elem pour le resultat a projeter + iret,ibid,nom_cara_elem = aster.dismoi('F','CARA_ELEM',RESULTAT.nom,'RESULTAT') + if len(nom_cara_elem) > 0 : + assert nom_cara_elem.strip() != "#PLUSIEURS" , nom_cara_elem + if nom_cara_elem.strip() == "#AUCUN" : + cara_elem = None + else : + cara_elem = self.get_concept(nom_cara_elem.strip()) + else: + cara_elem = None + + iret,ibid,nom_cham_mater = aster.dismoi('F','CHAM_MATER',RESULTAT.nom,'RESULTAT') + if len(nom_cham_mater) > 0 : + assert nom_cham_mater.strip() != "#PLUSIEURS" , nom_cham_mater + if nom_cham_mater.strip() == "#AUCUN" : + cham_mater = None + else : + cham_mater = self.get_concept(nom_cham_mater.strip()) + else: + cham_mater = None + + # afreq pour les frequences propres + if isinstance( RESULTAT, mode_meca): + from Cata.cata import RECU_TABLE + __freq = RECU_TABLE(CO=RESULTAT, + NOM_PARA='FREQ',); + afreq = __freq.EXTR_TABLE().Array('NUME_ORDRE','FREQ') + else: + afreq = None + + nume_ordr_demande = mcfact['NUME_ORDRE'] + if type(nume_ordr_demande) != tuple : + nume_ordr_demande = [nume_ordr_demande] + + num_max = len(RESULTAT.LIST_VARI_ACCES()['NUME_ORDRE']) + +#*********************************************** +# PHASE DE CALCUL DE LA DEFORMATION MOYENNE AUX NOEUDS +# CHAMP CALCULE SUR LE MODELE NUMERIQUE +#*********************************************** + + if EPSI_MOYENNE != None : + + if NOM_CHAM != 'EPSI_NOEU_DEPL': + __proj= RESULTAT + UTMESS('F','UTILITAI8_24',valk=['NOEU_EPSI',NOM_CHAM]) + else: + if nume_ordr_demande[0]: + num_ordr = nume_ordr_demande + else: + num_ordr = RESULTAT.LIST_VARI_ACCES()['NUME_ORDRE'] + + if isinstance( RESULTAT, evol_elas): + list_inst = RESULTAT.LIST_VARI_ACCES()['INST'] + if isinstance( RESULTAT, dyna_trans): + list_inst = RESULTAT.LIST_VARI_ACCES()['INST'] + if isinstance( RESULTAT, dyna_harmo): + list_freq = RESULTAT.LIST_VARI_ACCES()['FREQ'] + + liste = [] + + # il faut calculer le champ complet + if typmod == 2: + nom_cmps = ['EPXX','EPYY','EPZZ','EPXY',] + else: + nom_cmps = ['EPXX','EPYY','EPZZ','EPXY','EPXZ','EPYZ',] + + argsi = {'ACTION' : [], } + lnoeuds = { } + nb_mcfact = 0 + seuil = [] + masque = [] + for epsi_moye in EPSI_MOYENNE : + mcfactr = { } + mcfacti = { } + l_noeud = None + val_masque = [] + seuil_lu = epsi_moye['SEUIL_VARI'] + if type(seuil_lu) == tuple : + val_seuil = seuil_lu[0] + else: + val_seuil = seuil_lu + seuil.append(val_seuil) + masque_lu = epsi_moye['MASQUE'] + if type(masque_lu) != tuple : + val_masque.append(masque_lu) + else: + val_masque = masque_lu + masque.append(val_masque) + for typ in ['NOEUD','GROUP_NO','MAILLE','GROUP_MA']: + if epsi_moye[typ] != None: + l_noeud = find_no(mayanum, {typ : epsi_moye[typ]}) + nb_mcfact = nb_mcfact + 1 + for i in range(len(l_noeud)): + l_noeud[i]=l_noeud[i].strip() + lnoeuds[str(nb_mcfact)]=l_noeud + + if l_noeud == None: + UTMESS('F','MODELISA3_13',valk=['EPSI_MOYENNE']) + + if TYPE_CHAM[-1:] == 'C': + mcfactr = { 'NOM_CMP' : nom_cmps, + 'OPERATION' : 'EXTRACTION', + 'INTITULE' : str('R'+str(nb_mcfact)), + 'FORMAT_C' : 'REEL', + 'NOEUD' : l_noeud, + 'NOM_CHAM' : 'EPSI_NOEU_DEPL', + 'RESULTAT' : RESULTAT, + 'NUME_ORDRE' : num_ordr, + } + argsi['ACTION'].append(mcfactr) + mcfacti = { 'NOM_CMP' : nom_cmps, + 'OPERATION' : 'EXTRACTION', + 'INTITULE' : str('I'+str(nb_mcfact)), + 'FORMAT_C' : 'IMAG', + 'NOEUD' : l_noeud, + 'NOM_CHAM' : 'EPSI_NOEU_DEPL', + 'RESULTAT' : RESULTAT, + 'NUME_ORDRE' : num_ordr, + } + argsi['ACTION'].append(mcfacti) + else: + mcfactr = { 'NOM_CMP' : nom_cmps, + 'OPERATION' : 'EXTRACTION', + 'INTITULE' : str(nb_mcfact), + 'NOEUD' : l_noeud, + 'NOM_CHAM' : 'EPSI_NOEU_DEPL', + 'RESULTAT' : RESULTAT, + 'NUME_ORDRE' : num_ordr, + } + argsi['ACTION'].append(mcfactr) + + _tepsi=POST_RELEVE_T( + **argsi) + + table=_tepsi.EXTR_TABLE() + + DETRUIRE( CONCEPT= _F( NOM = _tepsi ), INFO=1) + + mcfact2 = { } + __chame = [None]*num_max + for ind in num_ordr: + argsa = {'AFFE' : [], } + for mcfacta in range(nb_mcfact): + l_noeud_mcfact = lnoeuds[str(mcfacta+1)] + l_vmoye=[] + l_cmp_vari=[] + seuil_mc=seuil[mcfacta] + masque_mc=masque[mcfacta] + for cmp in nom_cmps: + lur = 0 + lui = 0 + l_valr= [] + l_vali= [] + l_valc= [] + l_val= [] + for row in table.rows: + if TYPE_CHAM[-1:] == 'C': + if row['INTITULE'].strip() == str('R'+str(mcfacta+1)) \ + and row['NUME_ORDRE'] == ind : + l_valr.append(row[cmp]) + lur = 1 + elif row['INTITULE'].strip() == str('I'+str(mcfacta+1)) \ + and row['NUME_ORDRE'] == ind : + l_vali.append(row[cmp]) + lui = 1 + + else: + if row['INTITULE'].strip() == str(mcfacta+1) \ + and row['NUME_ORDRE'] == ind: + l_val.append(row[cmp]) + + if TYPE_CHAM[-1:] == 'C': + if lur and lui : + if len(l_valr) != len(l_vali): + UTMESS('F','POSTRELE_59') + for i in range(len(l_valr)): + l_valc.append(complex(l_valr[i],l_vali[i])) + + lur = 0 + lui = 0 + else: + UTMESS('F','POSTRELE_59') + + # on regarde a la fois la partie reelle et la partie imag pour les complexes + vmoyer = sum(l_valr)/len(l_valr) + vmoyei = sum(l_vali)/len(l_vali) + vmoye = sum(l_valc)/len(l_valc) + vminr = min(l_valr) + vmini = min(l_vali) + vmaxr = max(l_valr) + vmaxi = max(l_vali) + if vmoyer > 0: + if (vmaxr > vmoyer*(1.+seuil_mc)) or (vminr < vmoyer*(1-seuil_mc)): + l_cmp_vari.append(cmp) + if vmoyei > 0: + if (vmaxi > vmoyei*(1.+seuil_mc)) or (vmini < vmoyei*(1-seuil_mc)): + l_cmp_vari.append(cmp) + if vmoyer < 0: + if (vminr > vmoyer*(1.-seuil_mc)) or (vmaxr < vmoyer*(1+seuil_mc)): + l_cmp_vari.append(cmp) + if vmoyei < 0: + if (vmini > vmoyei*(1.-seuil_mc)) or (vmaxi < vmoyei*(1+seuil_mc)): + l_cmp_vari.append(cmp) + else: + vmoye = sum(l_val)/len(l_val) + vmin = min(l_val) + vmax = max(l_val) + if vmoye > 0: + if (vmax > vmoye*(1.+seuil_mc)) or (vmin < vmoye*(1-seuil_mc)): + l_cmp_vari.append(cmp) + if vmoye < 0: + if (vmin > vmoye*(1.-seuil_mc)) or (vmax < vmoye*(1+seuil_mc)): + l_cmp_vari.append(cmp) + + l_vmoye.append(vmoye) + + if len(l_cmp_vari) > 0: + for cmp in nom_cmps: + vu = 0 + for cmp_vari in l_cmp_vari: + if cmp_vari not in masque_mc: + if cmp == cmp_vari and not vu: + if EPSI_MOYENNE[mcfacta]['MAILLE'] != None: + entite = str('MAILLE : '+str(PSI_MOYENNE[mcfacta]['MAILLE'])) + if EPSI_MOYENNE[mcfacta]['GROUP_MA'] != None: + entite = str('GROUP_MA : '+str(EPSI_MOYENNE[mcfacta]['GROUP_MA'])) + UTMESS('A','OBSERVATION_8',vali=[ind],valr=[seuil_mc],valk=[entite,cmp]) + vu = 1 + + + if TYPE_CHAM[-1:] == 'C': + mcfactc = { 'NOM_CMP' : nom_cmps, + 'NOEUD' : l_noeud_mcfact, + 'VALE_C' : l_vmoye, + } + else: + mcfactc = { 'NOM_CMP' : nom_cmps, + 'NOEUD' : l_noeud_mcfact, + 'VALE' : l_vmoye, + } + + argsa['AFFE'].append(mcfactc) + + __chame[ind-1] = CREA_CHAMP( OPERATION = 'AFFE', + MODELE = MODELE_1, + PROL_ZERO = 'OUI', + TYPE_CHAM = TYPE_CHAM, + OPTION = NOM_CHAM, + **argsa + ); + + if isinstance( RESULTAT, mode_meca): + mcfact2 = {'CHAM_GD' : __chame[ind-1], + 'MODELE' : MODELE_1, + 'NUME_MODE' : int(afreq[ind-1,0]), + 'FREQ' : afreq[ind-1,1], + } + + if isinstance( RESULTAT, evol_elas): + mcfact2 = {'CHAM_GD' : __chame[ind-1], + 'MODELE' : MODELE_1, + 'INST' : list_inst[ind-1], + } + + if isinstance( RESULTAT, dyna_trans): + mcfact2 = {'CHAM_GD' : __chame[ind-1], + 'MODELE' : MODELE_1, + 'INST' : list_inst[ind], + } + + if isinstance( RESULTAT, dyna_harmo): + mcfact2 = {'CHAM_GD' : __chame[ind-1], + 'MODELE' : MODELE_1, + 'FREQ' : list_freq[ind-1], + } + + if cham_mater is not None: + mcfact2['CHAM_MATER'] = cham_mater + if cara_elem is not None: + mcfact2['CARA_ELEM'] = cara_elem + + liste.append(mcfact2) + + __proj = CREA_RESU( + OPERATION = 'AFFE', + TYPE_RESU = TYPE_RESU, + NOM_CHAM = NOM_CHAM, + AFFE = liste, + ); + else: + __proj= RESULTAT #*********************************************** # PHASE DE PROJECTION #*********************************************** - if PROJECTION == 'OUI' : - __proj=PROJ_CHAMP(RESULTAT = RESULTAT, + if PROJECTION == 'OUI': + __proj=PROJ_CHAMP(RESULTAT = __proj, MODELE_1 = MODELE_1, MODELE_2 = MODELE_2, NUME_DDL = NUME_DDL, @@ -82,8 +407,9 @@ def observation_ops(self, **mcfact ); - else : - __proj = RESULTAT + modele = MODELE_2 + else: + modele = MODELE_1 #*********************************************** @@ -106,50 +432,58 @@ def observation_ops(self, # ) - # cham_mater et cara_elem pour le resultat a projeter - jdc = CONTEXT.get_current_step().jdc - iret,ibid,nom_cara_elem = aster.dismoi('F','CARA_ELEM',RESULTAT.nom,'RESULTAT') - if len(nom_cara_elem) > 0 : - assert nom_cara_elem.strip() != "#PLUSIEURS" , nom_cara_elem - if nom_cara_elem.strip() == "#AUCUN" : - cara_elem = None - else : - cara_elem = self.get_concept(nom_cara_elem.strip()) - else: - cara_elem = None - - iret,ibid,nom_cham_mater = aster.dismoi('F','CHAM_MATER',RESULTAT.nom,'RESULTAT') - if len(nom_cham_mater) > 0 : - assert nom_cham_mater.strip() != "#PLUSIEURS" , nom_cham_mater - if nom_cham_mater.strip() == "#AUCUN" : - cham_mater = None - else : - cham_mater = self.get_concept(nom_cham_mater.strip()) - else: - cham_mater = None - - # recuperation du maillage associe au modele experimental - _maillag = aster.getvectjev( MODELE_2.nom.ljust(8) + '.MODELE .LGRF' ) - maillage = _maillag[0].strip() - jdc = CONTEXT.get_current_step().jdc - mayaexp = self.get_concept(maillage) - - _maillag = aster.getvectjev( MODELE_1.nom.ljust(8) + '.MODELE .LGRF' ) - maillage = _maillag[0].strip() - jdc = CONTEXT.get_current_step().jdc - mayanum = self.get_concept(maillage) - - if MODIF_REPERE != None : - for modi_rep in MODIF_REPERE : - type_cham = modi_rep['TYPE_CHAM'] - nom_cmp = modi_rep['NOM_CMP'] + if nume_ordr_demande[0]: + num_ordr = nume_ordr_demande + else: + num_ordr = __proj.LIST_VARI_ACCES()['NUME_ORDRE'] + + for modif_rep in MODIF_REPERE : + type_cham = modif_rep['TYPE_CHAM'] + if type_cham == 'TENS_2D': + nom_cmp = ['EPXX','EPYY','EPZZ','EPXY',] + elif type_cham == 'TENS_3D': + nom_cmp = ['EPXX','EPYY','EPZZ','EPXY','EPXZ','EPYZ',] + else: + nom_cmp = modif_rep['NOM_CMP'] mcfact1 = { 'NOM_CMP' : nom_cmp, 'TYPE_CHAM' : type_cham, 'NOM_CHAM' : NOM_CHAM } mcfact2 = { } - modi_rep = modi_rep.val + modi_rep = modif_rep.val + + if modi_rep['REPERE'] == 'DIR_JAUGE' : + vect_x = None + vect_y = None + if modi_rep.has_key('VECT_X'): + vect_x = modi_rep['VECT_X'] + if modi_rep.has_key('VECT_Y'): + vect_y = modi_rep['VECT_Y'] + + # il faut des mailles pour les tenseurs d'ordre 2 + taille = 0 + for typ in ['MAILLE','GROUP_MA',]: + if modi_rep.has_key(typ) : + if PROJECTION == 'OUI': + maya = mayaexp + else: + maya = mayanum + list_ma = find_ma(maya, {typ : modi_rep[typ]}) + taille = len(list_ma) + + mcfact1.update({ 'MAILLE' : list_ma }) + angl_naut = crea_repere_xy(vect_x, vect_y) + + mcfact2.update({ 'REPERE' : 'UTILISATEUR', + 'ANGL_NAUT' : angl_naut }) + + args = {'MODI_CHAM' : mcfact1, + 'DEFI_REPERE' : mcfact2 } + + __proj = MODI_REPERE( RESULTAT = __proj, + NUME_ORDRE = num_ordr, + **args) if modi_rep['REPERE'] == 'NORMALE' : # Cas ou l'utilisateur choisit de creer les reperes locaux @@ -163,13 +497,14 @@ def observation_ops(self, chnorm = crea_normale(self, MODELE_1, MODELE_2, NUME_DDL, cham_mater, cara_elem) + modele = MODELE_2 chnormx = chnorm.EXTR_COMP('DX',[],1) ind_noeuds = chnormx.noeud nom_allno = [mayaexp.NOMNOE.get()[k-1] for k in ind_noeuds] # on met les noeuds conernes sous forme de liste et on va # chercher les noeuds des mailles pour 'MAILLE' et 'GROUP_MA' - for typ in ['NOEUD','GROUP_NO','MAILLE','GROUP_MA','TOUT']: + for typ in ['NOEUD','GROUP_NO','MAILLE','GROUP_MA']: if modi_rep.has_key(typ) : list_no_exp = find_no(mayaexp, {typ : modi_rep[typ]}) @@ -195,56 +530,71 @@ def observation_ops(self, __proj = __bid[-1:][0] - else: - for typ in ['NOEUD','GROUP_NO','MAILLE','GROUP_MA','TOUT']: + if modi_rep['REPERE'] == 'UTILISATEUR' or modi_rep['REPERE'] == 'CYLINDRIQUE': + + if type_cham == 'TENS_2D' or type_cham == 'TENS_3D' : + for typ in ['MAILLE','GROUP_MA',]: + if modi_rep.has_key(typ) : + mcfact1.update({typ : modi_rep[typ]}) + else: + for typ in ['NOEUD','GROUP_NO','MAILLE','GROUP_MA']: if modi_rep.has_key(typ) : mcfact1.update({typ : modi_rep[typ]}) - if modi_rep['REPERE'] == 'CYLINDRIQUE' : + + if modi_rep['REPERE'] == 'CYLINDRIQUE' : origine = modi_rep['ORIGINE'] axe_z = modi_rep['AXE_Z'] mcfact2.update({ 'REPERE' : 'CYLINDRIQUE', 'ORIGINE' : origine, 'AXE_Z' : axe_z }) - elif modi_rep['REPERE'] == 'UTILISATEUR' : + elif modi_rep['REPERE'] == 'UTILISATEUR' : angl_naut = modi_rep['ANGL_NAUT'] mcfact2.update({ 'REPERE' : 'UTILISATEUR', 'ANGL_NAUT' : angl_naut }) - args = {'MODI_CHAM' : mcfact1, + + args = {'MODI_CHAM' : mcfact1, 'DEFI_REPERE' : mcfact2 } - __bid = MODI_REPERE( RESULTAT = __proj, + + __bidon = MODI_REPERE( RESULTAT = __proj, CRITERE = 'RELATIF', **args) - __proj = __bid - - - else: # pas de modif de repere demandee - pass + DETRUIRE( CONCEPT= _F( NOM = __proj ), INFO=1) + __proj = __bidon #************************************************* # Phase de selection des DDL de mesure #************************************************* - # les numeros d'ordre de la sd_resu - num_ordr = RESULTAT.LIST_VARI_ACCES()['NUME_ORDRE'] - __cham = [None]*len(num_ordr) - list_cham = [] if FILTRE != None: - nb_fi = len(FILTRE) + if nume_ordr_demande[0]: + num_ordr = nume_ordr_demande + else: + num_ordr = __proj.LIST_VARI_ACCES()['NUME_ORDRE'] + + __chamf = [None]*num_max + if isinstance( RESULTAT, evol_elas): + list_inst_ini = RESULTAT.LIST_VARI_ACCES()['INST'] + if isinstance( RESULTAT, dyna_trans): + list_inst_ini = RESULTAT.LIST_VARI_ACCES()['INST'] + if isinstance( RESULTAT, dyna_harmo): + list_freq_ini = RESULTAT.LIST_VARI_ACCES()['FREQ'] + liste = [] for ind in num_ordr: + mcfact2 = { } filtres = [] - __chamex = CREA_CHAMP(TYPE_CHAM = 'NOEU_DEPL_R', + __chamex = CREA_CHAMP(TYPE_CHAM = TYPE_CHAM, OPERATION = 'EXTR', RESULTAT = __proj, - NOM_CHAM = 'DEPL', + NOM_CHAM = NOM_CHAM, NUME_ORDRE = ind,); - for filtre in FILTRE : + for mcfiltre in FILTRE : mcfact1 = {} - filtre = filtre.val + filtre = mcfiltre.val for typ in ['NOEUD','GROUP_NO','MAILLE','GROUP_MA']: if filtre.has_key(typ) : mcfact1.update({typ : filtre[typ]}) @@ -252,17 +602,54 @@ def observation_ops(self, 'CHAM_GD' : __chamex }) filtres.append(mcfact1) - __cham[ind-1] = CREA_CHAMP(TYPE_CHAM = 'NOEU_DEPL_R', + if NOM_CHAM == 'DEPL': + __chamf[ind-1] = CREA_CHAMP(TYPE_CHAM = TYPE_CHAM, OPERATION = 'ASSE', - MODELE = MODELE_2, - PROL_ZERO = 'NON', + MODELE = modele, ASSE = filtres ); + elif NOM_CHAM == 'EPSI_NOEU_DEPL': + __chamf[ind-1] = CREA_CHAMP(TYPE_CHAM = TYPE_CHAM, + OPERATION = 'ASSE', + PROL_ZERO = 'OUI', + MODELE = modele, + ASSE = filtres, + ); - mcfact2 = {'CHAM_GD' : __cham[ind-1], + else: + valk = [] + valk.append(NOM_CHAM) + valk.append('DEPL') + valk.append('EPSI_NOEU_DEPL') + UTMESS('F','OBSERVATION_6',valk) + + if isinstance( RESULTAT, mode_meca): + mcfact2 = {'CHAM_GD' : __chamf[ind-1], + 'MODELE' : modele, + 'NUME_MODE' : int(afreq[ind-1,0]), + 'FREQ' : afreq[ind-1,1], + } + + if isinstance( RESULTAT, evol_elas): + mcfact2 = {'CHAM_GD' : __chamf[ind-1], + 'MODELE' : modele, + 'INST' : list_inst_ini[ind-1], + } + + if isinstance( RESULTAT, dyna_trans): + mcfact2 = {'CHAM_GD' : __chamf[ind-1], + 'MODELE' : modele, + 'INST' : list_inst_ini[ind-1], + } + + if isinstance( RESULTAT, dyna_harmo): + mcfact2 = {'CHAM_GD' : __chamf[ind-1], 'MODELE' : MODELE_2, - 'NOM_CAS' : str(ind)} + 'FREQ' : list_freq_ini[ind-1], + } + + if cham_mater is not None: mcfact2['CHAM_MATER'] = cham_mater if cara_elem is not None: @@ -271,40 +658,108 @@ def observation_ops(self, liste.append(mcfact2) DETRUIRE( CONCEPT= _F( NOM = __chamex ), INFO=1) - - self.DeclareOut( 'RESU', self.sd) - if isinstance( RESULTAT, evol_elas): - # Fabrication de l'evol_elas (cas le plus simple) - RESU = CREA_RESU( OPERATION = 'AFFE', - TYPE_RESU = 'EVOL_ELAS', - NOM_CHAM = 'DEPL', + __proj = CREA_RESU( + OPERATION = 'AFFE', + TYPE_RESU = TYPE_RESU, + NOM_CHAM = NOM_CHAM, AFFE = liste, ); +#************************************************* +# Recopie des resultats (__proj) dans RESU +#************************************************* + + if nume_ordr_demande[0]: + num_ordr = nume_ordr_demande + else: + num_ordr = __proj.LIST_VARI_ACCES()['NUME_ORDRE'] + + __chamf = [None]*num_max + if isinstance( RESULTAT, evol_elas): + list_inst = __proj.LIST_VARI_ACCES()['INST'] + if isinstance( RESULTAT, dyna_trans): + list_inst = __proj.LIST_VARI_ACCES()['INST'] + if isinstance( RESULTAT, dyna_harmo): + list_freq = __proj.LIST_VARI_ACCES()['FREQ'] + + liste = [] + + for ind in num_ordr: + mcfact2 = { } + filtres = [] + __chamex = CREA_CHAMP(TYPE_CHAM = TYPE_CHAM, + OPERATION = 'EXTR', + RESULTAT = __proj, + NOM_CHAM = NOM_CHAM, + NUME_ORDRE = ind,); + + mcfact1 = {} + mcfact1.update({'TOUT' : 'OUI', + 'CHAM_GD' : __chamex }) + filtres.append(mcfact1) + + if NOM_CHAM == 'DEPL': + __chamf[ind-1] = CREA_CHAMP(TYPE_CHAM = TYPE_CHAM, + OPERATION = 'ASSE', + MODELE = modele, + ASSE = filtres + ); + + elif NOM_CHAM == 'EPSI_NOEU_DEPL': + __chamf[ind-1] = CREA_CHAMP(TYPE_CHAM = TYPE_CHAM, + OPERATION = 'ASSE', + PROL_ZERO = 'OUI', + MODELE = modele, + ASSE = filtres, + ); + + else: + valk = [] + valk.append(NOM_CHAM) + valk.append('DEPL') + valk.append('EPSI_NOEU_DEPL') + UTMESS('F','OBSERVATION_6',valk) + if isinstance( RESULTAT, mode_meca): - # Fabrication de la base modale resultat. On doit tricher un peu (encore!!), en - # faisant un defi_base_modale dans lequel on met zero modes du concept RESULTAT - # TODO : permettre la creation directement d'un resu de type mode_meca avec - # CREA_RESU - _RESBID = CREA_RESU( OPERATION = 'AFFE', - TYPE_RESU = 'MULT_ELAS', - NOM_CHAM = 'DEPL', - AFFE = liste, - ); - - RESU = DEFI_BASE_MODALE( RITZ = ( - _F( MODE_MECA = RESULTAT, - NMAX_MODE = 0,), - _F( MODE_INTF = _RESBID), - ), - NUME_REF=NUME_DDL - ); - - - elif isinstance( RESULTAT, dyna_harmo): - # TODO : a faire - pass + mcfact2 = {'CHAM_GD' : __chamf[ind-1], + 'MODELE' : modele, + 'NUME_MODE' : int(afreq[ind-1,0]), + 'FREQ' : afreq[ind-1,1], + } + + if isinstance( RESULTAT, evol_elas): + mcfact2 = {'CHAM_GD' : __chamf[ind-1], + 'MODELE' : modele, + 'INST' : list_inst[ind-1], + } + + if isinstance( RESULTAT, dyna_trans): + mcfact2 = {'CHAM_GD' : __chamf[ind-1], + 'MODELE' : modele, + 'INST' : list_inst[ind-1], + } + + if isinstance( RESULTAT, dyna_harmo): + mcfact2 = {'CHAM_GD' : __chamf[ind-1], + 'MODELE' : MODELE_2, + 'FREQ' : list_freq[ind-1], + } + + + if cham_mater is not None: + mcfact2['CHAM_MATER'] = cham_mater + if cara_elem is not None: + mcfact2['CARA_ELEM'] = cara_elem + liste.append(mcfact2) + DETRUIRE( CONCEPT= _F( NOM = __chamex ), INFO=1) + + RESU = CREA_RESU( + OPERATION = 'AFFE', + TYPE_RESU = TYPE_RESU, + NOM_CHAM = NOM_CHAM, + AFFE = liste, + ); return ier @@ -319,8 +774,8 @@ def crea_normale(self, modele_1, modele_2, nume_ddl, cham_mater=None, cara_elem=None): """Cree un champ de vecteurs normaux sur le maillage experimental, par projection du champ de normales cree sur le maillage numerique + les mailles doivent etre des elements de (facettes) """ - import Numeric PROJ_CHAMP = self.get_cmd('PROJ_CHAMP') CREA_CHAMP = self.get_cmd('CREA_CHAMP') CREA_RESU = self.get_cmd('CREA_RESU') @@ -397,7 +852,6 @@ def crea_normale(self, modele_1, modele_2, return __norm5 - #********************************************************************** # Calcul des angles nautiques pour le repere local associe a la normale #********************************************************************** @@ -409,7 +863,7 @@ def crea_repere(chnorm, ind_no, vect): de trois parametres et du vecteur de base concerne. """ - import Numeric + import numpy nom_para = vect.keys()[0] # nom_para = 'VECT_X' ou 'VECT_Y' condition = list(vect[nom_para]) @@ -431,16 +885,16 @@ def crea_repere(chnorm, ind_no, vect): # (option VECT_X Ou VECT_Y). Dans ce cas la, le 3e est le produit # vectoriel des deux premiers. if nom_para == 'VECT_X' : - vect1 = Numeric.array(list(vect[nom_para])) # vect x du reploc - vect2 = cross_product(normale,vect1) - reploc = Numeric.array([vect1.tolist(), vect2.tolist(), normale]) - reploc = Numeric.transpose(reploc) + vect1 = numpy.array(list(vect[nom_para])) # vect x du reploc + vect2 = numpy.cross(normale,vect1) + reploc = numpy.array([vect1.tolist(), vect2.tolist(), normale]) + reploc = numpy.transpose(reploc) elif nom_para == 'VECT_Y' : - vect2 = Numeric.array(list(vect[nom_para])) # vect y du reploc - vect1 = cross_product(vect2, normale) - reploc = Numeric.array([vect1.tolist(), vect2.tolist(), normale]) - reploc = Numeric.transpose(reploc) + vect2 = numpy.array(list(vect[nom_para])) # vect y du reploc + vect1 = numpy.cross(vect2, normale) + reploc = numpy.array([vect1.tolist(), vect2.tolist(), normale]) + reploc = numpy.transpose(reploc) # 2.2) TODO : plutot que de donner explicitement un vecteur du repere # local avec VECT_X/Y, on devrait aussi pouvoir donner une condition @@ -457,6 +911,91 @@ def crea_repere(chnorm, ind_no, vect): return angl_naut + +#********************************************************************** +# Calcul des angles nautiques pour le repere associe a VECT_X et VECT_Y +#********************************************************************** + +def crea_repere_xy(vect_x, vect_y): + + """Calcul des angles nautiques a partir des directions vect_x et vect_y. + Si vect_x != None et vect_y != None alors on impose le premier vecteur de base + colineaire a vect_x et le deuxieme vecteur dans le plan (vect_x,vect_y) + Si vect_x != None et vect_y == None alors on impose le premier vecteur de base + colineaire a vect_x + Si vect_x == None et vect_y != None alors on impose le deuxieme vecteur de base + colineaire a vect_y + Si vect_x == None et vect_y == None alors on ne fait rien + """ + + import numpy + from Utilitai.Utmess import UTMESS + + if vect_x == None and vect_y == None: + angl_naut = (0.,0.,0.) + else: + if vect_x and vect_y: + vx = numpy.array(list(vect_x)) + vy = numpy.array(list(vect_y)) + vect1 = vx + vect3 = numpy.cross(vx,vy) + vect2 = numpy.cross(vect3,vx) + + elif vect_x: + vx = numpy.array(list(vect_x)) + vy1 = numpy.cross((1.,0.,0.),vx) + vy2 = numpy.cross((0.,1.,0.),vx) + vy3 = numpy.cross((0.,0.,1.),vx) + n1 = norm(vy1) + n2 = norm(vy2) + n3 = norm(vy3) + nmax = max(n1,n2,n3) + if nmax == n1: + vy = vy1 + elif nmax == n2: + vy = vy2 + elif nmax == n3: + vy = vy3 + else: + UTMESS('F','UTILITAI_7') + vect3 = numpy.cross(vx,vy) + vect1 = vx + vect2 = numpy.cross(vect3,vect1) + + elif vect_y: + vy = numpy.array(list(vect_y)) + vx1 = numpy.cross((1.,0.,0.),vy) + vx2 = numpy.cross((0.,1.,0.),vy) + vx3 = numpy.cross((0.,0.,1.),vy) + n1 = norm(vx1) + n2 = norm(vx2) + n3 = norm(vx3) + nmax = max(n1,n2,n3) + if nmax == n1: + vx = vx1 + elif nmax == n2: + vx = vx2 + elif nmax == n3: + vx = vx3 + else: + UTMESS('F','UTILITAI_7') + vect3 = numpy.cross(vx,vy) + vect2 = vy + vect1 = numpy.cross(vect2, vect3) + + + norm12=numpy.dot(vect1,vect1) + norm22=numpy.dot(vect2,vect2) + norm32=numpy.dot(vect3,vect3) + if norm12 == 0 or norm22 == 0 or norm32 == 0: + UTMESS('F','UTILITAI_7') + else: + reploc = numpy.array([vect1.tolist(),vect2.tolist(),vect3.tolist()]) + reploc = numpy.transpose(reploc) + angl_naut = anglnaut(reploc) + + return angl_naut + #***************************************************************************** # Aller chercher une liste de noeuds pour un mot cle 'NOEUD', 'GROUP_NO' # 'MAILLE' ou 'GROUP_MA' @@ -471,12 +1010,13 @@ def find_no(maya,mcsimp): etc... """ - import Numeric + import numpy list_no = [] - list_ma = [] if mcsimp.has_key('GROUP_NO') and type(mcsimp['GROUP_NO']) != tuple : mcsimp['GROUP_NO'] = [mcsimp['GROUP_NO']] + if mcsimp.has_key('MAILLE') and type(mcsimp['MAILLE']) != tuple : + mcsimp['MAILLE'] = [mcsimp['MAILLE']] if mcsimp.has_key('GROUP_MA') and type(mcsimp['GROUP_MA']) != tuple : mcsimp['GROUP_MA'] = [mcsimp['GROUP_MA']] @@ -484,66 +1024,74 @@ def find_no(maya,mcsimp): list_no = list(mcsimp['NOEUD']) elif mcsimp.has_key('GROUP_NO') : for group in mcsimp['GROUP_NO'] : - list_ind_no = list(Numeric.array(maya.GROUPENO.get()[group.ljust(8)])-1) + list_ind_no = list(numpy.array(maya.GROUPENO.get()[group.ljust(8)])-1) for ind_no in list_ind_no : nomnoe = maya.NOMNOE.get()[ind_no] if nomnoe not in list_no : list_no.append(nomnoe) elif mcsimp.has_key('MAILLE') : for mail in mcsimp['MAILLE'] : - ind_ma = maya.NOMMAI.get().index(mail.ljust(8)) - for ind_no in mayaexp.CONNEX[ind_ma] : - nomnoe = mayaexp.NOMNOE.get()[ind_no] - if nomnoe not in list_no : - list_no.append(nomnoe) + for index in range(len(maya.NOMMAI.get())): + if maya.NOMMAI.get()[index].strip() == mail: + nu_ma = index + for ind_no in maya.CONNEX.get()[nu_ma+1]: + nomnoe = maya.NOMNOE.get()[ind_no-1] + if nomnoe not in list_no: + list_no.append(nomnoe) elif mcsimp.has_key('GROUP_MA') : for group in mcsimp['GROUP_MA'] : - list_ma.append(maya.GROUPEMA.get()[group.ljust(8)]) - for mail in list_ma : - tmp = list(maya.NOMMAI.get()) - ind_ma = tmp.index(mail.ljust(8)) - for ind_no in maya.CONNEX[ind_ma] : - nomnoe = maya.NOMNOE.get()[ind_no] - if nomnoe not in list_no : - list_no.append(nomnoe) - + list_nu_ma = list(numpy.array(maya.GROUPEMA.get() + [group.ljust(8)]) - 1) + for nu_ma in list_nu_ma: + for ind_no in maya.CONNEX.get()[nu_ma+1]: + nomnoe = maya.NOMNOE.get()[ind_no-1] + if nomnoe not in list_no: + list_no.append(nomnoe) return list_no +#***************************************************************************** +# Aller chercher une liste de mailles pour un mot cle 'MAILLE' ou 'GROUP_MA' +#***************************************************************************** -#************************************************************************************ -# Quelques utilitaires de calculs d'angles nautiques (viennent de zmat004a.comm -#************************************************************************************ +def find_ma(maya,mcsimp): + """ Si mot cle MAILLE, on retourne la liste des mailles + Si mot cle GROUP_MA, on va chercher les mailles dans ces groupes + """ + import numpy -def cross_product(a, b): - """Return the cross product of two vectors. - For a dimension of 2, - the z-component of the equivalent three-dimensional cross product is - returned. + list_ma = [] + if mcsimp.has_key('GROUP_MA') and type(mcsimp['GROUP_MA']) != tuple : + mcsimp['GROUP_MA'] = [mcsimp['GROUP_MA']] + if mcsimp.has_key('MAILLE') and type(mcsimp['MAILLE']) != tuple : + mcsimp['MAILLE'] = [mcsimp['MAILLE']] - For backward compatibility with Numeric <= 23 - """ - from Numeric import asarray, array - a = asarray(a) - b = asarray(b) - dim = a.shape[0] - assert 2<= dim <=3 and dim == b.shape[0], "incompatible dimensions for cross product" - if dim == 2: - result = a[0]*b[1] - a[1]*b[0] - elif dim == 3: - x = a[1]*b[2] - a[2]*b[1] - y = a[2]*b[0] - a[0]*b[2] - z = a[0]*b[1] - a[1]*b[0] - result = array([x,y,z]) - return result + if mcsimp.has_key('MAILLE') : + for mail in mcsimp['MAILLE'] : + list_ma.append(mail) + elif mcsimp.has_key('GROUP_MA') : + for group in mcsimp['GROUP_MA'] : + list_ind_ma = list(numpy.array(maya.GROUPEMA.get()[group.ljust(8)])-1) + for ind_ma in list_ind_ma : + nommail = maya.NOMMAI.get()[ind_ma] + if nommail not in list_ma : + list_ma.append(nommail) + + return list_ma + + +#************************************************************************************ +# Quelques utilitaires de calculs d'angles nautiques (viennent de zmat004a.comm +#************************************************************************************ def norm(x): """Calcul de la norme euclidienne d'un vecteur""" - import Numeric - tmp = Numeric.sqrt(Numeric.dot(x,x)) + import numpy + tmp = numpy.sqrt(numpy.dot(x,x)) return tmp + def anglnaut(P): @@ -553,11 +1101,11 @@ def anglnaut(P): """ import copy - import Numeric + import numpy # expression des coordonnees globales des 3 vecteurs de base locale - x = Numeric.array([1.,0.,0.]) - y = Numeric.array([0.,1.,0.]) - z = Numeric.array([0.,0.,1.]) + x = numpy.array([1.,0.,0.]) + y = numpy.array([0.,1.,0.]) + z = numpy.array([0.,0.,1.]) xg = P[:,0] yg = P[:,1] @@ -568,28 +1116,33 @@ def anglnaut(P): # x1 projection de xg sur la plan xy, non norme x1[2]=0. # produit scalaire X xg - COSA=x1[0]/norm(x1) - #produit vectoriel X xg - SINA=x1[1]/norm(x1) - ar=Numeric.arctan2(SINA,COSA) - alpha=ar*180/Numeric.pi + normx = norm(x1) + if normx == 0.: # on impose alpha = 0 pour lever l'indetermination + COSA=1. + SINA=0. + else: + COSA=x1[0]/normx + #produit vectoriel X xg + SINA=x1[1]/normx + ar=numpy.arctan2(SINA,COSA) + alpha=ar*180/numpy.pi COSB=norm(x1) SINB=-xg[2] - beta=Numeric.arctan2(SINB,COSB)*180/Numeric.pi - - P2=Numeric.zeros((3,3),Numeric.Float) - P2[0,0]=Numeric.cos(ar) - P2[1,0]=Numeric.sin(ar) - P2[1,1]=Numeric.cos(ar) - P2[0,1]=-Numeric.sin(ar) - y1=Numeric.dot(P2,y) + beta=numpy.arctan2(SINB,COSB)*180/numpy.pi + + P2=numpy.zeros((3,3)) + P2[0,0]=numpy.cos(ar) + P2[1,0]=numpy.sin(ar) + P2[1,1]=numpy.cos(ar) + P2[0,1]=-numpy.sin(ar) + y1=numpy.dot(P2,y) y1n=y1/norm(y1) # calcul de gamma - COSG=Numeric.dot(y1n,yg) - SING=Numeric.dot(xg,cross_product(y1n,yg)) - gamma=Numeric.arctan2(SING,COSG)*180/Numeric.pi + COSG=numpy.dot(y1n,yg) + SING=numpy.dot(xg,numpy.cross(y1n,yg)) + gamma=numpy.arctan2(SING,COSG)*180/numpy.pi return alpha,beta,gamma diff --git a/Aster/Cata/cataSTA10/Macro/post_coque_ops.py b/Aster/Cata/cataSTA10/Macro/post_coque_ops.py new file mode 100644 index 00000000..40f74004 --- /dev/null +++ b/Aster/Cata/cataSTA10/Macro/post_coque_ops.py @@ -0,0 +1,172 @@ +#@ MODIF post_coque_ops Macro DATE 08/02/2010 AUTEUR DESROCHES X.DESROCHES + +# 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. +# ====================================================================== + +def post_coque_ops(self,RESULTAT,COOR_POINT,CHAM,NUME_ORDRE,INST, + **args): + """ + macro post_coque + """ + import aster + import os, string + import Accas + from Accas import _F + from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme + from Utilitai.Table import Table + from Noyau.N_utils import AsType + ier=0 + + # On importe les definitions des commandes a utiliser dans la macro + MACR_LIGN_COUPE =self.get_cmd('MACR_LIGN_COUPE') + CREA_CHAMP =self.get_cmd('CREA_CHAMP') + CREA_TABLE =self.get_cmd('CREA_TABLE') + CALC_ELEM =self.get_cmd('CALC_ELEM') + + + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + MasquerAlarme('MODELISA4_9') + + # Le concept sortant (de type table) est nomme + # 'tabout' dans le contexte de la macro + + self.DeclareOut('tabout',self.sd) + assert AsType(RESULTAT).__name__ in ('evol_elas','evol_noli',) + dico = RESULTAT.LIST_CHAMPS() + dico2 = RESULTAT.LIST_VARI_ACCES() + iret,ibid,n_modele = aster.dismoi('F','MODELE',RESULTAT.nom,'RESULTAT') + MODEL = self.get_concept(n_modele) + if INST != 0.0 : + if not INST in dico2['INST'] : + UTMESS('F','POST0_20',valr=INST) + else : + if not NUME_ORDRE in dico['SIEF_ELNO_ELGA'] : + if NUME_ORDRE in dico['DEPL'] : + CALC_ELEM(RESULTAT=RESULTAT,reuse=RESULTAT,OPTION='SIEF_ELNO_ELGA', + NUME_ORDRE=NUME_ORDRE) + else : + UTMESS('F','POST0_19',vali=NUME_ORDRE) + dico = RESULTAT.LIST_CHAMPS() + + # Calcul des deformations sur les peaux inf et sup : + if CHAM=='DEFORMATION': + if NUME_ORDRE: + __ressup=CALC_ELEM(RESULTAT=RESULTAT, + OPTION='EPSI_ELNO_DEPL',REPE_COQUE=_F(NIVE_COUCHE='SUP'), + NUME_ORDRE=NUME_ORDRE) + __resinf=CALC_ELEM(RESULTAT=RESULTAT, + OPTION='EPSI_ELNO_DEPL',REPE_COQUE=_F(NIVE_COUCHE='INF'), + NUME_ORDRE=NUME_ORDRE) + __epssup=CREA_CHAMP(RESULTAT=__ressup,TYPE_CHAM='ELNO_EPSI_R', + OPERATION='EXTR',NOM_CHAM='EPSI_ELNO_DEPL', + NUME_ORDRE=NUME_ORDRE) + __epsinf=CREA_CHAMP(RESULTAT=__resinf,TYPE_CHAM='ELNO_EPSI_R', + OPERATION='EXTR',NOM_CHAM='EPSI_ELNO_DEPL', + NUME_ORDRE=NUME_ORDRE) + else : + __ressup=CALC_ELEM(RESULTAT=RESULTAT, + OPTION='EPSI_ELNO_DEPL',REPE_COQUE=_F(NIVE_COUCHE='SUP'), + INST=INST) + __resinf=CALC_ELEM(RESULTAT=RESULTAT, + OPTION='EPSI_ELNO_DEPL',REPE_COQUE=_F(NIVE_COUCHE='INF'), + INST=INST) + __epssup=CREA_CHAMP(RESULTAT=__ressup,TYPE_CHAM='ELNO_EPSI_R', + OPERATION='EXTR',NOM_CHAM='EPSI_ELNO_DEPL', + INST=INST) + __epsinf=CREA_CHAMP(RESULTAT=__resinf,TYPE_CHAM='ELNO_EPSI_R', + OPERATION='EXTR',NOM_CHAM='EPSI_ELNO_DEPL', + INST=INST) + + + # Appel MACR_LIGN_COUPE : + motscles={} + if CHAM=='EFFORT' : motscles['NOM_CHAM'] ='SIEF_ELNO_ELGA' + if CHAM=='DEFORMATION' : motscles['NOM_CHAM'] ='EPSI_ELNO_DEPL' + + if CHAM=='EFFORT' : + motscles['LIGN_COUPE']=[] + iocc=0 + for m in COOR_POINT: + iocc=iocc+1 + lst=m['COOR'] + if len(lst)==4 : + if lst[3]!=0. : + UTMESS('A','POST0_21',vali=iocc,valr=lst[3]) + lst=lst[0:3] + motscles['LIGN_COUPE'].append(_F(TYPE='SEGMENT', + NB_POINTS=2, + COOR_ORIG=lst, + COOR_EXTR=lst, + DISTANCE_MAX=10.0,),) + __tabl=MACR_LIGN_COUPE(RESULTAT=RESULTAT,**motscles) + + if CHAM=='DEFORMATION' : + tab2=Table() + iocc=0 + for m in COOR_POINT: + motscles['LIGN_COUPE']=[] + iocc=iocc+1 + lst=m['COOR'] + if len(lst)!=4 : + UTMESS('F','POST0_22',vali=iocc,) + elif (lst[3]>1.) or (lst[3]<-1.) : + UTMESS('F','POST0_23',vali=iocc,valr=lst[3],) + coesup=0.5+lst[3]*0.5 + coeinf=0.5-lst[3]*0.5 + __epsz=CREA_CHAMP(TYPE_CHAM='ELNO_EPSI_R',OPERATION='ASSE', + MODELE=MODEL, + ASSE=( + _F(TOUT='OUI', + CHAM_GD=__epsinf, + CUMUL='OUI', + COEF_R=coeinf,), + _F(TOUT='OUI', + CHAM_GD=__epssup, + CUMUL='OUI', + COEF_R=coesup,),),); + lst=lst[0:3] + motscles['LIGN_COUPE'].append(_F(TYPE='SEGMENT', + NB_POINTS=2, + COOR_ORIG=lst, + COOR_EXTR=lst, + DISTANCE_MAX=10.0,),) + __tab=MACR_LIGN_COUPE(CHAM_GD=__epsz,MODELE=MODEL,**motscles) + __tab2=__tab.EXTR_TABLE() + for ligne in __tab2: + tab2.append(ligne) + tab2=tab2[__tab2.para] + + if CHAM=='EFFORT' : + tab2=__tabl.EXTR_TABLE() + tab3=(tab2.INST==INST) + tab2=tab3 + + tab4=Table() + ilig=0 + for ligne in tab2: + ilig=ilig+1 + if(ilig%2)==0: + tab4.append(ligne) + tab4=tab4[tab2.para] + dprod = tab4.dict_CREA_TABLE() + tabout = CREA_TABLE(TYPE_TABLE='TABLE', + **dprod) + RetablirAlarme('MODELISA4_9') + return ier + diff --git a/Aster/Cata/cataSTA10/Macro/post_dyna_alea_ops.py b/Aster/Cata/cataSTA10/Macro/post_dyna_alea_ops.py index 1ce2ed70..0d3f6714 100644 --- a/Aster/Cata/cataSTA10/Macro/post_dyna_alea_ops.py +++ b/Aster/Cata/cataSTA10/Macro/post_dyna_alea_ops.py @@ -1,4 +1,4 @@ -#@ MODIF post_dyna_alea_ops Macro DATE 16/11/2009 AUTEUR COURTOIS M.COURTOIS +#@ MODIF post_dyna_alea_ops Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -19,7 +19,6 @@ # ====================================================================== import random -import Numeric from types import ListType, TupleType from math import pi,sqrt,log,exp @@ -27,6 +26,7 @@ EnumTypes = (ListType, TupleType) def post_dyna_alea_ops(self,INTE_SPEC, FRAGILITE,TITRE,INFO,**args): + import numpy as NP import aster from Accas import _F from Utilitai.Utmess import UTMESS @@ -117,9 +117,9 @@ def post_dyna_alea_ops(self,INTE_SPEC, FRAGILITE,TITRE,INFO,**args): Nbval=len(liste_indic) - test1 = Numeric.equal(None,liste_indic) - test2 = Numeric.equal(None,liste_def) - if test1 >=1 or test2 >=1: + test1 = NP.equal(None,liste_indic) + test2 = NP.equal(None,liste_def) + if test1.any() or test2.any(): UTMESS('F','TABLE0_15') # estimation paramètres @@ -130,8 +130,8 @@ def post_dyna_alea_ops(self,INTE_SPEC, FRAGILITE,TITRE,INFO,**args): aster.affiche('MESSAGE',texte) #print 'parametres Am, beta estimes: ', xopt #courbe de fragilité - vec_a=Numeric.array(liste_a) - vecval=(Numeric.log(vec_a/xopt[0]))/xopt[1] + vec_a=NP.array(liste_a) + vecval=(NP.log(vec_a/xopt[0]))/xopt[1] for m in range(Nba): lpfa.append(normcdf(vecval[m])) @@ -181,7 +181,7 @@ def post_dyna_alea_ops(self,INTE_SPEC, FRAGILITE,TITRE,INFO,**args): texte2=' PARAMETRES Am, beta ESTIMES : '+str(xopt)+'\n' aster.affiche('MESSAGE',texte1) aster.affiche('MESSAGE',texte2) - vecval=(Numeric.log(vec_a/xopt[0]))/xopt[1] + vecval=(NP.log(vec_a/xopt[0]))/xopt[1] for m in range(Nba): lpfa.append(normcdf(vecval[m])) @@ -374,8 +374,8 @@ def post_dyna_alea_ops(self,INTE_SPEC, FRAGILITE,TITRE,INFO,**args): FILTRE = mcfact, ) val = __fon1.Valeurs() - fvalx= Numeric.array(val[0]) - fvaly= Numeric.array(val[1]) + fvalx= NP.array(val[0]) + fvaly= NP.array(val[1]) frez = fvalx[0] # -- moments spectraux @@ -383,11 +383,11 @@ def post_dyna_alea_ops(self,INTE_SPEC, FRAGILITE,TITRE,INFO,**args): val_mom={} for i_mom in l_moments : n = len(fvaly) - trapz = Numeric.zeros(n,Numeric.Float) + trapz = NP.zeros(n) trapz[0] = 0. valy = fvaly*(2*pi*fvalx)**i_mom trapz[1:n] = (valy[1:n]+valy[:-1])/2*(fvalx[1:n]-fvalx[:-1]) - prim_y = Numeric.cumsum(trapz) + prim_y = NP.cumsum(trapz) val_mom[i_mom] = prim_y[-1] for i_mom in l_moments : chmo='LAMBDA_'+str(i_mom).zfill(2) diff --git a/Aster/Cata/cataSTA10/Macro/post_endo_fiss_ops.py b/Aster/Cata/cataSTA10/Macro/post_endo_fiss_ops.py new file mode 100644 index 00000000..e5a282e0 --- /dev/null +++ b/Aster/Cata/cataSTA10/Macro/post_endo_fiss_ops.py @@ -0,0 +1,868 @@ +#@ MODIF post_endo_fiss_ops Macro DATE 31/05/2010 AUTEUR COURTOIS M.COURTOIS + +# 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. +# ====================================================================== +# RESPONSABLE BOTTONI M.BOTTONI +# --------------------------------------------------------------------------- +# POST_ENDO_FISS +# PROCEDURE PYTHON DU RECHERCHE DU TRAJET DE FISSURATION SUR UN +# CHAMP SCALAIRE 2D + + + +# ---------------------------- +# +# FONCTIONS UTILES +# +# ---------------------------- + +# FIND IN A VECTOR : +# Fonction qui trouve tous les valeurs dans "Vect" +# egal au scalaire "a". +# On retourne tous les indices des valeurs cherchees +# Vect doit etre un vecteur unidimensionnel +def vfind(Vect,a) : + import numpy as NP + Vect0 = Vect-a + lst0 = NP.nonzero(Vect0)[0] + NP.put(Vect0,lst0, NP.ones(lst0.shape)) + Vect0 = Vect0-1 + lst0 = NP.nonzero(Vect0)[0] + return lst0 + +# DELETE ELEMENT IN A VECTOR : +# Fonction qui sert a effacer des elements d'un vecteur Vect +# (element array unidimmensionnel ou matrice avec la deuxieme dimension 1) +# a: vecteur d'indices avec le meme cahracteristiques que Vect +def delEl(Vect,a) : + import numpy as NP + class LengthError(Exception): + pass + + shapeV = Vect.shape + if type(a) == list : + a=NP.array(a) + shapea = a.shape + + lenErr = True + if len(shapeV)==1 : + lenErr = False + if len(shapea)==1 : + lenErr = False + if len(shapea)==2 and (shapea[0]==1 or shapea[1]==1) : + lenErr = False + if lenErr : + raise LengthError + + Vect = Vect.tolist() + a = NP.ravel(a) + a = NP.sort(a) + + for i in range(len(a)) : + idx = a[i] + try : + del Vect[idx] + except TypeError : + raise TypeError + a = a-1 + + Vect = NP.array(Vect) + return Vect + + +# RETURN A UNIQUE VECTOR +# Fonction qui elimine les doublons dans un vecteur Vect +# Vect doit etre un vecteur unidimensionnel +def unique(Vect): + i = 0 + while i < len(Vect) : + num = Vect[i] + idxDou = vfind(Vect, num) + if len(idxDou)>1 : + idxDou = idxDou[1:len(idxDou)] + Vect = delEl(Vect,idxDou) + i = i+1 + return Vect + + + +# CREATE A 1D-MESH : +# Cree un maillage SEG2 en 2D +# Coorx : liste des coordonnees x des noeuds +# Coory : liste des coordonnees y des noeuds +# Connex : connectivites entre les noeuds +# (liste de tuples d'entiers) +# + +def crea_mail_lin(XcreteTot,YcreteTot,ConnTot,dime): + resu = 'TITRE\n' + titre = 'Maillage lineaire'+'\n' + resu = resu + titre + resu = resu+'FINSF\n' + + # creation des noeuds + resu = resu+'COOR_'+str(dime)+'D\n' + CoorX = XcreteTot[0] + CoorY = YcreteTot[0] + for i in range(1,len(XcreteTot)) : + CoorX = CoorX + XcreteTot[i] + CoorY = CoorY + YcreteTot[i] + nbNoeu = len(CoorX) + for i in range(nbNoeu): + nbno = i+1 + x = CoorX[i] + y = CoorY[i] + noeud = ' N'+str(nbno)+' '+str(x)+' '+str(y)+'\n' + resu = resu + noeud + resu = resu+'FINSF\n' + + # creation des mailles + resu = resu+'SEG2\n' + nbmailTot = 0 + nbNoTot = 0 + for j in range(len(ConnTot)) : + Connex = ConnTot[j] + nbmail = len(Connex) + for i in range(nbmail) : + nbma = i+1+nbmailTot + ma = Connex[i] + maille = ' M'+str(nbma)+' N'+str(ma[0]+nbNoTot)+' N'+str(ma[1]+nbNoTot)+'\n' + resu = resu+maille + nbmailTot = nbmailTot + len(Connex) + nbNoTot = nbNoTot + len(XcreteTot[j]) + resu = resu+'FINSF\n' + + # creation des groupes de mailles "fissure" + nbmailTot = 0 + for j in range(len(ConnTot)): + resu = resu+'GROUP_MA\n' + resu = resu+'FISSURE'+str(j+1)+'\n' + Connex = ConnTot[j] + nbmail = len(Connex) + for i in range(nbmail): + nbma = i+1+nbmailTot + resu = resu +' M'+str(nbma)+'\n' + resu = resu+'\n' + resu = resu+'FINSF\n' + nbmailTot = nbmailTot + len(Connex) + + resu = resu+'FIN\n' + return resu + + + + + + + + + + + +# ------------------------------------------ +# +# ROUTINE POUR LA RECHERCHE DE LA CRETE +# POST ENDO FISS +# +# ------------------------------------------ + +def post_endo_fiss_ops(self, + TABLE, + NOM_CMP, + NOM_CHAM, + RECHERCHE, + **args) : + + from Macro.macr_lign_coupe_ops import crea_noeu_lig_coup + from Macro.macr_lign_coupe_ops import crea_mail_lig_coup + from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme + from Utilitai.UniteAster import UniteAster + from Accas import _F + from math import radians + import os + import numpy as NP + + + ier = 0 + # La macro compte pour 1 dans la numerotation des commandes + self.set_icmd(1) + + MasquerAlarme('CALCULEL5_48') + + # -------------------------------------------------- + # IMPORTATION COMMANDES ASTER + # + LIRE_MAILLAGE = self.get_cmd('LIRE_MAILLAGE') + AFFE_MODELE = self.get_cmd('AFFE_MODELE') + PROJ_CHAMP = self.get_cmd('PROJ_CHAMP') + CREA_TABLE = self.get_cmd('CREA_TABLE') + CREA_RESU = self.get_cmd('CREA_RESU') + CREA_CHAMP = self.get_cmd('CREA_CHAMP') + + + # -------------------------------------------------- + # DECLARATION SORTIES + # + self.DeclareOut('__MAIFI',self.sd) + self.DeclareOut('__tabRes',TABLE) + + + # -------------------------------------------------- + # RECUPERATION ENTREES + # + l_dRECHERCHE = [] + for recherche in RECHERCHE : + dRECHERCHE = recherche.cree_dict_valeurs(recherche.mc_liste) + for i in dRECHERCHE.keys(): + if dRECHERCHE[i]==None : del dRECHERCHE[i] + l_dRECHERCHE.append(dRECHERCHE) + + # -------------------------------------------------- + # TEST SUR LE TYPE DE CHAMP + # + ltyP_cham = ['NOEU_DEPL_R','ELGA_EPSI_R','ELNO_EPSI_R','NOEU_SIEF_R','ELGA_VARI_R','ELNO_VARI_R','ELNO_VARI_R','NOEU_VAR2_R'] + lnoM_cham = ['DEPL','EPSI_ELGA_DEPL','EPSI_ELNO_DEPL','EPSI_NOEU_DEPL','VARI_ELGA','VARI_ELNO','VARI_ELNO_ELGA','VARI_NOEU_ELGA'] + + if NOM_CHAM in lnoM_cham : + Xtype_cham = ltyP_cham[lnoM_cham.index(NOM_CHAM)] + else : + UTMESS('F','POST0_35') + + + # -------------------------------------------------- + # RECUPERATION ENTREES, MODELE ET MAILLAGE + # + motscles = {} + + if args['CHAM_GD'] != None : + build = 'champ' + __YBARTO = args['CHAM_GD'] + __modtot = args['MODELE'] + #n_modele = (__modtot.nom).strip() + inst = 1. + motscles['INST'] = inst + + else : + build = 'resu' + __RESUIN = args['RESULTAT'] + nomresu = __RESUIN.nom + dicResu = __RESUIN.LIST_PARA() + + if args['NUME_ORDRE'] != None : + inst = 1. + nume_ordre = args['NUME_ORDRE'] + motscles['NUME_ORDRE'] = nume_ordre + else : + inst = args['INST'] + motscles['INST'] = inst + dicVarAcc = __RESUIN.LIST_VARI_ACCES() + nume_ordre = dicVarAcc['INST'].index(inst) + 1 + + if args['MODELE'] != None : + __modtot = args['MODELE'] + elif dicResu['MODELE'][0] is not None: + lst_n_modele = dicResu['MODELE'] + n_modele = lst_n_modele[nume_ordre-1] + n_modele = n_modele.strip() + __modtot = self.get_concept(n_modele) + else : + UTMESS('F','POST0_33') + + + n_mail = __modtot.MODELE.LGRF.get() + n_mail = n_mail[0].strip() + __mail = self.get_concept(n_mail) + Coortot = __mail.COORDO.VALE.get() + Xtot = Coortot[0:len(Coortot):3] + Ytot = Coortot[1:len(Coortot):3] + + dime = __mail.DIME.get()[5] + if dime != 2 : + UTMESS('F','POST0_34') + + + if build == 'resu' : + __YBARTO = CREA_CHAMP(TYPE_CHAM = Xtype_cham, + OPERATION = 'EXTR', + RESULTAT = __RESUIN, + NOM_CHAM = NOM_CHAM, + **motscles) + + + + # -------------------------------------------------- + # BOUCLE SUR L'OCCURRENCE DU MOT-CLEF RECHERCHE + # + XcreteTot = [] + YcreteTot = [] + ConnTot = [] + YbarcreteTot = [] + lstFissure = [] + + + for idxRech in range(len(l_dRECHERCHE)) : + + dRECHERCHE = l_dRECHERCHE[idxRech] + + # --------------------------------- + # Recuperation valeurs d'entrees + # + lort = dRECHERCHE['LONG_ORTH'] + nbPoints = dRECHERCHE['NB_POINT'] + pas = dRECHERCHE['PAS'] + lreg = dRECHERCHE['LONG_REG'] + seuil = dRECHERCHE['SEUIL'] + alpha = dRECHERCHE['ANGL_MAX'] + seuil = dRECHERCHE['SEUIL'] + + if 'GROUP_MA' in dRECHERCHE.keys() : + groupma = dRECHERCHE['GROUP_MA'] + + # -------------------------------------------------- + # Construction du concept resultat de travail + # + if build == 'champ' : + if 'GROUP_MA' in dRECHERCHE.keys() : + __YBARNO = CREA_CHAMP(OPERATION = 'ASSE', + TYPE_CHAM = Xtype_cham, + MODELE = __modtot, + ASSE = _F(CHAM_GD = __YBARTO, + GROUP_MA = groupma, + NOM_CMP = NOM_CMP, + ),) + else : + __YBARNO = __YBARTO + + + if build == 'resu' : + if 'GROUP_MA' in dRECHERCHE.keys() : + __YBARNO = CREA_CHAMP(OPERATION = 'ASSE', + TYPE_CHAM = Xtype_cham, + MODELE = __modtot, + ASSE = _F(CHAM_GD = __YBARTO, + GROUP_MA = groupma, + NOM_CMP = NOM_CMP, + ),) + else : + __YBARNO = __YBARTO + + + __resu = CREA_RESU( OPERATION = 'AFFE', + TYPE_RESU = 'EVOL_NOLI', + NOM_CHAM = NOM_CHAM, + AFFE = (_F( CHAM_GD = __YBARNO, + #MODELE = __modtot, + INST = inst),),) + + + # -------------------------------------------------------------- + # Recuperation dans Python des valeurs du champ et du maillage + # + Ybarno = __YBARNO.EXTR_COMP(NOM_CMP,[],1) + Ybar = Ybarno.valeurs + Noeybar = Ybarno.noeud + IdxNoeud = NP.array(Noeybar)-1 + Coorx = NP.take(Xtot,IdxNoeud) + Coory = NP.take(Ytot,IdxNoeud) + + + # -------------------------------------------------- + # Amorcage de la procedure de recherche de la crete + # + + # Point ou la Ybar est maximale + # + idxmax = NP.argmax(Ybar) + xmax = Coorx[idxmax] + ymax = Coory[idxmax] + ybarmax = Ybar[idxmax] + + CoxAmm = NP.array([xmax], float) + CoyAmm = NP.array([ymax], float) + YbarAmm = NP.array([ybarmax], float) + + # Creation d'un circle autour du point de max + # et projection sur le circle + # + lignes = [] + groups = [] + arcs = [] + arcs.append(([xmax+pas,ymax],[xmax,ymax],nbPoints,180.)) + arcs.append(([xmax-pas,ymax],[xmax,ymax],nbPoints,180.)) + resu_mail0,arcgma0,angles0,nbno0 = crea_mail_lig_coup(dime,lignes,groups,arcs) + + + nomFichierSortie = os.path.join(os.getcwd(),'maillage.mail') + fproc = open(nomFichierSortie, 'w') + fproc.write(resu_mail0) + fproc.close() + UL = UniteAster() + uniteMail = UL.Libre(action = 'ASSOCIER', nom = nomFichierSortie) + + __MAI = LIRE_MAILLAGE(UNITE = uniteMail) + UL.EtatInit(uniteMail) + + + __MO = AFFE_MODELE(MAILLAGE = __MAI, + AFFE = _F(TOUT = 'OUI', + PHENOMENE = 'MECANIQUE', + MODELISATION = 'BARRE'),) + + __YBARPR = PROJ_CHAMP(METHODE = 'ELEM', + RESULTAT = __resu, + MODELE_1 = __modtot, + MODELE_2 = __MO, + DISTANCE_MAX = 0., + TYPE_CHAM = 'NOEU', + NOM_CHAM = NOM_CHAM, + NUME_ORDRE = 1, ) + + __YBARCH = CREA_CHAMP(TYPE_CHAM = Xtype_cham, + OPERATION = 'EXTR', + NOM_CHAM = NOM_CHAM, + RESULTAT = __YBARPR, + NUME_ORDRE = 1,) + + dx0 = __YBARCH.EXTR_COMP(NOM_CMP,[],1) + + # Nonvide : liste de noeud du profil orthogonal + # avec des valeurs associes + # idxpred : connections entres les 2 demi-circle + Nonvide = NP.array(list(dx0.noeud)) + idxpred1 = vfind(Nonvide,2*nbPoints-1) + idxpred2 = vfind(Nonvide,nbPoints) + + Ybarort = dx0.valeurs + Coor0 = __MAI.COORDO.VALE.get() + Coorxort = NP.array(Coor0[0:len(Coor0):3] , float) + Cooryort = NP.array(Coor0[1:len(Coor0):3] , float) + + # On elimine les noeuds sans valeurs associes + Coorxort = NP.take(Coorxort,Nonvide-1) + Cooryort = NP.take(Cooryort,Nonvide-1) + Coorxort = delEl(Coorxort,idxpred1) + Coorxort = delEl(Coorxort,idxpred2) + Cooryort = delEl(Cooryort,idxpred1) + Cooryort = delEl(Cooryort,idxpred2) + Ybarort = delEl(Ybarort,idxpred1) + Ybarort = delEl(Ybarort,idxpred2) + + # Regularisation sur le circle + YbarReg = NP.zeros((len(Ybarort),), float) + X1 = NP.concatenate((Coorxort[1:len(Coorxort)], NP.array([Coorxort[0]]))) + Y1 = NP.concatenate((Cooryort[1:len(Coorxort)], NP.array([Cooryort[0]]))) + DX = X1-Coorxort + DY = Y1-Cooryort + DS = NP.sqrt(DX**2+DY**2) + for l in range(len(Ybarort)): + DSa = DS[(l-1):len(DS)] + DSb = DS[0:(l-1)] + DS1 = NP.concatenate((DSa,DSb)) + Dist = NP.zeros((len(Ybarort),), float) + Gauss = NP.zeros((len(Ybarort),), float) + for k in range(len(Ybarort)/2): + Dist[k+1] = Dist[k] + DS1[k] + Dist[-k-1] = Dist[-k] + DS1[-k-1] + for k in range(len(Ybarort)): + Gauss[k] = NP.e**(-(2*Dist[k]/(pas/5))**2) + + Gauss2 = NP.concatenate((Gauss[1:len(Gauss)], NP.array([Gauss[0]]))) + Den = DS1 * ((Gauss + Gauss2)/2) + + YbarortShft = NP.concatenate((Ybarort[l:len(Ybarort)],Ybarort[0:(l)])) + Ybargauss = YbarortShft * Gauss + Ybargauss2 = NP.concatenate((Ybargauss[1:len(Ybargauss)], NP.array([Ybargauss[0]]))) + Num = DS1 * ((Ybargauss + Ybargauss2)/2) + + YbarReg[l] = NP.sum(Num)/NP.sum(Den) + + # Deuxieme point de la crete + idxmax = NP.argmax(YbarReg) + valmax = Ybarort[idxmax] + cox = Coorxort[idxmax] + coy = Cooryort[idxmax] + + CoxAmm = NP.concatenate((CoxAmm, NP.array([cox]))) + CoyAmm = NP.concatenate((CoyAmm, NP.array([coy]))) + YbarAmm = NP.concatenate((YbarAmm, NP.array([valmax]))) + + + # On re-calcule le premier point + # + CoxLast = NP.array([ CoxAmm[1] , CoxAmm[0] ]) + CoyLast = NP.array([ CoyAmm[1] , CoyAmm[0] ]) + VersAvan = NP.array([CoxLast[1] - CoxLast[0], CoyLast[1] - CoyLast[0]]) + VersAvan = VersAvan / (NP.sqrt((VersAvan[0])**2 + (VersAvan[1])**2)) + + Ppred = NP.array([CoxLast[0] + VersAvan[0]*pas, CoyLast[0] + VersAvan[1]*pas ]) + VersNorm = (1 / NP.sqrt((VersAvan[0])**2 + (VersAvan[1])**2)) * NP.array([ -VersAvan[1] , VersAvan[0] ]) + PPlus = NP.array([ Ppred[0] + (lort/2)*VersNorm[0] , Ppred[1] + (lort/2)*VersNorm[1] ]) + PMoin = NP.array([ Ppred[0] - (lort/2)*VersNorm[0] , Ppred[1] - (lort/2)*VersNorm[1] ]) + + # creation du profil orthogonal + lignes = [] + groups = [] + arcs = [] + lignes = [] + lignes.append((PMoin.tolist(),Ppred.tolist(),nbPoints)) + lignes.append((Ppred.tolist(),PPlus.tolist(),nbPoints)) + resu_mail0,arcgma0,angles0,nbno0 = crea_mail_lig_coup(dime,lignes,groups,arcs) + + fproc = open(nomFichierSortie, 'w') + fproc.write(resu_mail0) + fproc.close() + UL = UniteAster() + uniteMail = UL.Libre(action = 'ASSOCIER', nom = nomFichierSortie) + + __MAI = LIRE_MAILLAGE(UNITE = uniteMail) + UL.EtatInit(uniteMail) + + __MO = AFFE_MODELE(MAILLAGE = __MAI, + AFFE = _F(TOUT = 'OUI', + PHENOMENE = 'MECANIQUE', + MODELISATION = 'BARRE'),) + + __YBARPR = PROJ_CHAMP(METHODE = 'ELEM', + RESULTAT = __resu, + MODELE_1 = __modtot, + MODELE_2 = __MO, + DISTANCE_MAX = 0., + TYPE_CHAM = 'NOEU', + NOM_CHAM = NOM_CHAM, + NUME_ORDRE = 1, ) + + + __YBARCH = CREA_CHAMP(TYPE_CHAM = Xtype_cham, + OPERATION = 'EXTR', + NOM_CHAM = NOM_CHAM, + RESULTAT = __YBARPR, + NUME_ORDRE = 1,) + + dx0 = __YBARCH.EXTR_COMP(NOM_CMP,[],1) + + + # Pas de cas ou le point de prediction est hors de matiere! + # Recherche du point de prediction parmis les points projetes + # et elimination du double point au milieu + Nonvide = NP.array(list(dx0.noeud)) + idxpred = vfind(Nonvide,nbPoints) + Ybarort = dx0.valeurs + + Coor0 = __MAI.COORDO.VALE.get() + Coorxort = NP.array(Coor0[0:len(Coor0):3] , float) + Cooryort = NP.array(Coor0[1:len(Coor0):3] , float) + Coorxort = NP.take(Coorxort,Nonvide-1) + Cooryort = NP.take(Cooryort,Nonvide-1) + Coorxort = delEl(Coorxort,idxpred) + Cooryort = delEl(Cooryort,idxpred) + Ybarort = delEl(Ybarort,idxpred) + + # Regularisation du profil orthogonal + YbarReg = NP.zeros((len(Ybarort),), float) + for l in range(len(Ybarort)): + xcentre = Coorxort[l] + ycentre = Cooryort[l] + Dist = ((Coorxort-xcentre)**2 + (Cooryort-ycentre)**2)**0.5 + Gauss = NP.zeros((len(Dist),), float) + for m in range(len(Dist)) : + Gauss[m] = NP.e**(-(2*Dist[m]/lreg)**2) + Ybargauss = Ybarort * Gauss + DeltaL = NP.absolute(Dist[0:len(Dist)-1] - Dist[1:len(Dist)]) + Num = DeltaL * (Ybargauss[0:len(Dist)-1] + Ybargauss[1:len(Dist)])/2 + Den = DeltaL * (Gauss[0:len(Dist)-1] + Gauss[1:len(Dist)])/2 + + YbarReg[l] = NP.sum(Num)/NP.sum(Den) + + # Premier point de la crete + idxmax = NP.argmax(YbarReg) + valmax = Ybarort[idxmax] + cox = Coorxort[idxmax] + coy = Cooryort[idxmax] + CoxAmm[0] = cox + CoyAmm[0] = coy + YbarAmm[0]= valmax + + + + # -------------------------------------------------- + # Recherche de la crete apres amorcage + # + + + # Definition des deux directions d'avancement possibles + # + VersAvn1 = NP.array([CoxAmm[1]-CoxAmm[0],CoyAmm[1]-CoyAmm[0]]) + module = ((VersAvn1[0])**2 + (VersAvn1[1])**2)**0.5 + VersAvn1 = VersAvn1 * (1/module) + VersAvn2 = -VersAvn1 + + # Initialisation vecteurs + # + Coxcrete1 = NP.array([CoxAmm[1]]) + Coycrete1 = NP.array([CoyAmm[1]]) + Ybarcrete1 = NP.array([YbarAmm[1]]) + + Coxcrete2 = NP.array([CoxAmm[0]]) + Coycrete2 = NP.array([CoyAmm[0]]) + Ybarcrete2 = NP.array([YbarAmm[0]]) + + # Boucle sur les points de la crete + # Variables du boucle : + # dirRech --> direction de recherche, 1,2 + # condSort --> condition de sortie du boucle + dirRech = 1 + i = 0 + condSort = 1. + seuil + while (condSort > seuil and dirRech<=2) : + i = i+1 + # Determination du vecteur d'avancement + if i==1: + if dirRech == 1: + VersAvan = VersAvn1 + else: + VersAvan = VersAvn2 + else: + if dirRech == 1: + CoxLast = NP.array( [Coxcrete1[i-2] , Coxcrete1[i-1] ]) + CoyLast = NP.array([ Coycrete1[i-2] , Coycrete1[i-1] ]) + else : + CoxLast = NP.array( [Coxcrete2[i-2] , Coxcrete2[i-1] ]) + CoyLast = NP.array([ Coycrete2[i-2] , Coycrete2[i-1] ]) + VersAvan = NP.array([CoxLast[1]-CoxLast[0],CoyLast[1]-CoyLast[0]]) + module = ((VersAvan[0])**2. + (VersAvan[1])**2.)**0.5 + VersAvan = VersAvan * (1/module) + + if dirRech == 1: + PStart = NP.array([Coxcrete1[i-1],Coycrete1[i-1]]) + else: + PStart = NP.array([Coxcrete2[i-1],Coycrete2[i-1]]) + + # point de prediction + Ppred = NP.array([PStart[0] + VersAvan[0]*pas, PStart[1] + VersAvan[1]*pas ]) + VersNorm = (1. / NP.sqrt((VersAvan[0])**2. + (VersAvan[1])**2.)) * NP.array([ -VersAvan[1] , VersAvan[0] ]) + PPlus = NP.array([ Ppred[0] + (lort/2.)*VersNorm[0] , Ppred[1] + (lort/2.)*VersNorm[1] ]) + PMoin = NP.array([ Ppred[0] - (lort/2.)*VersNorm[0] , Ppred[1] - (lort/2.)*VersNorm[1] ]) + + # creation du profil orthogonal + lignes = [] + groups = [] + arcs = [] + lignes.append((PMoin.tolist(),Ppred.tolist(),nbPoints)) + lignes.append((Ppred.tolist(),PPlus.tolist(),nbPoints)) + resu_mail0,arcgma0,angles0,nbno0 = crea_mail_lig_coup(dime,lignes,groups,arcs) + + fproc = open(nomFichierSortie, 'w') + fproc.write(resu_mail0) + fproc.close() + UL = UniteAster() + uniteMail = UL.Libre(action = 'ASSOCIER', nom = nomFichierSortie) + + __MAI = LIRE_MAILLAGE(UNITE = uniteMail) + UL.EtatInit(uniteMail) + + __MO = AFFE_MODELE(MAILLAGE = __MAI, + AFFE = _F(TOUT = 'OUI', + PHENOMENE = 'MECANIQUE', + MODELISATION = 'BARRE'),) + + + try: + # on essaie de projeter, exception: il n'y a pas des points "dans la matiere" + __YBARPR = PROJ_CHAMP(METHODE = 'ELEM', + RESULTAT = __resu, + MODELE_1 = __modtot, + MODELE_2 = __MO, + DISTANCE_MAX = 0., + TYPE_CHAM = 'NOEU', + NOM_CHAM = NOM_CHAM, + NUME_ORDRE = 1,) + + except : + print "#MC dans EXCEPT" + # Attention!! Ici on gere seulement le cas d'aucun point dans la matiere! + # Il faudra gerer tous les possibles erreurs de proj_champ, ou trouver nom + # a l'erreur specifique! + if dirRech == 1 : + dirRech = 2 + i = 0 + else: + condSort = seuil * 0.1 + + else : + # si la projection est possible + __YBARCH = CREA_CHAMP(TYPE_CHAM = Xtype_cham, + OPERATION = 'EXTR', + NOM_CHAM = NOM_CHAM, + RESULTAT = __YBARPR, + NUME_ORDRE = 1,) + + dx0 = __YBARCH.EXTR_COMP(NOM_CMP,[],1) + Nonvide = NP.array(list(dx0.noeud)) + + # recherche du point de prediction parmis les points projetes + idxpred = vfind(Nonvide,nbPoints) + + # cas ou le point de prediction est hors matiere + if len(idxpred)==0: + if dirRech == 1: + dirRech = 2 + i = 0 + continue + else: + condSort = seuil*0.1 + break + + Ybarort = dx0.valeurs + Coor0 = __MAI.COORDO.VALE.get() + Coorxort = NP.array(Coor0[0:len(Coor0):3] , float) + Cooryort = NP.array(Coor0[1:len(Coor0):3] , float) + Coorxort = NP.take(Coorxort,Nonvide-1) + Cooryort = NP.take(Cooryort,Nonvide-1) + Coorxort = delEl(Coorxort,idxpred) + Cooryort = delEl(Cooryort,idxpred) + Ybarort = delEl(Ybarort,idxpred) + + # Regularisation sur le profil orthogonal + # + YbarReg = NP.zeros((len(Ybarort),), float) + for l in range(len(Ybarort)): + xcentre = Coorxort[l] + ycentre = Cooryort[l] + Dist = ((Coorxort-xcentre)**2 + (Cooryort-ycentre)**2)**0.5 + Gauss = NP.zeros((len(Dist),), float) + for m in range(len(Dist)) : + Gauss[m] = NP.e**(-(2*Dist[m]/lreg)**2) + + Ybargauss = Ybarort * Gauss + DeltaL = NP.absolute(Dist[0:len(Dist)-1] - Dist[1:len(Dist)]) + Num = DeltaL * (Ybargauss[0:len(Dist)-1] + Ybargauss[1:len(Dist)])/2 + Den = DeltaL * (Gauss[0:len(Dist)-1] + Gauss[1:len(Dist)])/2 + YbarReg[l] = NP.sum(Num)/NP.sum(Den) + + + # Nouveau point de la crete + # + idxmax = NP.argmax(YbarReg) + valmax = Ybarort[idxmax] + cox = Coorxort[idxmax] + coy = Cooryort[idxmax] + + + # on controle que l'angle forme par le point trouve + # et la direction de recherche ne soit pas plus grand + # du seuil "ANGL_MAX" + + if round(alpha) != 180. : + alphar = radians(alpha) + blim = pas * NP.tan(alphar/2.) + btest = ((cox-Ppred[0])**2. + (coy-Ppred[1])**2.)**0.5 + if btest > blim : + if dirRech == 1 : + dirRech = 2 + i = 0 + continue + else: + condSort = seuil*0.1 + break + + if dirRech == 1: + Coxcrete1 = NP.concatenate((Coxcrete1,NP.array([cox]))) + Coycrete1 = NP.concatenate((Coycrete1,NP.array([coy]))) + Ybarcrete1 = NP.concatenate((Ybarcrete1,NP.array([valmax]))) + else: + Coxcrete2 = NP.concatenate((Coxcrete2,NP.array([cox]))) + Coycrete2 = NP.concatenate((Coycrete2,NP.array([coy]))) + Ybarcrete2 = NP.concatenate((Ybarcrete2,NP.array([valmax]))) + + condSort = valmax + if condSort <= seuil and dirRech == 1 : + dirRech = 2 + i = 0 + + Coxcrete1 = Coxcrete1.tolist() + Coxcrete2 = Coxcrete2.tolist() + Coycrete1 = Coycrete1.tolist() + Coycrete2 = Coycrete2.tolist() + Ybarcrete1 = Ybarcrete1.tolist() + Ybarcrete2 = Ybarcrete2.tolist() + Coxcrete2.reverse() + Coycrete2.reverse() + Ybarcrete2.reverse() + Coxcrete2.extend(Coxcrete1) + Coycrete2.extend(Coycrete1) + Ybarcrete2.extend(Ybarcrete1) + + + nbNoeud = len(Coxcrete2) + Connex = [] + for idxNo in range(nbNoeud-1) : + no1 = idxNo+1 + no2 = idxNo+2 + ma = (no1,no2) + Connex.append(ma) + + XcreteTot.append(Coxcrete2) + YcreteTot.append(Coycrete2) + YbarcreteTot.append(Ybarcrete2) + ConnTot.append(Connex) + lstFissure = lstFissure + ( ['FISS'+str(idxRech+1)]*len(Coxcrete2) ) + + lstX = [] + lstY = [] + lstYbar = [] + for i in range(len(XcreteTot)) : + lstX = lstX + XcreteTot[i] + lstY = lstY + YcreteTot[i] + lstYbar = lstYbar + YbarcreteTot[i] + + + + # -------------------------------------------------- + # CREATION D'UNE TABLE POUR LE STOCKAGE DE POINTS DE + # LA CRETE ET DE L'OUVERTURE DE FISSURE + # + + __tabRes = CREA_TABLE(LISTE = ( + _F(PARA = 'FISSURE' , LISTE_K = lstFissure ), + _F(PARA = 'COORX' , LISTE_R = lstX ), + _F(PARA = 'COORY' , LISTE_R = lstY ), + _F(PARA = 'CHAMP' , LISTE_R = lstYbar), + ),) + + + # -------------------------------------------------- + # CREATION D'UNE SD MAILLAGE DE LA CRETE + # + resu_mail0 = crea_mail_lin(XcreteTot,YcreteTot,ConnTot,dime) + + + fproc = open(nomFichierSortie, 'w') + fproc.write(resu_mail0) + fproc.close() + UL = UniteAster() + uniteMail = UL.Libre(action = 'ASSOCIER', nom = nomFichierSortie) + __MAIFI = LIRE_MAILLAGE(UNITE = uniteMail) + UL.EtatInit(uniteMail) + + + # -------------------------------------------------- + # SORTIE DE LA MACRO + # + RetablirAlarme('CALCULEL5_48') + return ier + diff --git a/Aster/Cata/cataSTA10/Macro/post_k1_k2_k3_ops.py b/Aster/Cata/cataSTA10/Macro/post_k1_k2_k3_ops.py index f91608af..2cf042f8 100644 --- a/Aster/Cata/cataSTA10/Macro/post_k1_k2_k3_ops.py +++ b/Aster/Cata/cataSTA10/Macro/post_k1_k2_k3_ops.py @@ -1,4 +1,4 @@ -#@ MODIF post_k1_k2_k3_ops Macro DATE 16/11/2009 AUTEUR COURTOIS M.COURTOIS +#@ MODIF post_k1_k2_k3_ops Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -32,6 +32,7 @@ def veri_tab(tab,nom,ndim) : label='COOR_Z' UTMESS('F','RUPTURE0_2',valk=[label,nom]) +#TODO prefer use numpy.cross def cross_product(a,b): cross = [0]*3 cross[0] = a[1]*b[2]-a[2]*b[1] @@ -58,10 +59,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]: @@ -109,8 +110,7 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, import string import copy import math - import Numeric - from Numeric import array,asarray,Float,sqrt,matrixmultiply,transpose,sign,resize,dot,multiply + import numpy as NP from math import pi from types import ListType, TupleType from Accas import _F @@ -181,14 +181,14 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, if not Tempe3D : coefd3 = 0. - coefd = e * sqrt(2.*pi) + coefd = e * NP.sqrt(2.*pi) unmnu2 = 1. - nu**2 unpnu = 1. + nu if MODELISATION=='3D' : coefk='K1 K2 K3' ndim = 3 coefd = coefd / ( 8.0 * unmnu2 ) - coefd3 = e*sqrt(2*pi) / ( 8.0 * unpnu ) + coefd3 = e*NP.sqrt(2*pi) / ( 8.0 * unpnu ) coefg = unmnu2 / e coefg3 = unpnu / e elif MODELISATION=='AXIS' : @@ -310,10 +310,10 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, tcoorf=__NCOFON.EXTR_TABLE() DETRUIRE(CONCEPT=_F(NOM=__NCOFON),INFO=1) nbt = len(tcoorf['NOEUD'].values()['NOEUD']) - xs=array(tcoorf['COOR_X'].values()['COOR_X'][:nbt],Float) - ys=array(tcoorf['COOR_Y'].values()['COOR_Y'][:nbt],Float) - if ndim==2 : zs=Numeric.zeros(nbt,Float) - elif ndim==3 : zs=array(tcoorf['COOR_Z'].values()['COOR_Z'][:nbt],Float) + xs=NP.array(tcoorf['COOR_X'].values()['COOR_X'][:nbt]) + ys=NP.array(tcoorf['COOR_Y'].values()['COOR_Y'][:nbt]) + if ndim==2 : zs=NP.zeros(nbt) + elif ndim==3 : zs=NP.array(tcoorf['COOR_Z'].values()['COOR_Z'][:nbt]) ns = tcoorf['NOEUD'].values()['NOEUD'][:nbt] ns = map(string.rstrip,ns) l_coorf = [[ns[i],xs[i],ys[i],zs[i]] for i in range(0,nbt)] @@ -338,58 +338,58 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, xl=moy(tcoorl['COOR_X'].values()['COOR_X'][:nbt]) yl=moy(tcoorl['COOR_Y'].values()['COOR_Y'][:nbt]) zl=moy(tcoorl['COOR_Z'].values()['COOR_Z'][:nbt]) - Plev = array([xl, yl, zl]) + Plev = NP.array([xl, yl, zl]) # Calcul des normales a chaque noeud du fond - v1 = array(VECT_K1) + v1 = NP.array(VECT_K1) VN = [None]*Nbfond absfon = [0,] if MODELISATION=='3D' : DTANOR = FOND_FISS.DTAN_ORIGINE.get() - Pfon2 = array([d_coorf[LNOFO[0]][0],d_coorf[LNOFO[0]][1],d_coorf[LNOFO[0]][2]]) + Pfon2 = NP.array([d_coorf[LNOFO[0]][0],d_coorf[LNOFO[0]][1],d_coorf[LNOFO[0]][2]]) VLori = Pfon2 - Plev if DTANOR != None : - VN[0] = array(DTANOR) + VN[0] = NP.array(DTANOR) else : - Pfon3 = array([d_coorf[LNOFO[1]][0],d_coorf[LNOFO[1]][1],d_coorf[LNOFO[1]][2]]) - VT = (Pfon3 - Pfon2)/sqrt(dot(transpose(Pfon3-Pfon2),Pfon3-Pfon2)) - VN[0] = array(cross_product(VT,v1)) + Pfon3 = NP.array([d_coorf[LNOFO[1]][0],d_coorf[LNOFO[1]][1],d_coorf[LNOFO[1]][2]]) + VT = (Pfon3 - Pfon2)/NP.sqrt(NP.dot(NP.transpose(Pfon3-Pfon2),Pfon3-Pfon2)) + VN[0] = NP.array(cross_product(VT,v1)) for i in range(1,Nbfond-1): - Pfon1 = array([d_coorf[LNOFO[i-1]][0],d_coorf[LNOFO[i-1]][1],d_coorf[LNOFO[i-1]][2]]) - Pfon2 = array([d_coorf[LNOFO[i]][0],d_coorf[LNOFO[i]][1],d_coorf[LNOFO[i]][2]]) - Pfon3 = array([d_coorf[LNOFO[i+1]][0],d_coorf[LNOFO[i+1]][1],d_coorf[LNOFO[i+1]][2]]) - absf = sqrt(dot(transpose(Pfon1-Pfon2),Pfon1-Pfon2)) + absfon[i-1] + Pfon1 = NP.array([d_coorf[LNOFO[i-1]][0],d_coorf[LNOFO[i-1]][1],d_coorf[LNOFO[i-1]][2]]) + Pfon2 = NP.array([d_coorf[LNOFO[i]][0],d_coorf[LNOFO[i]][1],d_coorf[LNOFO[i]][2]]) + Pfon3 = NP.array([d_coorf[LNOFO[i+1]][0],d_coorf[LNOFO[i+1]][1],d_coorf[LNOFO[i+1]][2]]) + absf = NP.sqrt(NP.dot(NP.transpose(Pfon1-Pfon2),Pfon1-Pfon2)) + absfon[i-1] absfon.append(absf) - VT = (Pfon3 - Pfon2)/sqrt(dot(transpose(Pfon3-Pfon2),Pfon3-Pfon2)) - VT = VT+(Pfon2 - Pfon1)/sqrt(dot(transpose(Pfon2-Pfon1),Pfon2-Pfon1)) - VN[i] = array(cross_product(VT,v1)) - VN[i] = VN[i]/sqrt(dot(transpose(VN[i]),VN[i])) + VT = (Pfon3 - Pfon2)/NP.sqrt(NP.dot(NP.transpose(Pfon3-Pfon2),Pfon3-Pfon2)) + VT = VT+(Pfon2 - Pfon1)/NP.sqrt(NP.dot(NP.transpose(Pfon2-Pfon1),Pfon2-Pfon1)) + VN[i] = NP.array(cross_product(VT,v1)) + VN[i] = VN[i]/NP.sqrt(NP.dot(NP.transpose(VN[i]),VN[i])) i = Nbfond-1 - Pfon1 = array([d_coorf[LNOFO[i-1]][0],d_coorf[LNOFO[i-1]][1],d_coorf[LNOFO[i-1]][2]]) - Pfon2 = array([d_coorf[LNOFO[i]][0],d_coorf[LNOFO[i]][1],d_coorf[LNOFO[i]][2]]) + Pfon1 = NP.array([d_coorf[LNOFO[i-1]][0],d_coorf[LNOFO[i-1]][1],d_coorf[LNOFO[i-1]][2]]) + Pfon2 = NP.array([d_coorf[LNOFO[i]][0],d_coorf[LNOFO[i]][1],d_coorf[LNOFO[i]][2]]) VLextr = Pfon2 - Plev - absf = sqrt(dot(transpose(Pfon1-Pfon2),Pfon1-Pfon2)) + absfon[i-1] + absf = NP.sqrt(NP.dot(NP.transpose(Pfon1-Pfon2),Pfon1-Pfon2)) + absfon[i-1] absfon.append(absf) DTANEX = FOND_FISS.DTAN_EXTREMITE.get() if DTANEX != None : - VN[i] = array(DTANEX) + VN[i] = NP.array(DTANEX) else : - VT = (Pfon2 - Pfon1)/sqrt(dot(transpose(Pfon2-Pfon1),Pfon2-Pfon1)) - VN[i] = array(cross_product(VT,v1)) + VT = (Pfon2 - Pfon1)/NP.sqrt(NP.dot(NP.transpose(Pfon2-Pfon1),Pfon2-Pfon1)) + VN[i] = NP.array(cross_product(VT,v1)) dicoF = dict([(LNOFO[i],absfon[i]) for i in range(Nbfond)]) dicVN = dict([(LNOFO[i],VN[i]) for i in range(Nbfond)]) #Sens de la tangente v = cross_product(VLori,VLextr) - sens = sign(dot(transpose(v),v1)) + sens = NP.sign(NP.dot(NP.transpose(v),v1)) #Cas 2D if MODELISATION!='3D' : DTANOR = False DTANEX = False - VT = array([0.,0.,1.]) - VN = array(cross_product(v1,VT)) + VT = NP.array([0.,0.,1.]) + VN = NP.array(cross_product(v1,VT)) dicVN = dict([(LNOFO[0],VN)]) - Pfon = array([d_coorf[LNOFO[0]][0],d_coorf[LNOFO[0]][1],d_coorf[LNOFO[0]][2]]) + Pfon = NP.array([d_coorf[LNOFO[0]][0],d_coorf[LNOFO[0]][1],d_coorf[LNOFO[0]][2]]) VLori = Pfon - Plev - sens = sign(dot(transpose(VN),VLori)) + sens = NP.sign(NP.dot(NP.transpose(VN),VLori)) #Extraction dep sup/inf sur les normales TlibS = [None]*Nbf1 TlibI = [None]*Nbf1 @@ -402,7 +402,7 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, MODEL = self.get_concept(n_modele) dmax = PREC_VIS_A_VIS * ABSC_CURV_MAXI for i in range(Nbf1): - Porig = array(d_coorf[Lnf1[i]] ) + Porig = NP.array(d_coorf[Lnf1[i]] ) if Lnf1[i]==LNOFO[0] and DTANOR : Pextr = Porig - ABSC_CURV_MAXI*dicVN[Lnf1[i]] elif Lnf1[i]==LNOFO[Nbfond-1] and DTANEX : Pextr = Porig - ABSC_CURV_MAXI*dicVN[Lnf1[i]] else : Pextr = Porig - ABSC_CURV_MAXI*dicVN[Lnf1[i]]*sens @@ -466,10 +466,10 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, else : tcoor=TABL_DEPL_SUP.EXTR_TABLE() nbt = len(tcoor['NOEUD'].values()['NOEUD']) - xs=array(tcoor['COOR_X'].values()['COOR_X'][:nbt],Float) - ys=array(tcoor['COOR_Y'].values()['COOR_Y'][:nbt],Float) - if ndim==2 : zs=Numeric.zeros(nbt,Float) - elif ndim==3 : zs=array(tcoor['COOR_Z'].values()['COOR_Z'][:nbt],Float) + xs=NP.array(tcoor['COOR_X'].values()['COOR_X'][:nbt]) + ys=NP.array(tcoor['COOR_Y'].values()['COOR_Y'][:nbt]) + if ndim==2 : zs=NP.zeros(nbt) + elif ndim==3 : zs=NP.array(tcoor['COOR_Z'].values()['COOR_Z'][:nbt]) ns = tcoor['NOEUD'].values()['NOEUD'][:nbt] ns = map(string.rstrip,ns) l_coor = [[ns[i],xs[i],ys[i],zs[i]] for i in range(0,nbt)] @@ -479,9 +479,9 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, # ---------- Abscisse curviligne du fond ------------- absfon = [0,] for i in range(Nbfond-1) : - Pfon1 = array([d_coor[LNOFO[i]][0],d_coor[LNOFO[i]][1],d_coor[LNOFO[i]][2]]) - Pfon2 = array([d_coor[LNOFO[i+1]][0],d_coor[LNOFO[i+1]][1],d_coor[LNOFO[i+1]][2]]) - absf = sqrt(dot(transpose(Pfon1-Pfon2),Pfon1-Pfon2)) + absfon[i] + Pfon1 = NP.array([d_coor[LNOFO[i]][0],d_coor[LNOFO[i]][1],d_coor[LNOFO[i]][2]]) + Pfon2 = NP.array([d_coor[LNOFO[i+1]][0],d_coor[LNOFO[i+1]][1],d_coor[LNOFO[i+1]][2]]) + absf = NP.sqrt(NP.dot(NP.transpose(Pfon1-Pfon2),Pfon1-Pfon2)) + absfon[i] absfon.append(absf) dicoF = dict([(LNOFO[i],absfon[i]) for i in range(Nbfond)]) @@ -500,7 +500,7 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, precn = precv * rmax rmprec= rmax*(1.+precv/10.) for i in range(0,Nbf1) : - Pfon = array([d_coor[Lnf1[i]][0],d_coor[Lnf1[i]][1],d_coor[Lnf1[i]][2]]) + Pfon = NP.array([d_coor[Lnf1[i]][0],d_coor[Lnf1[i]][1],d_coor[Lnf1[i]][2]]) Tmpsup = [] Tmpinf = [] itots = 0 @@ -511,8 +511,8 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, if dicoS[Lnf1[i]][k] !='': itots = itots +1 Nsup = dicoS[Lnf1[i]][k] - Psup = array([d_coor[Nsup][0],d_coor[Nsup][1],d_coor[Nsup][2]]) - abss = sqrt(dot(transpose(Pfon-Psup),Pfon-Psup)) + Psup = NP.array([d_coor[Nsup][0],d_coor[Nsup][1],d_coor[Nsup][2]]) + abss = NP.sqrt(NP.dot(NP.transpose(Pfon-Psup),Pfon-Psup)) if abssprecn : UTMESS('A','RUPTURE0_21',valk=Lnf1[i]) else : @@ -615,115 +615,115 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, i = 0 if MODELISATION=='3D' : if DTAN_ORIG != None : - VP[0] = array(DTAN_ORIG) - VP[0] = VP[0]/sqrt(VP[0][0]**2+VP[0][1]**2+VP[0][2]**2) - VN[0] = array([Vpropa[0],Vpropa[1],Vpropa[2]]) - verif = dot(transpose(VP[0]),VN[0]) + VP[0] = NP.array(DTAN_ORIG) + VP[0] = VP[0]/NP.sqrt(VP[0][0]**2+VP[0][1]**2+VP[0][2]**2) + VN[0] = NP.array([Vpropa[0],Vpropa[1],Vpropa[2]]) + verif = NP.dot(NP.transpose(VP[0]),VN[0]) if abs(verif) > 0.01: UTMESS('A','RUPTURE1_33',valr=[VN[0][0],VN[0][1],VN[0][2]]) else : - VN[0] = array([Vpropa[0],Vpropa[1],Vpropa[2]]) - VP[0] = array([Vpropa[3+0],Vpropa[3+1],Vpropa[3+2]]) + VN[0] = NP.array([Vpropa[0],Vpropa[1],Vpropa[2]]) + VP[0] = NP.array([Vpropa[3+0],Vpropa[3+1],Vpropa[3+2]]) for i in range(1,Nbfond-1): absf = Coorfo[4*i+3] absfon.append(absf) - VN[i] = array([Vpropa[6*i],Vpropa[6*i+1],Vpropa[6*i+2]]) - VP[i] = array([Vpropa[3+6*i],Vpropa[3+6*i+1],Vpropa[3+6*i+2]]) - verif = dot(transpose(VN[i]),VN[i-1]) + VN[i] = NP.array([Vpropa[6*i],Vpropa[6*i+1],Vpropa[6*i+2]]) + VP[i] = NP.array([Vpropa[3+6*i],Vpropa[3+6*i+1],Vpropa[3+6*i+2]]) + verif = NP.dot(NP.transpose(VN[i]),VN[i-1]) if abs(verif) < 0.98: UTMESS('A','RUPTURE1_35',vali=[i-1,i]) i = Nbfond-1 absf = Coorfo[4*i+3] absfon.append(absf) if DTAN_EXTR != None : - VP[i] = array(DTAN_EXTR) - VN[i] = array([Vpropa[6*i],Vpropa[6*i+1],Vpropa[6*i+2]]) - verif = dot(transpose(VP[i]),VN[0]) + VP[i] = NP.array(DTAN_EXTR) + VN[i] = NP.array([Vpropa[6*i],Vpropa[6*i+1],Vpropa[6*i+2]]) + verif = NP.dot(NP.transpose(VP[i]),VN[0]) if abs(verif) > 0.01: UTMESS('A','RUPTURE1_34',valr=[VN[i][0],VN[i][1],VN[i][2]]) else : - VN[i] = array([Vpropa[6*i],Vpropa[6*i+1],Vpropa[6*i+2]]) - VP[i] = array([Vpropa[3+6*i],Vpropa[3+6*i+1],Vpropa[3+6*i+2]]) + VN[i] = NP.array([Vpropa[6*i],Vpropa[6*i+1],Vpropa[6*i+2]]) + VP[i] = NP.array([Vpropa[3+6*i],Vpropa[3+6*i+1],Vpropa[3+6*i+2]]) else : for i in range(0,Nbfond): - VP[i] = array([Vpropa[2+4*i],Vpropa[3+4*i],0.]) - VN[i] = array([Vpropa[0+4*i],Vpropa[1+4*i],0.]) + VP[i] = NP.array([Vpropa[2+4*i],Vpropa[3+4*i],0.]) + VN[i] = NP.array([Vpropa[0+4*i],Vpropa[1+4*i],0.]) # Cas fissure plane (VECT_K1 donne) if VECT_K1 != None : - v1 = array(VECT_K1) - v1 = v1/sqrt(v1[0]**2+v1[1]**2+v1[2]**2) - v1 = array(VECT_K1) + v1 = NP.array(VECT_K1) + v1 = v1/NP.sqrt(v1[0]**2+v1[1]**2+v1[2]**2) + v1 = NP.array(VECT_K1) i = 0 if MODELISATION=='3D' : # Sens du vecteur VECT_K1 - v1x =array([Vpropa[0],Vpropa[1],Vpropa[2]]) - verif = dot(transpose(v1),v1x) + v1x =NP.array([Vpropa[0],Vpropa[1],Vpropa[2]]) + verif = NP.dot(NP.transpose(v1),v1x) if verif < 0 : v1 = -v1 VN = [v1]*Nbfond if DTAN_ORIG != None : - VP[i] = array(DTAN_ORIG) - VP[i] = VP[i]/sqrt(VP[i][0]**2+VP[i][1]**2+VP[i][2]**2) - verif = dot(transpose(VP[i]),VN[0]) + VP[i] = NP.array(DTAN_ORIG) + VP[i] = VP[i]/NP.sqrt(VP[i][0]**2+VP[i][1]**2+VP[i][2]**2) + verif = NP.dot(NP.transpose(VP[i]),VN[0]) if abs(verif) > 0.01: UTMESS('A','RUPTURE1_36') else : - Pfon2 = array([Coorfo[4*i],Coorfo[4*i+1],Coorfo[4*i+2]]) - Pfon3 = array([Coorfo[4*(i+1)],Coorfo[4*(i+1)+1],Coorfo[4*(i+1)+2]]) - VT = (Pfon3 - Pfon2)/sqrt(dot(transpose(Pfon3-Pfon2),Pfon3-Pfon2)) - VP[0] = array(cross_product(VT,v1)) - VNi = array([Vpropa[3],Vpropa[4],Vpropa[5]]) - verif = dot(transpose(VP[i]),VNi) + Pfon2 = NP.array([Coorfo[4*i],Coorfo[4*i+1],Coorfo[4*i+2]]) + Pfon3 = NP.array([Coorfo[4*(i+1)],Coorfo[4*(i+1)+1],Coorfo[4*(i+1)+2]]) + VT = (Pfon3 - Pfon2)/NP.sqrt(NP.dot(NP.transpose(Pfon3-Pfon2),Pfon3-Pfon2)) + VP[0] = NP.array(cross_product(VT,v1)) + VNi = NP.array([Vpropa[3],Vpropa[4],Vpropa[5]]) + verif = NP.dot(NP.transpose(VP[i]),VNi) if abs(verif) < 0.99: vv =[VNi[0],VNi[1],VNi[2],VN[i][0],VN[i][1],VN[i][2],] UTMESS('A','RUPTURE0_32',vali=[i],valr=vv) for i in range(1,Nbfond-1): - Pfon1 = array([Coorfo[4*(i-1)],Coorfo[4*(i-1)+1],Coorfo[4*(i-1)+2]]) - Pfon2 = array([Coorfo[4*i],Coorfo[4*i+1],Coorfo[4*i+2]]) - Pfon3 = array([Coorfo[4*(i+1)],Coorfo[4*(i+1)+1],Coorfo[4*(i+1)+2]]) + Pfon1 = NP.array([Coorfo[4*(i-1)],Coorfo[4*(i-1)+1],Coorfo[4*(i-1)+2]]) + Pfon2 = NP.array([Coorfo[4*i],Coorfo[4*i+1],Coorfo[4*i+2]]) + Pfon3 = NP.array([Coorfo[4*(i+1)],Coorfo[4*(i+1)+1],Coorfo[4*(i+1)+2]]) absf = Coorfo[4*i+3] absfon.append(absf) - VT = (Pfon3 - Pfon2)/sqrt(dot(transpose(Pfon3-Pfon2),Pfon3-Pfon2)) - VT = VT+(Pfon2 - Pfon1)/sqrt(dot(transpose(Pfon2-Pfon1),Pfon2-Pfon1)) - VP[i] = array(cross_product(VT,v1)) - VP[i] = VP[i]/sqrt(dot(transpose(VP[i]),VP[i])) - VNi = array([Vpropa[6*i],Vpropa[6*i+1],Vpropa[6*i+2]]) - verif = dot(transpose(VN[i]),VNi) + VT = (Pfon3 - Pfon2)/NP.sqrt(NP.dot(NP.transpose(Pfon3-Pfon2),Pfon3-Pfon2)) + VT = VT+(Pfon2 - Pfon1)/NP.sqrt(NP.dot(NP.transpose(Pfon2-Pfon1),Pfon2-Pfon1)) + VP[i] = NP.array(cross_product(VT,v1)) + VP[i] = VP[i]/NP.sqrt(NP.dot(NP.transpose(VP[i]),VP[i])) + VNi = NP.array([Vpropa[6*i],Vpropa[6*i+1],Vpropa[6*i+2]]) + verif = NP.dot(NP.transpose(VN[i]),VNi) if abs(verif) < 0.99: vv =[VNi[0],VNi[1],VNi[2],VN[i][0],VN[i][1],VN[i][2],] UTMESS('A','RUPTURE0_32',vali=[i],valr=vv) i = Nbfond-1 - Pfon1 = array([Coorfo[4*(i-1)],Coorfo[4*(i-1)+1],Coorfo[4*(i-1)+2]]) - Pfon2 = array([Coorfo[4*i],Coorfo[4*i+1],Coorfo[4*i+2]]) + Pfon1 = NP.array([Coorfo[4*(i-1)],Coorfo[4*(i-1)+1],Coorfo[4*(i-1)+2]]) + Pfon2 = NP.array([Coorfo[4*i],Coorfo[4*i+1],Coorfo[4*i+2]]) absf = Coorfo[4*i+3] absfon.append(absf) if DTAN_EXTR != None : - VP[i] = array(DTAN_EXTR) - VP[i] = VP[i]/sqrt(VP[i][0]**2+VP[i][1]**2+VP[i][2]**2) - verif = dot(transpose(VP[i]),VN[i]) + VP[i] = NP.array(DTAN_EXTR) + VP[i] = VP[i]/NP.sqrt(VP[i][0]**2+VP[i][1]**2+VP[i][2]**2) + verif = NP.dot(NP.transpose(VP[i]),VN[i]) if abs(verif) > 0.01: UTMESS('A','RUPTURE1_37') else : - VT = (Pfon2 - Pfon1)/sqrt(dot(transpose(Pfon2-Pfon1),Pfon2-Pfon1)) - VP[i] = array(cross_product(VT,v1)) - VNi = array([Vpropa[6*i],Vpropa[6*i+1],Vpropa[6*i+2]]) - verif = dot(transpose(VN[i]),VNi) + VT = (Pfon2 - Pfon1)/NP.sqrt(NP.dot(NP.transpose(Pfon2-Pfon1),Pfon2-Pfon1)) + VP[i] = NP.array(cross_product(VT,v1)) + VNi = NP.array([Vpropa[6*i],Vpropa[6*i+1],Vpropa[6*i+2]]) + verif = NP.dot(NP.transpose(VN[i]),VNi) if abs(verif) < 0.99 : vv =[VNi[0],VNi[1],VNi[2],VN[i][0],VN[i][1],VN[i][2],] UTMESS('A','RUPTURE0_32',vali=[i],valr=vv) else : - VT = array([0.,0.,1.]) + VT = NP.array([0.,0.,1.]) for i in range(0,Nbfond): - VP[i] = array(cross_product(v1,VT)) + VP[i] = NP.array(cross_product(v1,VT)) VN[i] = v1 - VNi = array([Vpropa[0+4*i],Vpropa[1+4*i],0.]) - verif = dot(transpose(VN[i]),VNi) + VNi = NP.array([Vpropa[0+4*i],Vpropa[1+4*i],0.]) + verif = NP.dot(NP.transpose(VN[i]),VNi) if abs(verif) < 0.99 : vv =[VNi[0],VNi[1],VNi[2],VN[i][0],VN[i][1],VN[i][2],] UTMESS('A','RUPTURE0_32',vali=[i],valr=vv) #Sens de la tangente if MODELISATION=='3D' : i = Nbfond/2 else : i = 0 - Po = array([Coorfo[4*i],Coorfo[4*i+1],Coorfo[4*i+2]]) + Po = NP.array([Coorfo[4*i],Coorfo[4*i+1],Coorfo[4*i+2]]) Porig = Po + ABSC_CURV_MAXI*VP[i] Pextr = Po - ABSC_CURV_MAXI*VP[i] __Tabg = MACR_LIGN_COUPE(RESULTAT=__RESX,NOM_CHAM='DEPL', @@ -748,7 +748,7 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, NB_NOEUD_COUPE = 5 mcfact=[] for i in range(Nbfond): - Porig = array([Coorfo[4*i],Coorfo[4*i+1],Coorfo[4*i+2]]) + Porig = NP.array([Coorfo[4*i],Coorfo[4*i+1],Coorfo[4*i+2]]) if i==0 and DTAN_ORIG!=None : Pextr = Porig - ABSC_CURV_MAXI*VP[i] elif i==(Nbfond-1) and DTAN_EXTR!=None : Pextr = Porig - ABSC_CURV_MAXI*VP[i] else : Pextr = Porig + ABSC_CURV_MAXI*VP[i]*sens @@ -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 : @@ -947,32 +965,32 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, nbval = len(refsc) else : nbval=len(abscs) - abscs=array(abscs[:nbval]) - coxs=array(tabsupi['COOR_X'].values()['COOR_X'][:nbval],Float) - coys=array(tabsupi['COOR_Y'].values()['COOR_Y'][:nbval],Float) - if ndim==2 : cozs=Numeric.zeros(nbval,Float) - elif ndim==3 : cozs=array(tabsupi['COOR_Z'].values()['COOR_Z'][:nbval],Float) + abscs=NP.array(abscs[:nbval]) + coxs=NP.array(tabsupi['COOR_X'].values()['COOR_X'][:nbval]) + coys=NP.array(tabsupi['COOR_Y'].values()['COOR_Y'][:nbval]) + if ndim==2 : cozs=NP.zeros(nbval) + elif ndim==3 : cozs=NP.array(tabsupi['COOR_Z'].values()['COOR_Z'][:nbval]) if FOND_FISS and not RESULTAT : #tri des noeuds avec abscisse - Pfon = array([d_coor[Lnofon[ino]][0],d_coor[Lnofon[ino]][1],d_coor[Lnofon[ino]][2]]) - abscs = sqrt((coxs-Pfon[0])**2+(coys-Pfon[1])**2+(cozs-Pfon[2])**2) + Pfon = NP.array([d_coor[Lnofon[ino]][0],d_coor[Lnofon[ino]][1],d_coor[Lnofon[ino]][2]]) + abscs = NP.sqrt((coxs-Pfon[0])**2+(coys-Pfon[1])**2+(cozs-Pfon[2])**2) tabsupi['Abs_fo'] = abscs tabsupi.sort('Abs_fo') abscs = getattr(tabsupi,'Abs_fo').values() - abscs=array(abscs[:nbval]) - coxs=array(tabsupi['COOR_X'].values()['COOR_X'][:nbval],Float) - coys=array(tabsupi['COOR_Y'].values()['COOR_Y'][:nbval],Float) - if ndim==2 : cozs=Numeric.zeros(nbval,Float) - elif ndim==3 : cozs=array(tabsupi['COOR_Z'].values()['COOR_Z'][:nbval],Float) + abscs=NP.array(abscs[:nbval]) + coxs=NP.array(tabsupi['COOR_X'].values()['COOR_X'][:nbval]) + coys=NP.array(tabsupi['COOR_Y'].values()['COOR_Y'][:nbval]) + if ndim==2 : cozs=NP.zeros(nbval) + elif ndim==3 : cozs=NP.array(tabsupi['COOR_Z'].values()['COOR_Z'][:nbval]) if FOND_FISS and INFO==2 and iord==0 and not TYPE_MAILLAGE =='LIBRE': for ks in range(0,nbval) : texte="NOEUD RETENU POUR LA LEVRE SUP: %s %f"%(Lnosup[ino][ks],abscs[ks]) aster.affiche('MESSAGE',texte) - dxs=array(tabsupi['DX'].values()['DX'][:nbval],Float) - dys=array(tabsupi['DY'].values()['DY'][:nbval],Float) - if ndim==2 : dzs=Numeric.zeros(nbval,Float) - elif ndim==3 : dzs=array(tabsupi['DZ'].values()['DZ'][:nbval],Float) + dxs=NP.array(tabsupi['DX'].values()['DX'][:nbval]) + dys=NP.array(tabsupi['DY'].values()['DY'][:nbval]) + if ndim==2 : dzs=NP.zeros(nbval) + elif ndim==3 : dzs=NP.array(tabsupi['DZ'].values()['DZ'][:nbval]) # --- LEVRE INF : "ABSC_CURV" CROISSANTES et < RMAX --- if SYME_CHAR=='SANS' and not FISSURE : @@ -994,35 +1012,35 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, else: UTMESS('A','RUPTURE0_42') nbval=min(nbval,nbvali) - absci=array(absci[:nbval]) - coxi=array(tabinfi['COOR_X'].values()['COOR_X'][:nbval],Float) - coyi=array(tabinfi['COOR_Y'].values()['COOR_Y'][:nbval],Float) - if ndim==2 : cozi=Numeric.zeros(nbval,Float) - elif ndim==3 : cozi=array(tabinfi['COOR_Z'].values()['COOR_Z'][:nbval],Float) + absci=NP.array(absci[:nbval]) + coxi=NP.array(tabinfi['COOR_X'].values()['COOR_X'][:nbval]) + coyi=NP.array(tabinfi['COOR_Y'].values()['COOR_Y'][:nbval]) + if ndim==2 : cozi=NP.zeros(nbval) + elif ndim==3 : cozi=NP.array(tabinfi['COOR_Z'].values()['COOR_Z'][:nbval]) # --- ON VERIFIE QUE LES NOEUDS SONT EN VIS_A_VIS (SYME=SANS) --- if not FOND_FISS : precn = precv * rmax dist=(coxs-coxi)**2+(coys-coyi)**2+(cozs-cozi)**2 - dist=sqrt(dist) + dist=NP.sqrt(dist) for d in dist : if d>precn : UTMESS('F','RUPTURE0_44') if FOND_FISS and not RESULTAT :#tri des noeuds avec abscisse - Pfon = array([d_coor[Lnofon[ino]][0],d_coor[Lnofon[ino]][1],d_coor[Lnofon[ino]][2]]) - absci = sqrt((coxi-Pfon[0])**2+(coyi-Pfon[1])**2+(cozi-Pfon[2])**2) + Pfon = NP.array([d_coor[Lnofon[ino]][0],d_coor[Lnofon[ino]][1],d_coor[Lnofon[ino]][2]]) + absci = NP.sqrt((coxi-Pfon[0])**2+(coyi-Pfon[1])**2+(cozi-Pfon[2])**2) tabinfi['Abs_fo'] = absci tabinfi.sort('Abs_fo') absci = getattr(tabinfi,'Abs_fo').values() - absci=array(abscs[:nbval]) - coxi=array(tabinfi['COOR_X'].values()['COOR_X'][:nbval],Float) - coyi=array(tabinfi['COOR_Y'].values()['COOR_Y'][:nbval],Float) - if ndim==2 : cozi=Numeric.zeros(nbval,Float) - elif ndim==3 : cozi=array(tabinfi['COOR_Z'].values()['COOR_Z'][:nbval],Float) + absci=NP.array(abscs[:nbval]) + coxi=NP.array(tabinfi['COOR_X'].values()['COOR_X'][:nbval]) + coyi=NP.array(tabinfi['COOR_Y'].values()['COOR_Y'][:nbval]) + if ndim==2 : cozi=NP.zeros(nbval) + elif ndim==3 : cozi=NP.array(tabinfi['COOR_Z'].values()['COOR_Z'][:nbval]) - dxi=array(tabinfi['DX'].values()['DX'][:nbval],Float) - dyi=array(tabinfi['DY'].values()['DY'][:nbval],Float) - if ndim==2 : dzi=Numeric.zeros(nbval,Float) - elif ndim==3 : dzi=array(tabinfi['DZ'].values()['DZ'][:nbval],Float) + dxi=NP.array(tabinfi['DX'].values()['DX'][:nbval]) + dyi=NP.array(tabinfi['DY'].values()['DY'][:nbval]) + if ndim==2 : dzi=NP.zeros(nbval) + elif ndim==3 : dzi=NP.array(tabinfi['DZ'].values()['DZ'][:nbval]) if FOND_FISS and INFO==2 and iord==0 and not TYPE_MAILLAGE =='LIBRE': for ki in range(0,nbval) : @@ -1036,18 +1054,18 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, H1 = complete(H1) E1 = getattr(tabsupi,'E1X').values() E1 = complete(E1) - dxs = 2*(H1 + sqrt(abscs)*E1) + dxs = 2*(H1 + NP.sqrt(abscs)*E1) H1 = getattr(tabsupi,'H1Y').values() E1 = getattr(tabsupi,'E1Y').values() H1 = complete(H1) E1 = complete(E1) - dys = 2*(H1 + sqrt(abscs)*E1) + dys = 2*(H1 + NP.sqrt(abscs)*E1) H1 = getattr(tabsupi,'H1Z').values() E1 = getattr(tabsupi,'E1Z').values() H1 = complete(H1) E1 = complete(E1) - dzs = 2*(H1 + sqrt(abscs)*E1) - abscs=array(abscs[:nbval]) + dzs = 2*(H1 + NP.sqrt(abscs)*E1) + abscs=NP.array(abscs[:nbval]) # ---------- CALCUL PROP. MATERIAU AVEC TEMPERATURE ----------- if Tempe3D : @@ -1059,8 +1077,8 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, valres,codret = MATER.RCVALE('ELAS',nompar,valpar,nomres,'F') e = valres[0] nu = valres[1] - coefd = e * sqrt(2.*pi) / ( 8.0 * (1. - nu**2)) - coefd3 = e*sqrt(2*pi) / ( 8.0 * (1. + nu)) + coefd = e * NP.sqrt(2.*pi) / ( 8.0 * (1. - nu**2)) + coefd3 = e*NP.sqrt(2*pi) / ( 8.0 * (1. + nu)) coefg = (1. - nu**2) / e coefg3 = (1. + nu) / e @@ -1092,34 +1110,34 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, v2 = VP[ino] v1 = VN[ino] elif SYME_CHAR=='SANS' : - vo = array([( coxs[-1]+coxi[-1] )/2.,( coys[-1]+coyi[-1] )/2.,( cozs[-1]+cozi[-1] )/2.]) - ve = array([( coxs[0 ]+coxi[0 ] )/2.,( coys[0 ]+coyi[0 ] )/2.,( cozs[0 ]+cozi[0 ] )/2.]) + vo = NP.array([( coxs[-1]+coxi[-1] )/2.,( coys[-1]+coyi[-1] )/2.,( cozs[-1]+cozi[-1] )/2.]) + ve = NP.array([( coxs[0 ]+coxi[0 ] )/2.,( coys[0 ]+coyi[0 ] )/2.,( cozs[0 ]+cozi[0 ] )/2.]) v2 = ve-vo else : - vo = array([ coxs[-1], coys[-1], cozs[-1]]) - ve = array([ coxs[0], coys[0], cozs[0]]) + vo = NP.array([ coxs[-1], coys[-1], cozs[-1]]) + ve = NP.array([ coxs[0], coys[0], cozs[0]]) v2 = ve-vo - if not FISSURE : v1 = array(VECT_K1) - v2 = v2/sqrt(v2[0]**2+v2[1]**2+v2[2]**2) + if not FISSURE : v1 = NP.array(VECT_K1) + v2 = v2/NP.sqrt(v2[0]**2+v2[1]**2+v2[2]**2) v1p = sum(v2*v1) if SYME_CHAR=='SANS' : v1 = v1-v1p*v2 else : v2 = v2-v1p*v1 - v1 = v1/sqrt(v1[0]**2+v1[1]**2+v1[2]**2) - v2 = v2/sqrt(v2[0]**2+v2[1]**2+v2[2]**2) - v3 = array([v1[1]*v2[2]-v2[1]*v1[2],v1[2]*v2[0]-v2[2]*v1[0],v1[0]*v2[1]-v2[0]*v1[1]]) - pgl = asarray([v1,v2,v3]) - dpls = asarray([dxs,dys,dzs]) - dpls = matrixmultiply(pgl,dpls) + v1 = v1/NP.sqrt(v1[0]**2+v1[1]**2+v1[2]**2) + v2 = v2/NP.sqrt(v2[0]**2+v2[1]**2+v2[2]**2) + v3 = NP.array([v1[1]*v2[2]-v2[1]*v1[2],v1[2]*v2[0]-v2[2]*v1[0],v1[0]*v2[1]-v2[0]*v1[1]]) + pgl = NP.asarray([v1,v2,v3]) + dpls = NP.asarray([dxs,dys,dzs]) + dpls = NP.dot(pgl,dpls) if SYME_CHAR!='SANS' and abs(dpls[0][0]) > 1.e-10 : UTMESS('A','RUPTURE0_49',valk=[Lnofon[ino],SYME_CHAR]) if FISSURE : saut=dpls elif SYME_CHAR=='SANS' : - dpli = asarray([dxi,dyi,dzi]) - dpli = matrixmultiply(pgl,dpli) + dpli = NP.asarray([dxi,dyi,dzi]) + dpli = NP.dot(pgl,dpli) saut=(dpls-dpli) else : - dpli = [multiply(dpls[0],-1.),dpls[1],dpls[2]] + dpli = [NP.multiply(dpls[0],-1.),dpls[1],dpls[2]] saut=(dpls-dpli) if INFO==2 : mcfact=[] @@ -1143,14 +1161,14 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, # ------------------------------------------------------------------ # CALCUL DES K1, K2, K3 # ------------------------------------------------------------------ - isig=sign(transpose(resize(saut[:,-1],(nbval-1,3)))) - isig=sign(isig+0.001) - saut=saut*array([[coefd]*nbval,[coefd]*nbval,[coefd3]*nbval]) + isig=NP.sign(NP.transpose(NP.resize(saut[:,-1],(nbval-1,3)))) + isig=NP.sign(isig+0.001) + saut=saut*NP.array([[coefd]*nbval,[coefd]*nbval,[coefd3]*nbval]) saut=saut**2 ksig = isig[:,1] - ksig = array([ksig,ksig]) - ksig = transpose(ksig) - kgsig=resize(ksig,(1,6))[0] + ksig = NP.array([ksig,ksig]) + ksig = NP.transpose(ksig) + kgsig=NP.resize(ksig,(1,6))[0] # ------------------------------------------------------------------ # --- METHODE 1 --- # ------------------------------------------------------------------ @@ -1162,9 +1180,9 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, k = abs(y1-x1*(y2-y1)/(x2-x1)) g = coefg*(k[0]+k[1])+coefg3*k[2] kg1 = [max(k[0]),min(k[0]),max(k[1]),min(k[1]),max(k[2]),min(k[2])] - kg1 = sqrt(kg1)*kgsig - kg1=Numeric.concatenate([kg1,[max(g),min(g)]]) - vk = sqrt(k)*isig[:,:-1] + kg1 = NP.sqrt(kg1)*kgsig + kg1=NP.concatenate([kg1,[max(g),min(g)]]) + vk = NP.sqrt(k)*isig[:,:-1] if INFO==2 : mcfact=[] mcfact.append(_F(PARA='ABSC_CURV_1' ,LISTE_R=x1.tolist() )) @@ -1186,9 +1204,9 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, k = abs(y1/x1) g = coefg*(k[0]+k[1])+coefg3*k[2] kg2= [max(k[0]),min(k[0]),max(k[1]),min(k[1]),max(k[2]),min(k[2])] - kg2 = sqrt(kg2)*kgsig - kg2=Numeric.concatenate([kg2,[max(g),min(g)]]) - vk = sqrt(k)*isig + kg2 = NP.sqrt(kg2)*kgsig + kg2=NP.concatenate([kg2,[max(g),min(g)]]) + vk = NP.sqrt(k)*isig if INFO==2 : mcfact=[] mcfact.append(_F(PARA='ABSC_CURV' ,LISTE_R=x1.tolist() )) @@ -1208,12 +1226,12 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, x2 = abscs[1:nabs] y1 = saut[:,:-1] y2 = saut[:,1:nabs] - k = (sqrt(y2)*sqrt(x2)+sqrt(y1)*sqrt(x1))*(x2-x1) - k = Numeric.sum(transpose(k)) + k = (NP.sqrt(y2)*NP.sqrt(x2)+NP.sqrt(y1)*NP.sqrt(x1))*(x2-x1) + k = NP.sum(NP.transpose(k), axis=0) de = abscs[-1] vk = (k/de**2)*isig[:,0] g = coefg*(vk[0]**2+vk[1]**2)+coefg3*vk[2]**2 - kg3=Numeric.concatenate([[vk[0]]*2,[vk[1]]*2,[vk[2]]*2,[g]*2]) + kg3=NP.concatenate([[vk[0]]*2,[vk[1]]*2,[vk[2]]*2,[g]*2]) if INFO==2 : mcfact=[] mcfact.append(_F(PARA='K1' ,LISTE_R=vk[0] )) @@ -1227,8 +1245,8 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,FISSURE,MATER,RESULTAT, # ------------------------------------------------------------------ # CREATION DE LA TABLE # ------------------------------------------------------------------ - kg=array([kg1,kg2,kg3]) - kg=transpose(kg) + kg=NP.array([kg1,kg2,kg3]) + kg=NP.transpose(kg) mcfact=[] if TITRE != None : titre = TITRE diff --git a/Aster/Cata/cataSTA10/Macro/propa_fiss_ops.py b/Aster/Cata/cataSTA10/Macro/propa_fiss_ops.py index b481f307..6dbe737b 100644 --- a/Aster/Cata/cataSTA10/Macro/propa_fiss_ops.py +++ b/Aster/Cata/cataSTA10/Macro/propa_fiss_ops.py @@ -1,4 +1,4 @@ -#@ MODIF propa_fiss_ops Macro DATE 24/08/2009 AUTEUR GENIAUT S.GENIAUT +#@ MODIF propa_fiss_ops Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -18,6 +18,10 @@ # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== +from math import atan, atan2, cos, sin, sqrt + +import numpy as NP + def InterpolationLineaire(x0, points) : """ @@ -87,6 +91,26 @@ def InterpolBaseFiss(s0, Basefo, Coorfo) : return VPVNi +def dadN(C,N,M,DK,R) : +# Calcul de la vitesse de propagation + v = C/((1-R)**N)*abs(DK)**M + return v + +def betaf(k1,k2) : + if k2 == 0: + beta = 0. + else : + beta = 2*atan(0.25*(k1/k2-abs(k2)/k2*sqrt((k1/k2)**2+8))) + return beta + +#TODO prefer use numpy.cross +def cross_product(a,b): + cross = [0]*3 + cross[0] = a[1]*b[2]-a[2]*b[1] + cross[1] = a[2]*b[0]-a[0]*b[2] + cross[2] = a[0]*b[1]-a[1]*b[0] + return cross + #def propa_fiss_ops(self,METHODE_PROPA,TEST_MAIL,INFO,**args): def propa_fiss_ops(self,METHODE_PROPA,INFO,**args): """ @@ -102,9 +126,6 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args): from types import ListType, TupleType from Utilitai.Table import Table, merge from Utilitai.partition import MAIL_PY - import Numeric - from Numeric import array,asarray,Float,concatenate,sqrt,sign,resize,dot,zeros - from math import atan, atan2, cos, sin from SD.sd_mater import sd_compor1 from Cata.cata import table_sdaster,fiss_xfem,modele_sdaster @@ -117,6 +138,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' ) @@ -125,51 +147,6 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args): # La macro compte pour 1 dans la numerotation des commandes self.set_icmd(1) -#------------------------------------------------------------------ -# Loi de propagation - ##if (METHODE_PROPA != 'INITIALISATION') and (TEST_MAIL == 'NON' ) : - #if (METHODE_PROPA == 'SIMPLEXE') or (METHODE_PROPA == 'UPWIND') : - #TEST_MAIL=args['TEST_MAIL'] - #if (TEST_MAIL == 'NON' ) : - #LOI= args['LOI_PROPA'] - #if LOI == None : - #print 'MESSAGE D ERREUR : IL FAUT UNE LOI DE PROPAGATION' - #dLoi=LOI[0].cree_dict_valeurs(LOI[0].mc_liste) -## Recuperation de E et de Nu - ##fiss = args['FISSURE'] - ##self.DeclareOut('nomfiss',fiss) - #mat = dLoi['MATER'] - #matph = mat.NOMRC.get() - #phenom=None - #for cmpt in matph : - #if cmpt[:4]=='ELAS' : - #phenom=cmpt - #break - #if phenom==None : UTMESS('F','RUPTURE0_5') - #compor = sd_compor1('%-8s.%s' % (mat.nom, phenom)) - #valk = [s.strip() for s in compor.VALK.get()] - #valr = compor.VALR.get() - #dicmat=dict(zip(valk,valr)) - #if dicmat.has_key('TEMP_DEF') : - #nompar = ('TEMP',) - #valpar = (dicmat['TEMP_DEF'],) - #UTMESS('A','XFEM2_85',valr=valpar) - #nomres=['E','NU'] - #valres,codret = MATER.RCVALE('ELAS',nompar,valpar,nomres,'F') - #e = valres[0] - #nu = valres[1] - #else : - #e = dicmat['E'] - #nu = dicmat['NU'] -## Construction catalogue PROPA_XFEM - #dLoix = {} - #dLoix['LOI'] = 'PARIS' - #dLoix['E'] = e - #dLoix['NU'] = nu - #dLoix['C'] = dLoi['C'] - #dLoix['M'] = dLoi['M'] - #dLoix['N'] = dLoi['N'] - #------------------------------------------------------------------ # CAS 1 : METHODE_PROPA = 'SIMPLEXE' OU 'UPWIND' # @@ -181,10 +158,8 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args): if (TEST_MAIL == 'NON' ) : LOI= args['LOI_PROPA'] if LOI == None : - print 'MESSAGE D ERREUR : IL FAUT UNE LOI DE PROPAGATION' + UTMESS('F','RUPTURE1_50') dLoi=LOI[0].cree_dict_valeurs(LOI[0].mc_liste) - #fiss = args['FISSURE'] - #self.DeclareOut('nomfiss',fiss) mat = dLoi['MATER'] matph = mat.NOMRC.get() phenom=None @@ -223,6 +198,10 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args): mcsimp['RAYON'] = args['RAYON'] mcsimp['DA_MAX'] = args['DA_MAX'] mcsimp['TEST_MAIL']=TEST_MAIL + mcsimp['ZONE_MAJ']=args['ZONE_MAJ'] + if mcsimp['ZONE_MAJ'] == 'TORE' : + if args['RAYON_TORE']!=None : + mcsimp['RAYON_TORE']=args['RAYON_TORE'] Fissures = args['FISSURE'] # Build the list for the PROPA_XFEM operateur @@ -262,7 +241,7 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args): dcomp=COMP_LINE[0].cree_dict_valeurs(COMP_LINE[0].mc_liste) mcsimp ['COMP_LINE' ] =dcomp - if TEST_MAIL != 'CONSTANT' : + if TEST_MAIL == 'NON' : # Ok. It's time for propagation! Let's call PROPA_XFEM for each # propagating crack. for NumFiss in range(0,len(FissAct)) : @@ -327,371 +306,463 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args): #------------------------------------------------------------------ # CAS 2 : METHODE_PROPA = 'MAILLAGE' # - ALPHABET=['A','B','C','D','E','F','G','H','I','J','K','L','O','P','Q','R','S','T','U','V','W','X','Y','Z']; +# il faudrait rendre cela plus automatique pour lever la limite a 52 points + ALPHABET=['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']; +# 'AA','AB','AC','AD','AE','AF','AG','AH','AI','AJ','AK','AL','AM','AN','AO','AP','AQ','AR','AS','AT','AU','AV','AW','AX','AY','AZ']; if METHODE_PROPA == 'MAILLAGE' : - fiss = args['FISSURE1'] + Fissures = args['FISSURE'] + LOI_PROPA = args['LOI_PROPA'] - MA_XFEM1 = args['MA_XFEM1'] if LOI_PROPA != None : coef_paris = LOI_PROPA['M'] - Damax = LOI_PROPA['DA_MAX'] + coef_M = LOI_PROPA['M'] coef_C = LOI_PROPA['C'] + coef_N = LOI_PROPA['N'] + YOUNG = 2.E11 it = args['ITERATION'] - typmod= MA_XFEM1.DIME.get() - typmod = typmod[5] + Damax = args['DA_MAX'] + COMP_LINE = args['COMP_LINE'] + + Nbfissure=len(Fissures) + mm = [None]*Nbfissure + __MMX = [None]*Nbfissure + BETA = [None]*Nbfissure + DKeq = [None]*Nbfissure + R = [None]*Nbfissure + RmM = [None]*Nbfissure + VMAX = 0. + + numfis=0 + print '-------------------------------------------' + print 'NOMBRE DE FISSURES A TRAITER : ',Nbfissure + for Fiss in Fissures : + print 'FISSURE ',numfis+1,' : ',Fiss['FISS_ACTUELLE'].get_name() + numfis=numfis+1 + print '-------------------------------------------' + + numfis=0 + DKmax = 0 +# PREMIERE BOUCLE SUR LES FISSURES : DK, DKmax + for Fiss in Fissures : + fiss0 = Fiss['FISS_ACTUELLE'] + MAIL_FISS1 = Fiss['MAIL_ACTUEL'] + dime= MAIL_FISS1.DIME.get() + dime = dime[5] # Verification qu on a bien un fond unique - Fissmult = fiss.FONDMULT.get() - Nbfiss = len(Fissmult)/2 - if Nbfiss >1 : - UTMESS('F','RUPTURE1_48',vali=Nbfiss) + Fissmult = fiss0.FONDMULT.get() + Nbfiss = len(Fissmult)/2 + if Nbfiss >1 : + UTMESS('F','RUPTURE1_48',vali=Nbfiss) # Recuperation des K et calcul de DeltaK - Nmeth = args['METHODE_POSTK'] - SIF = args['TABLE'] - hypo = args['HYPOTHESE'] - nbinst = 1 + Nmeth = Fiss['METHODE_POSTK'] + SIF = Fiss['TABLE'] + nbinst = 1 # A- TABLEAU ISSSU DE POST_K1_K2_K3 - if (Nmeth != None) : - __TABN = CALC_TABLE(TABLE=SIF,ACTION=_F(OPERATION='FILTRE', + if (Nmeth != None) : + __TABN = CALC_TABLE(TABLE=SIF,ACTION=_F(OPERATION='FILTRE', NOM_PARA='METHODE',VALE_I=Nmeth),); - __tabp = __TABN.EXTR_TABLE() - if ('K1_MAX' not in __tabp.para) or ('G_MAX' not in __tabp.para): - UTMESS('F','RUPTURE1_44') - __tab1 = __tabp.values() - if 'INST' in __tabp.para : - l_inst_tab=__tabp['INST'].values()['INST'] - l_inst_tab=dict([(i,0) for i in l_inst_tab]).keys() - nbinst = len(l_inst_tab) - if nbinst > 1 : - nbfis = len(__tab1['K1_MAX']) / nbinst - DK1 = [None]*nbfis - DKmax = 0. - for k in range(nbfis) : - DK1[k]=[0.]*2 - __tmp = __tabp.PT_FOND==(k+1) - if (typmod == 3) : DK1[k][0]=__tmp.values()['ABSC_CURV'][0] - DK1[k][1]=max(__tmp.values()['K1_MAX'])-min(__tmp.values()['K1_MAX']) - DKmax = max(DKmax,DK1[k][1]) - else : - nbfis = len(__tab1['K1_MAX']) - if hypo == 'NON_PLAN' : - BETA = [None]*nbfis - if (min(__tab1['G_MAX']) < 0.) : - UTMESS('F','RUPTURE1_46') - DKmax = max(sqrt(__tab1['G_MAX'])) - BETA = [0.]*nbfis - absc = [0.]*nbfis - for i in range(nbfis) : - k1 = __tab1['K1_MAX'][i] - k2 = __tab1['K2_MAX'][i] - if (typmod == 3) : absc[i]=__tab1['ABSC_CURV'][i] - BETA[i] = [absc[i] , 2*atan(0.25*(k1/k2-abs(k2)/k2*sqrt((k1/k2)**2+8)))] - DK1 = [[absc[i],sqrt(__tab1['G_MAX'][i])] for i in range(nbfis)] - else : - DKmax = max(__tab1['K1_MAX']) - if (typmod == 3) : - DK1 = [[__tab1['ABSC_CURV'][i],__tab1['K1_MAX'][i]] for i in range(nbfis)] - else : - DK1 = [[0.,__tab1['K1_MAX'][i]] for i in range(nbfis)] - if (min(__tab1['K1_MAX']) < 0.) : - UTMESS('F','RUPTURE1_49') + __tabp = __TABN.EXTR_TABLE() + if ('K1_MAX' not in __tabp.para) or ('G_MAX' not in __tabp.para): + UTMESS('F','RUPTURE1_44') + __tab1 = __tabp.values() + nbinst = 1 + if 'INST' in __tabp.para : + l_inst_tab=__tabp['INST'].values()['INST'] + l_inst_tab=dict([(i,0) for i in l_inst_tab]).keys() + nbinst = len(l_inst_tab) + nbptfon = len(__tab1['K1_MAX']) / nbinst + R[numfis] = [None]*nbptfon + RmM[numfis] = [None]*nbptfon + DKeq[numfis] = [None]*nbptfon + BETA[numfis] = [None]*nbptfon + absc = [0.]*nbptfon + if nbinst > 1 : + for k in range(nbptfon) : + if (dime == 2) : __tmp = __tabp + if (dime == 3) : __tmp = __tabp.PT_FOND==(k+1) + if (dime == 3) : absc[k]=__tmp['ABSC_CURV'][k] + ddkeq = sqrt(YOUNG)*(sqrt(max(__tmp.values()['G_MAX'])) + - sqrt(min(__tmp.values()['G_MAX']))) + rminmax = sqrt(min(__tmp.values()['G_MAX'])) / sqrt(max(__tmp.values()['G_MAX'])) + DKeq[numfis][k] = [absc[k], ddkeq ] + RmM[numfis][k] = [absc[k], rminmax ] + k1 = __tmp.values()['K1_MAX'] + k2 = __tmp.values()['K2_MAX'] + betat = [0.]*nbinst + for jt in range(nbinst) : + betat[jt] = betaf(k1[jt],k2[jt]) +# ANGLE BETA NE DOIT PAS TROP VARIER ENTRE LES PAS DE TEMPS + dbeta = max(betat) - min(betat) + if dbeta > (5./180.*3.1415) : + UTMESS('F','XFEM2_72') + BETA[numfis][k] = [absc[k], betat[0] ] + VMAX0 = dadN(coef_C,coef_N,coef_M,DKeq[numfis][k][1],RmM[numfis][k][1]) + VMAX = max(VMAX,VMAX0 ) + else : + if COMP_LINE == None : + UTMESS('A','XFEM2_76') + CMIN = 0. + CMAX = 1. + else : + CMIN = COMP_LINE['COEF_MULT_MINI'] + CMAX = COMP_LINE['COEF_MULT_MAXI'] + if (min(__tab1['G_MAX']) < 0.) : + UTMESS('F','RUPTURE1_46') + DKmax0 = max(NP.sqrt(__tab1['G_MAX'])) + DKmax = max(DKmax,DKmax0) + for k in range(nbptfon) : + k1 = __tab1['K1_MAX'][k] + k2 = __tab1['K2_MAX'][k] + if (dime == 3) : absc[k]=__tab1['ABSC_CURV'][k] + BETA[numfis][k] = [absc[k] , betaf(k1,k2)] + DKeq[numfis][k] = [absc[k],sqrt(YOUNG)*NP.sqrt(__tab1['G_MAX'][k])] + RmM[numfis][k] = [absc[k], CMIN/CMAX] + VMAX0 = dadN(coef_C,coef_N,coef_M,DKeq[numfis][k][1],RmM[numfis][k][1]) + VMAX = max(VMAX,VMAX0 ) # B- TABLEAU ISSSU DE CALC_G (option CALC_K_G) - else : - __tabp = SIF.EXTR_TABLE() - if (typmod == 3) and (('K1_LOCAL' not in __tabp.para) or ('G_LOCAL' not in __tabp.para) or ('BETA_LOCAL' not in __tabp.para)): - UTMESS('F','RUPTURE1_45') - if (typmod == 2) and (('K1' not in __tabp.para) or ('G' not in __tabp.para)) : - UTMESS('F','RUPTURE1_45') - __tab1= __tabp.values() - if 'INST' in __tabp.para : - l_inst_tab=__tabp['INST'].values()['INST'] - l_inst_tab=dict([(i,0) for i in l_inst_tab]).keys() - nbinst = len(l_inst_tab) - if nbinst > 1 : - nbfiss = 1 - if (typmod == 3) : nbfis = len(__tab1['K1_LOCAL']) / nbinst - DK1 = [None]*nbfis - DKmax = 0. - for k in range(nbfis) : - DK1[k]=[None]*2 - __tmp = __tabp.NUM_PT==(k+1) - if (typmod == 3) : - DK1[k][0]=__tmp.values()['ABSC_CURV'][0] - DK1[k][1]=max(__tmp.values()['K1_LOCAL'])-min(__tmp.values()['K1_LOCAL']) - else : - DK1[k][0]=0. - DK1[k][1]=max(__tmp.values()['K1'])-min(__tmp.values()['K1']) - DKmax = max(DKmax,DK1[k][1]) - elif typmod == 3 : - nbfis = len(__tab1['K1_LOCAL']) - if hypo == 'NON_PLAN' : - if (min(__tab1['G_LOCAL']) < 0.) : - UTMESS('F','RUPTURE1_46') - DKmax = max(sqrt(__tab1['G_LOCAL'])) - DK1 = [[__tab1['ABSC_CURV'][i],sqrt(__tab1['G_LOCAL'][i])] for i in range(nbfis)] - BETA = [[__tab1['ABSC_CURV'][i],__tab1['BETA_LOCAL'][i]] for i in range(nbfis)] - else : - DKmax = max(__tab1['K1_LOCAL']) - DK1 = [[__tab1['ABSC_CURV'][i],__tab1['K1_LOCAL'][i]] for i in range(nbfis)] - if (min(__tab1['K1_LOCAL']) < 0.) : - UTMESS('F','RUPTURE1_49') - else : - nbfis = 1 - if hypo == 'NON_PLAN' : - if (min(__tab1['G']) < 0.) : - UTMESS('F','RUPTURE1_46') - DKmax = max(sqrt(__tab1['G'])) - DK1 = [[0.,DKmax],] - k1 = __tab1['K1'][0] - k2 = __tab1['K2'][0] - beta = 2*atan(0.25*(k1/k2-abs(k2)/k2*sqrt((k1/k2)**2+8))) - BETA = [[0.,beta] ] - else : - DKmax = max(__tab1['K1']) - DK1 = [[0.,DKmax ] ,] - if (min(__tab1['K1']) < 0.) : - UTMESS('F','RUPTURE1_49') - - if hypo == 'NON_PLAN' and nbinst > 1 : - UTMESS('F','RUPTURE1_47') - + else : + __tabp = SIF.EXTR_TABLE() + if (dime == 3) and (('K1_LOCAL' not in __tabp.para) or ('G_LOCAL' not in __tabp.para) or ('BETA_LOCAL' not in __tabp.para)): + UTMESS('F','RUPTURE1_45') + if (dime == 2) and (('K1' not in __tabp.para) or ('G' not in __tabp.para)) : + UTMESS('F','RUPTURE1_45') + __tab1= __tabp.values() + if 'INST' in __tabp.para : + l_inst_tab=__tabp['INST'].values()['INST'] + l_inst_tab=dict([(i,0) for i in l_inst_tab]).keys() + nbinst = len(l_inst_tab) + if (dime == 2) : nbptfon = 1 + if (dime == 3) : nbptfon = len(__tab1['G_LOCAL']) / nbinst + RmM[numfis] = [None]*nbptfon + DKeq[numfis] = [None]*nbptfon + BETA[numfis] = [None]*nbptfon + if nbinst > 1 : + for k in range(nbptfon) : + if (dime == 3) : + __tmp = __tabp.NUM_PT==(k+1) + if (min(__tmp['G_LOCAL']) < 0.) : + UTMESS('F','RUPTURE1_46') + absc = __tmp.values()['ABSC_CURV'][0] + DKeq[numfis][k]=[absc, sqrt(YOUNG)*(sqrt(max(__tmp.values()['G_LOCAL']))-sqrt(min(__tmp.values()['G_LOCAL'])))] + RmM[numfis][k] = [absc, sqrt(min(__tmp.values()['G_LOCAL'])) / sqrt(max(__tmp.values()['G_LOCAL']))] + dbeta = max(__tmp.values()['BETA_LOCAL'])-min(__tmp.values()['BETA_LOCAL']) + if dbeta > (5./180.*3.1415) : + UTMESS('F','XFEM2_72') + BETA[numfis][k] = [absc, __tmp.values()['BETA_LOCAL'][0] ] + else : + if (min(__tabp.values()['G']) < 0.) : + UTMESS('F','RUPTURE1_46') + DKeq[numfis][k]=[0.,sqrt(YOUNG)*(sqrt(max(__tabp.values()['G']))-sqrt(min(__tabp.values()['G'])))] + RmM[numfis][k] = [0., sqrt(min(__tabp.values()['G'])) / sqrt(max(__tabp.values()['G'])) ] + k1 = __tabp.values()['K1'][0] + k2 = __tabp.values()['K2'][0] + BETA[numfis][k]=[0., betaf(k1,k2)] + VMAX0 = dadN(coef_C,coef_N,coef_M,DKeq[numfis][k][1],RmM[numfis][k][1]) + VMAX = max(VMAX,VMAX0 ) + elif dime == 3 : + nbptfon = len(__tab1['G_LOCAL']) + if COMP_LINE == None : + UTMESS('A','XFEM2_76') + CMIN = 0. + CMAX = 1. + else : + CMIN = COMP_LINE['COEF_MULT_MINI'] + CMAX = COMP_LINE['COEF_MULT_MAXI'] + if (min(__tab1['G_LOCAL']) < 0.) : + UTMESS('F','RUPTURE1_46') + DKeq[numfis] = [[__tab1['ABSC_CURV'][i],NP.sqrt(__tab1['G_LOCAL'][i])*sqrt(YOUNG) ] for i in range(nbptfon)] + RmM[numfis] = [[__tab1['ABSC_CURV'][i], CMIN/CMAX] for i in range(nbptfon)] + BETA[numfis] = [[__tab1['ABSC_CURV'][i],__tab1['BETA_LOCAL'][i]] for i in range(nbptfon)] + for i in range(nbptfon) : + VMAX0 = dadN(coef_C,coef_N,coef_M,DKeq[numfis][i][1],RmM[numfis][i][1]) + VMAX = max(VMAX,VMAX0 ) + else : + nbptfon = 1 + if COMP_LINE == None : + UTMESS('A','XFEM2_76') + CMIN = 0. + CMAX = 1. + else : + CMIN = COMP_LINE['COEF_MULT_MINI'] + CMAX = COMP_LINE['COEF_MULT_MAXI'] + if (min(__tab1['G']) < 0.) : + UTMESS('F','RUPTURE1_46') + DKeq[numfis][0] = [0.,sqrt(YOUNG)*max(NP.sqrt(__tab1['G']))] + k1 = __tab1['K1'][0] + k2 = __tab1['K2'][0] + BETA[numfis][0] = [0.,betaf(k1,k2)] + RmM[numfis][0] = [0.,CMIN/CMAX] + VMAX0 = dadN(coef_C,coef_N,coef_M,DKeq[numfis][0][1],RmM[numfis][0][1]) + VMAX = max(VMAX,VMAX0 ) + + numfis = numfis + 1 + +# CALCUL DU NOMBRE DE CYCLES EQUIVALENTS + NBCYCL = Damax / VMAX + print 'AVANCE MAXIMALE DU FOND DE FISSURE',Damax + print 'NOMBRE DE CYCLES DE FATIGUE',NBCYCL + +# DEUXIEME BOUCLE SUR LES FISSURES : PROPAGATION + numfis = 0 + for Fiss in Fissures : + fiss0 = Fiss['FISS_ACTUELLE'] + print '-------------------------------------------' + print 'TRAITEMENT DE LA FISSURE ',fiss0.get_name() + print '-------------------------------------------' + MAIL_FISS1 = Fiss['MAIL_ACTUEL'] + MFOND = Fiss['GROUP_MA_FOND'] + MFISS = Fiss['GROUP_MA_FISS'] + #------------------------------------------------------------------ # CAS 2a : MODELE 3D # - if typmod == 3 : - mm = MAIL_PY() - mm.FromAster(MA_XFEM1) - + if dime == 3 : + mm[numfis] = MAIL_PY() + mm[numfis].FromAster(MAIL_FISS1) + # Recuperation des informations sur le maillage - nbno = mm.dime_maillage[0] - nbma = mm.dime_maillage[2] - collgrma = mm.gma - nbnofo = len(collgrma['FOND_0'])+1 - + nbno = mm[numfis].dime_maillage[0] + nbma = mm[numfis].dime_maillage[2] + collgrma = mm[numfis].gma + gmafon = MFOND+str('_')+str(it-1) + +# Recuperation de la liste des noeuds du fond + connex = mm[numfis].co + linomma = list(mm[numfis].correspondance_mailles) + groupma = mm[numfis].gma + lmafo = groupma[gmafon] + lisnofo = [] + for i in range(len(lmafo)) : + ma_i = linomma[lmafo[i]] + no_i = connex[lmafo[i]] + if i == 0 : + lisnofo.append(no_i[0]) + lisnofo.append(no_i[1]) + else : + if lisnofo[i] != no_i[0] : + UTMESS('F','RUPTURE1_51') + lisnofo.append(no_i[1]) + + nbnofo = len(lisnofo) + # Correction de la position des noeuds (equirepartition) - Coorfo = fiss.FONDFISS.get() - absmax = Coorfo[-1] - abscf = [0.]*nbnofo - for i in range(nbnofo) : - abscf[i] = i * absmax / (nbnofo-1) - xyzi = InterpolFondFiss(abscf[i], Coorfo) - mm.cn[nbno-nbnofo+i][0] = xyzi[0] - mm.cn[nbno-nbnofo+i][1] = xyzi[1] - mm.cn[nbno-nbnofo+i][2] = xyzi[2] - + Coorfo = fiss0.FONDFISS.get() + absmax = Coorfo[-1] + abscf = [0.]*nbnofo + for i in range(nbnofo) : + abscf[i] = i * absmax / (nbnofo-1) + xyzi = InterpolFondFiss(abscf[i], Coorfo) + mm[numfis].cn[nbno-nbnofo+i][0] = xyzi[0] + mm[numfis].cn[nbno-nbnofo+i][1] = xyzi[1] + mm[numfis].cn[nbno-nbnofo+i][2] = xyzi[2] + # Maillage apres correction - coord = mm.cn - linomno = list(mm.correspondance_noeuds) - linomno = map(string.rstrip,linomno) - l_coorf = [[linomno[i],coord[i]] for i in range(0,nbno)] - d_coorf = dict(l_coorf) + coord = mm[numfis].cn + linomno = list(mm[numfis].correspondance_noeuds) + linomno = map(string.rstrip,linomno) + l_coorf = [[linomno[i],coord[i]] for i in range(0,nbno)] + d_coorf = dict(l_coorf) # Boucle sur le fond : coordonnees du point propage - Basefo = fiss.BASEFOND.get() - Listfo = fiss.FONDFISS.get() - Vorig = args['DTAN_ORIG'] - Vextr = args['DTAN_EXTR'] - if (Damax ==None) : - DKmax = 1 - if (coef_C ==None) : - coef_C = Damax - for ifond in range(nbnofo) : - Xf = d_coorf['NX%s%i' %(ALPHABET[ifond],it)][0] - Yf = d_coorf['NX%s%i' %(ALPHABET[ifond],it)][1] - Zf = d_coorf['NX%s%i' %(ALPHABET[ifond],it)][2] - - VPVNi = InterpolBaseFiss(abscf[ifond],Basefo, Listfo) - - k1 = InterpolationLineaire(abscf[ifond], DK1) - if k1<=0 : - UTMESS('F','RUPTURE1_49') - -# Correction pour reduire le risque de maille aplatie (pilotage par Damax uniquement) - if (Damax !=None) : - Damin = Damax /10. - if ((k1/DKmax)**coef_paris <= Damin ) : - k1 = Damin**(1/coef_paris)*DKmax - + Basefo = fiss0.BASEFOND.get() + Listfo = fiss0.FONDFISS.get() + Vorig = Fiss['DTAN_ORIG'] + Vextr = Fiss['DTAN_EXTR'] + if (Damax ==None) : + DKmax = 1 + if (coef_C ==None) : + coef_C = Damax + for ifond in range(nbnofo) : + Xf = d_coorf['NX%s%i' %(ALPHABET[ifond],it)][0] + Yf = d_coorf['NX%s%i' %(ALPHABET[ifond],it)][1] + Zf = d_coorf['NX%s%i' %(ALPHABET[ifond],it)][2] + + VPVNi = InterpolBaseFiss(abscf[ifond],Basefo, Listfo) + DKeqloc = InterpolationLineaire(abscf[ifond], DKeq[numfis]) + Rloc = InterpolationLineaire(abscf[ifond], RmM[numfis]) + if DKeqloc<=0 : + UTMESS('F','RUPTURE1_49') + # Tangentes aux extremites - if (ifond == 0) and (Vorig != None) : - VPVNi[3] = Vorig[0] - VPVNi[4] = Vorig[1] - VPVNi[5] = Vorig[2] - if (ifond == nbnofo-1) and (Vextr != None) : - VPVNi[3] = Vextr[0] - VPVNi[4] = Vextr[1] - VPVNi[5] = Vextr[2] - - if hypo == 'NON_PLAN' : - beta = InterpolationLineaire(abscf[ifond], BETA) - Xf2 = Xf + coef_C*(VPVNi[3]*cos(beta)+VPVNi[0]*sin(beta))*(k1/DKmax)**coef_paris - Yf2 = Yf + coef_C*(VPVNi[4]*cos(beta)+VPVNi[1]*sin(beta))*(k1/DKmax)**coef_paris - Zf2 = Zf + coef_C*(VPVNi[5]*cos(beta)+VPVNi[2]*sin(beta))*(k1/DKmax)**coef_paris - else : - Xf2 = Xf + coef_C*VPVNi[3]*(k1/DKmax)**coef_paris - Yf2 = Yf + coef_C*VPVNi[4]*(k1/DKmax)**coef_paris - Zf2 = Zf + coef_C*VPVNi[5]*(k1/DKmax)**coef_paris - - LesNoeudsEnPlus = array([[Xf2,Yf2,Zf2]]) - if ifond ==0 : - Pini = (Xf2,Yf2,Zf2) - vectorie = (VPVNi[0],VPVNi[1],VPVNi[2],) - NomNoeudsEnPlus = ['NX%s%i' %(ALPHABET[ifond],it+1)] - mm.cn = concatenate((mm.cn,LesNoeudsEnPlus)) - mm.correspondance_noeuds = tuple( list(mm.correspondance_noeuds) + NomNoeudsEnPlus ) + if (ifond == 0) and (Vorig != None) : + VPVNi[3] = Vorig[0] + VPVNi[4] = Vorig[1] + VPVNi[5] = Vorig[2] + if (ifond == nbnofo-1) and (Vextr != None) : + VPVNi[3] = Vextr[0] + VPVNi[4] = Vextr[1] + VPVNi[5] = Vextr[2] + + beta = InterpolationLineaire(abscf[ifond], BETA[numfis]) + Vloc = NBCYCL*dadN(coef_C,coef_N,coef_M,DKeqloc,Rloc) + Xf2 = Xf + (VPVNi[3]*cos(beta)+VPVNi[0]*sin(beta))*Vloc + Yf2 = Yf + (VPVNi[4]*cos(beta)+VPVNi[1]*sin(beta))*Vloc + Zf2 = Zf + (VPVNi[5]*cos(beta)+VPVNi[2]*sin(beta))*Vloc + + LesNoeudsEnPlus = NP.array([[Xf2,Yf2,Zf2]]) + if ifond ==0 : + Pini = (Xf2,Yf2,Zf2) + vectorie = (VPVNi[0],VPVNi[1],VPVNi[2],) + NomNoeudsEnPlus = ['NX%s%i' %(ALPHABET[ifond],it+1)] + mm[numfis].cn = NP.concatenate((mm[numfis].cn,LesNoeudsEnPlus)) + mm[numfis].correspondance_noeuds = tuple( list(mm[numfis].correspondance_noeuds) + NomNoeudsEnPlus ) + + # Ajout Maille levre (quad4) + nbnotot = len(mm[numfis].correspondance_noeuds) + NomMaillesEnPlus = [] + num_maille = [] + NoeudsMailles = [] + for ifond in range(nbnofo-1) : + NomMaillesEnPlus.append( 'MX%s%i' %(ALPHABET[ifond], it+1) ) + num_maille.append( [ nbma + ifond +1 ] ) + num_maille.append( nbma +ifond + 1 ) + i1 = nbnotot - 2*nbnofo + ifond + i2 = nbnotot - 2*nbnofo + ifond +1 + i3 = nbnotot - nbnofo + ifond +1 + i4 = nbnotot - nbnofo + ifond + NoeudsMailles.append( NP.array([i1,i2,i3,i4])) -# Ajout Maille levre (quad4) - nbnotot = len(mm.correspondance_noeuds) - NomMaillesEnPlus = [] - num_maille = [] - NoeudsMailles = [] - for ifond in range(nbnofo-1) : - NomMaillesEnPlus.append( 'MX%s%i' %(ALPHABET[ifond], it+1) ) - num_maille.append( [ nbma + ifond +1 ] ) - num_maille.append( nbma +ifond + 1 ) - i1 = nbnotot - 2*nbnofo + ifond - i2 = nbnotot - 2*nbnofo + ifond +1 - i3 = nbnotot - nbnofo + ifond +1 - i4 = nbnotot - nbnofo + ifond - NoeudsMailles.append( array([i1,i2,i3,i4])) - - typ_maille = mm.dic['QUAD4'] - NbMailleAjoute = nbnofo-1 - mm.tm = concatenate((mm.tm,array([typ_maille]*NbMailleAjoute))) - mm.correspondance_mailles += tuple(NomMaillesEnPlus) - mm.co += NoeudsMailles - fsi = mm.gma['FISS_%i' %(it-1)] - for ifond in range(nbnofo-1) : - fsi = concatenate((fsi,array([nbma+ifond]))) - mm.gma['FISS_%i' %it] = fsi - + typ_maille = mm[numfis].dic['QUAD4'] + NbMailleAjoute = nbnofo-1 + mm[numfis].tm = NP.concatenate((mm[numfis].tm,NP.array([typ_maille]*NbMailleAjoute))) + mm[numfis].correspondance_mailles += tuple(NomMaillesEnPlus) + mm[numfis].co += NoeudsMailles + #XXX utilise resize/arange... (MC) + fsi = mm[numfis].gma['%s_%i' %(MFISS,it-1)] + for ifond in range(nbnofo-1) : + fsi = NP.concatenate((fsi,NP.array([nbma+ifond]))) + mm[numfis].gma['%s_%i' %(MFISS,it)] = fsi.astype(int) + # Ajout Maille fond (SEG2) - NomMaillesEnPlus = [] - num_maille = [] - NoeudsMailles = [] - for ifond in range(nbnofo-1) : - NomMaillesEnPlus.append( 'MF%s%i' %(ALPHABET[ifond], it+1) ) - num_maille.append( [ nbma + ifond +nbnofo ] ) - num_maille.append( nbma + ifond + nbnofo ) - i3 = nbnotot - nbnofo + ifond - i4 = nbnotot - nbnofo + ifond +1 - NoeudsMailles.append( array([i3,i4])) - - typ_maille = mm.dic['SEG2'] - NbMailleAjoute = nbnofo-1 - mm.tm = concatenate((mm.tm,array([typ_maille]*NbMailleAjoute))) - mm.correspondance_mailles += tuple(NomMaillesEnPlus) - mm.co += NoeudsMailles - fsi = [] - for ifond in range(nbnofo-1) : - fsi = concatenate((fsi,array([nbma+ifond+nbnofo-1]))) - mm.gma['FOND_%i' %it] = fsi - + NomMaillesEnPlus = [] + num_maille = [] + NoeudsMailles = [] + for ifond in range(nbnofo-1) : + NomMaillesEnPlus.append( 'MF%s%i' %(ALPHABET[ifond], it+1) ) + num_maille.append( [ nbma + ifond +nbnofo ] ) + num_maille.append( nbma + ifond + nbnofo ) + i3 = nbnotot - nbnofo + ifond + i4 = nbnotot - nbnofo + ifond +1 + NoeudsMailles.append( NP.array([i3,i4])) + + typ_maille = mm[numfis].dic['SEG2'] + NbMailleAjoute = nbnofo-1 + mm[numfis].tm = NP.concatenate((mm[numfis].tm,NP.array([typ_maille]*NbMailleAjoute))) + mm[numfis].correspondance_mailles += tuple(NomMaillesEnPlus) + mm[numfis].co += NoeudsMailles + mm[numfis].gma['%s_%i' %(MFOND,it)] = NP.arange(nbma+nbnofo-1, nbma+2*(nbnofo-1)) + #------------------------------------------------------------------ # CAS 2b : MODELE 2D # - if typmod == 2 : - mm = MAIL_PY() - mm.FromAster(MA_XFEM1) - - (nno,ndim) = mm.cn.shape - -# Recuperation des informations sur le maillage - nbno = mm.dime_maillage[0] - nbma = mm.dime_maillage[2] - coord = mm.cn - linomno = list(mm.correspondance_noeuds) - linomno = map(string.rstrip,linomno) - l_coorf = [[linomno[i],coord[i]] for i in range(0,nbno)] - d_coorf = dict(l_coorf) - -# Coordonnees du point propage - Xf = d_coorf['NXA%i' %(it)][0] - Yf = d_coorf['NXA%i' %(it)][1] - if (Damax ==None) : - DKmax = 1 - if (coef_C ==None) : - coef_C = Damax - - VPVNi = fiss.BASEFOND.get() - k1 = DK1[0][1] - if hypo == 'NON_PLAN' : - beta = BETA[0][1] - Xf2 = Xf + coef_C*(VPVNi[2]*cos(beta)+VPVNi[0]*sin(beta))*(k1/DKmax)**coef_paris - Yf2 = Yf + coef_C*(VPVNi[3]*cos(beta)+VPVNi[1]*sin(beta))*(k1/DKmax)**coef_paris - else : - Xf2 = Xf + coef_C*VPVNi[2]*(k1/DKmax)**coef_paris - Yf2 = Yf + coef_C*VPVNi[3]*(k1/DKmax)**coef_paris - - LesNoeudsEnPlus = array([[Xf2,Yf2]]) - NomNoeudsEnPlus = ['NXA%i' %(it+1)] - mm.cn = concatenate((mm.cn,LesNoeudsEnPlus)) - mm.correspondance_noeuds = tuple(linomno + NomNoeudsEnPlus ) - -# Ajout Maille levre (SEG2) - NomMaillesEnPlus = ['MX%s%i' %(ALPHABET[0], it+1)] - num_maille = [ nbma + 1 ] - num_maille.append( nbma + 1 ) - NoeudsMailles = [array([nbno-1,nbno])] - typ_maille = mm.dic['SEG2'] - NbMailleAjoute = 1 - mm.tm = concatenate((mm.tm,array([typ_maille]*NbMailleAjoute))) - mm.correspondance_mailles += tuple(NomMaillesEnPlus) - mm.co += NoeudsMailles - fsi = mm.gma['FISS_%i' %(it-1)] - fsi = concatenate((fsi,array([nbma]))) - mm.gma['FISS_%i' %it] = fsi - + if dime == 2 : + mm[numfis] = MAIL_PY() + mm[numfis].FromAster(MAIL_FISS1) + + (nno,ndim) = mm[numfis].cn.shape + + # Recuperation des informations sur le maillage + nbno = mm[numfis].dime_maillage[0] + nbma = mm[numfis].dime_maillage[2] + coord = mm[numfis].cn + linomno = list(mm[numfis].correspondance_noeuds) + linomno = map(string.rstrip,linomno) + l_coorf = [[linomno[i],coord[i]] for i in range(0,nbno)] + d_coorf = dict(l_coorf) + + # Coordonnees du point propage + Xf = d_coorf['NXA%i' %(it)][0] + Yf = d_coorf['NXA%i' %(it)][1] + + VPVNi = fiss0.BASEFOND.get() + V = NBCYCL*dadN(coef_C,coef_N,coef_M,DKeq[numfis][0][1],RmM[numfis][0][1]) + beta = BETA[numfis][0][1] + Xf2 = Xf +V*(VPVNi[2]*cos(beta)+VPVNi[0]*sin(beta)) + Yf2 = Yf + V*(VPVNi[3]*cos(beta)+VPVNi[1]*sin(beta)) + + LesNoeudsEnPlus = NP.array([[Xf2,Yf2]]) + NomNoeudsEnPlus = ['NXA%i' %(it+1)] + mm[numfis].cn = NP.concatenate((mm[numfis].cn,LesNoeudsEnPlus)) + mm[numfis].correspondance_noeuds = tuple(linomno + NomNoeudsEnPlus ) + + # Ajout Maille levre (SEG2) + NomMaillesEnPlus = ['MX%s%i' %(ALPHABET[0], it+1)] + num_maille = [ nbma + 1 ] + num_maille.append( nbma + 1 ) + NoeudsMailles = [NP.array([nbno-1,nbno])] + typ_maille = mm[numfis].dic['SEG2'] + NbMailleAjoute = 1 + mm[numfis].tm = NP.concatenate((mm[numfis].tm,NP.array([typ_maille]*NbMailleAjoute))) + mm[numfis].correspondance_mailles += tuple(NomMaillesEnPlus) + mm[numfis].co += NoeudsMailles + fsi = mm[numfis].gma['%s_%i' %(MFISS,it-1)] + fsi = NP.concatenate((fsi,NP.array([nbma]))) + mm[numfis].gma['%s_%i' %(MFISS,it)] = fsi.astype(int) + # Ajout Maille fond (POI1) - NomMaillesEnPlus = ['MF%s%i' %(ALPHABET[0], it+1)] - num_maille = [ nbma + 2 ] - NoeudsMailles = [array([nbno])] - typ_maille = mm.dic['POI1'] - mm.tm = concatenate((mm.tm,array([typ_maille]*1))) - mm.correspondance_mailles += tuple(NomMaillesEnPlus) - mm.co += NoeudsMailles - mm.gma['FOND_%i' %it] = array(nbma+1) - + NomMaillesEnPlus = ['MF%s%i' %(ALPHABET[0], it+1)] + num_maille = [ nbma + 2 ] + NoeudsMailles = [NP.array([nbno])] + typ_maille = mm[numfis].dic['POI1'] + mm[numfis].tm = NP.concatenate((mm[numfis].tm,NP.array([typ_maille]*1))) + mm[numfis].correspondance_mailles += tuple(NomMaillesEnPlus) + mm[numfis].co += NoeudsMailles + mm[numfis].gma['%s_%i' %(MFOND,it)] = NP.array([nbma+1], dtype=int) # Fin du 2D - if INFO==2 : - texte="Maillage produit par l operateur PROPA_FISS" - aster.affiche('MESSAGE',texte) - print mm - -# 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) - self.DeclareOut('ma_xfem2',MA_XFEM2) - ma_xfem2=LIRE_MAILLAGE(UNITE=39); - - MA_TOT2 = args['MA_TOT2'] - if MA_TOT2 != None : self.DeclareOut('ma_tot',MA_TOT2) - MA_STRUC = args['MA_STRUC'] - ma_tot = ASSE_MAILLAGE(MAILLAGE_1 = MA_STRUC, + + if INFO==2 : + texte="Maillage produit par l operateur PROPA_FISS" + aster.affiche('MESSAGE',texte) + print mm[numfis] + +# Sauvegarde maillage xfem + MAIL_FISS2 = Fiss['MAIL_PROPAGE'] + if MAIL_FISS2 != None : self.DeclareOut('ma_xfem2',MAIL_FISS2) + + unit = mm[numfis].ToAster() + DEFI_FICHIER(UNITE=unit, ACTION="LIBERER") + ma_xfem2=LIRE_MAILLAGE(UNITE=unit); + + if numfis == 0 : + __MMX[0]=LIRE_MAILLAGE(UNITE=unit); + else: + __MMX[numfis]=ASSE_MAILLAGE(MAILLAGE_1 = __MMX[numfis-1], MAILLAGE_2 = ma_xfem2, OPERATION='SUPERPOSE') - + + numfis = numfis+1 + +# Sauvegarde maillage concatene + MAIL_TOTAL = args['MAIL_TOTAL'] + if MAIL_TOTAL != None : self.DeclareOut('ma_tot',MAIL_TOTAL) + MAIL_STRUC = args['MAIL_STRUC'] + ma_tot = ASSE_MAILLAGE(MAILLAGE_1 = MAIL_STRUC, + MAILLAGE_2 = __MMX[Nbfissure-1], + OPERATION='SUPERPOSE',) + #------------------------------------------------------------------ # CAS 3 : METHODE_PROPA = 'INITIALISATION' # if METHODE_PROPA == 'INITIALISATION' : form = args['FORM_FISS'] + MFOND = args['GROUP_MA_FOND'] + MFISS = args['GROUP_MA_FISS'] # 3-a : demi-droite if form == 'DEMI_DROITE' : PF = args['PFON'] DTAN = args['DTAN'] - PI = array([[PF[0]-DTAN[0],PF[1]-DTAN[1]],]) + PI = NP.array([[PF[0]-DTAN[0],PF[1]-DTAN[1]],]) ndim = 2 mm = MAIL_PY() mm.__init__() # Ajout des noeuds - LesNoeudsEnPlus = concatenate((PI,array([PF[0:2]]))) + LesNoeudsEnPlus = NP.concatenate((PI,NP.array([PF[0:2]]))) NomNoeudsEnPlus = ['NXA0','NXA1'] mm.cn = LesNoeudsEnPlus mm.correspondance_noeuds = tuple( NomNoeudsEnPlus ) @@ -703,23 +774,23 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args): NomMaillesEnPlus = ['MX%s%i' %(ALPHABET[0], it)] num_maille = [ nbma + 1 ] num_maille.append( nbma + 1 ) - NoeudsMailles = [array([nbno,nbno+1])] + NoeudsMailles = [NP.array([nbno,nbno+1])] typ_maille = mm.dic['SEG2'] NbMailleAjoute = 1 - mm.tm = concatenate((mm.tm,array([typ_maille]*NbMailleAjoute))) + mm.tm = NP.concatenate((mm.tm,NP.array([typ_maille]*NbMailleAjoute))) mm.correspondance_mailles += tuple(NomMaillesEnPlus) mm.co += NoeudsMailles - mm.gma['FISS_0'] = array(nbma) + mm.gma['%s_0' %(MFISS)] = NP.array([nbma], dtype=int) # Ajout Maille fond (POI1) NomMaillesEnPlus = ['MF%s%i' %(ALPHABET[0], it)] num_maille = [ nbma + 2 ] - NoeudsMailles = [array([nbno+1])] + NoeudsMailles = [NP.array([nbno+1])] typ_maille = mm.dic['POI1'] - mm.tm = concatenate((mm.tm,array([typ_maille]*1))) + mm.tm = NP.concatenate((mm.tm,NP.array([typ_maille]*1))) mm.correspondance_mailles += tuple(NomMaillesEnPlus) mm.co += NoeudsMailles - mm.gma['FOND_0'] = array(nbma+1) + mm.gma['%s_0' %(MFOND)] = NP.array([nbma+1], dtype=int) # 3-b : demi-plan @@ -728,7 +799,7 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args): P1 = args['POINT_EXTR'] dpropa = args['DTAN'] nbpt = args['NB_POINT_FOND'] - Q0 = array([[P0[0]-dpropa[0],P0[1]-dpropa[1],P0[2]-dpropa[2]]]) + Q0 = NP.array([[P0[0]-dpropa[0],P0[1]-dpropa[1],P0[2]-dpropa[2]]]) mm = MAIL_PY() mm.__init__() @@ -750,18 +821,18 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args): xx[i] = x[i] - dpropa[0] yy[i] = y[i] - dpropa[1] zz[i] = z[i] - dpropa[2] - LesNoeudsEnPlus = array([[xx[i],yy[i],zz[i]]]) + LesNoeudsEnPlus = NP.array([[xx[i],yy[i],zz[i]]]) NomNoeudsEnPlus = ['NX%s0' %(ALPHABET[i]) ] - mm.cn = concatenate((mm.cn,LesNoeudsEnPlus)) + mm.cn = NP.concatenate((mm.cn,LesNoeudsEnPlus)) mm.correspondance_noeuds = tuple(list(mm.correspondance_noeuds) +NomNoeudsEnPlus ) - LesNoeudsEnPlus = array([P0]) + LesNoeudsEnPlus = NP.array([P0]) NomNoeudsEnPlus = ['NXA1'] - mm.cn = concatenate((mm.cn,LesNoeudsEnPlus)) + mm.cn = NP.concatenate((mm.cn,LesNoeudsEnPlus)) mm.correspondance_noeuds = tuple(list(mm.correspondance_noeuds) + NomNoeudsEnPlus ) for i in range(1,nbpt) : - LesNoeudsEnPlus = array([[x[i],y[i],z[i]]]) + LesNoeudsEnPlus = NP.array([[x[i],y[i],z[i]]]) NomNoeudsEnPlus = ['NX%s1' %(ALPHABET[i]) ] - mm.cn = concatenate((mm.cn,LesNoeudsEnPlus)) + mm.cn = NP.concatenate((mm.cn,LesNoeudsEnPlus)) mm.correspondance_noeuds = tuple(list(mm.correspondance_noeuds) +NomNoeudsEnPlus ) # Ajout Maille levre (quad4) @@ -776,17 +847,14 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args): i2 = ifond+1 i3 = nbpt+ifond i4 = nbpt+ifond+1 - NoeudsMailles.append( array([i1,i2,i4,i3])) + NoeudsMailles.append( NP.array([i1,i2,i4,i3])) typ_maille = mm.dic['QUAD4'] NbMailleAjoute = nbpt-1 - mm.tm = concatenate((mm.tm,array([typ_maille]*NbMailleAjoute))) + mm.tm = NP.concatenate((mm.tm,NP.array([typ_maille]*NbMailleAjoute))) mm.correspondance_mailles += tuple(NomMaillesEnPlus) mm.co += NoeudsMailles - fsi =[] - for ifond in range(nbpt-1) : - fsi = concatenate((fsi,array([ifond]))) - mm.gma['FISS_0' ] = fsi + mm.gma['%s_0' %(MFISS) ] = NP.arange(nbpt-1) # Ajout Maille fond (SEG2) NomMaillesEnPlus = [] @@ -798,18 +866,91 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args): num_maille.append( ifond + nbpt ) i3 = nbpt+ifond i4 = nbpt+ifond+1 - NoeudsMailles.append( array([i3,i4])) + NoeudsMailles.append( NP.array([i3,i4])) typ_maille = mm.dic['SEG2'] NbMailleAjoute = nbpt-1 - mm.tm = concatenate((mm.tm,array([typ_maille]*NbMailleAjoute))) + mm.tm = NP.concatenate((mm.tm,NP.array([typ_maille]*NbMailleAjoute))) mm.correspondance_mailles += tuple(NomMaillesEnPlus) mm.co += NoeudsMailles - fsi = [] - for ifond in range(nbpt-1) : - fsi = concatenate((fsi,array([ifond+nbpt-1]))) - mm.gma['FOND_0'] = fsi + mm.gma['%s_0' %(MFOND)] = NP.arange(nbpt-1, 2*(nbpt-1)) +# 3-c : ellipse + if form == 'ELLIPSE' : + P0 = args['CENTRE'] + alpha0 = args['ANGLE_ORIG'] + alpha1 = args['ANGLE_EXTR'] + vect_x = args['VECT_X'] + vect_y = args['VECT_Y'] + gdax = args['DEMI_GRAND_AXE'] + ptax = args['DEMI_PETIT_AXE'] + normale = cross_product(vect_x,vect_y) + verif = NP.dot(vect_x,vect_y) + if abs(verif) > 0.01: + UTMESS('F','RUPTURE1_52') + nbpt = args['NB_POINT_FOND'] + + mm = MAIL_PY() + mm.__init__() + LesNoeudsEnPlus = NP.array([[P0[0],P0[1],P0[2]]]) + NomNoeudsEnPlus = ['NXA0'] + mm.cn = LesNoeudsEnPlus + mm.correspondance_noeuds = tuple( NomNoeudsEnPlus ) + +# Coordonnees des noeuds + matr = NP.asarray([vect_x,vect_y,normale]) + matr2 = NP.transpose(matr) + alpha0 = alpha0*NP.pi/180. + alpha1 = alpha1*NP.pi/180. + for i in range(nbpt) : + alphai = alpha0 + i*(alpha1-alpha0) / (nbpt-1) + coor_r1 = NP.asarray([gdax*cos(alphai), ptax*sin(alphai), 0]) + coor_r0 = NP.dot(matr2,coor_r1) + P0 + LesNoeudsEnPlus = NP.array([[coor_r0[0],coor_r0[1],coor_r0[2]]]) + NomNoeudsEnPlus = ['NX%s1' %(ALPHABET[i]) ] + mm.cn = NP.concatenate((mm.cn,LesNoeudsEnPlus)) + mm.correspondance_noeuds = tuple(list(mm.correspondance_noeuds) +NomNoeudsEnPlus ) + +# Ajout Maille levre (TRIA3) + NomMaillesEnPlus = [] + num_maille = [] + NoeudsMailles = [] + typ_maille = mm.dic['TRIA3'] + for ifond in range(nbpt-1) : + NomMaillesEnPlus.append( 'MX%s1' %(ALPHABET[ifond]) ) + num_maille.append( [ ifond +1 ] ) + num_maille.append( ifond + 1 ) + i1 = 0 + i2 = ifond + 1 + i3 = ifond + 2 + NoeudsMailles.append( NP.array([i1,i2,i3])) + NbMailleAjoute = nbpt-1 + mm.tm = NP.concatenate((mm.tm,NP.array([typ_maille]*NbMailleAjoute))) + mm.correspondance_mailles += tuple(NomMaillesEnPlus) + mm.co += NoeudsMailles + mm.gma['%s_0' %(MFISS) ] = NP.arange(NbMailleAjoute) + + + +# Ajout Maille fond (SEG2) + NomMaillesEnPlus = [] + num_maille = [] + NoeudsMailles = [] + typ_maille = mm.dic['SEG2'] + for ifond in range(nbpt-1) : + NomMaillesEnPlus.append( 'MF%s1' %(ALPHABET[ifond]) ) + num_maille.append( [ ifond +nbpt ] ) + num_maille.append( ifond + nbpt ) + i3 = ifond + 1 + i4 = ifond + 2 + NoeudsMailles.append( NP.array([i3,i4])) + + NbMailleAjoute = nbpt-1 + mm.tm = NP.concatenate((mm.tm,NP.array([typ_maille]*NbMailleAjoute))) + mm.correspondance_mailles += tuple(NomMaillesEnPlus) + mm.co += NoeudsMailles + mm.gma['%s_0' %(MFOND)] = NP.arange(nbpt-1, 2*(nbpt-1)) + if INFO==2 : texte="Maillage produit par l operateur PROPA_FISS" @@ -817,16 +958,17 @@ def propa_fiss_ops(self,METHODE_PROPA,INFO,**args): print mm # 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) - self.DeclareOut('ma_xfem2',MA_XFEM2) - ma_xfem2=LIRE_MAILLAGE(UNITE=39); - - MA_TOT2 = args['MA_TOT2'] - if MA_TOT2 != None : self.DeclareOut('ma_tot',MA_TOT2) - MA_STRUC = args['MA_STRUC'] - ma_tot = ASSE_MAILLAGE(MAILLAGE_1 = MA_STRUC, + MAIL_FISS2 = args['MAIL_FISS'] + if MAIL_FISS2 != None : self.DeclareOut('ma_xfem2',MAIL_FISS2) + unit = mm.ToAster() + DEFI_FICHIER(UNITE=unit, ACTION="LIBERER") + self.DeclareOut('ma_xfem2',MAIL_FISS2) + ma_xfem2=LIRE_MAILLAGE(UNITE=unit); + + MAIL_TOTAL = args['MAIL_TOTAL'] + if MAIL_TOTAL != None : self.DeclareOut('ma_tot',MAIL_TOTAL) + MAIL_STRUC = args['MAIL_STRUC'] + ma_tot = ASSE_MAILLAGE(MAILLAGE_1 = MAIL_STRUC, MAILLAGE_2 = ma_xfem2, OPERATION='SUPERPOSE') diff --git a/Aster/Cata/cataSTA10/Macro/raff_xfem_ops.py b/Aster/Cata/cataSTA10/Macro/raff_xfem_ops.py index e83fc33f..c427fa6b 100644 --- a/Aster/Cata/cataSTA10/Macro/raff_xfem_ops.py +++ b/Aster/Cata/cataSTA10/Macro/raff_xfem_ops.py @@ -1,4 +1,4 @@ -#@ MODIF raff_xfem_ops Macro DATE 16/11/2009 AUTEUR COURTOIS M.COURTOIS +#@ MODIF raff_xfem_ops Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -29,7 +29,6 @@ def raff_xfem_ops(self,FISSURE,INFO,**args): import string import copy import math - import Numeric from types import ListType, TupleType from Accas import _F from SD.sd_xfem import sd_fiss_xfem diff --git a/Aster/Cata/cataSTA10/Macro/reca_algo.py b/Aster/Cata/cataSTA10/Macro/reca_algo.py index 9320a7a9..7b884a64 100644 --- a/Aster/Cata/cataSTA10/Macro/reca_algo.py +++ b/Aster/Cata/cataSTA10/Macro/reca_algo.py @@ -1,4 +1,4 @@ -#@ MODIF reca_algo Macro DATE 21/09/2009 AUTEUR COURTOIS M.COURTOIS +#@ MODIF reca_algo Macro DATE 26/05/2010 AUTEUR ASSIRE A.ASSIRE # -*- coding: iso-8859-1 -*- # RESPONSABLE ASSIRE A.ASSIRE # CONFIGURATION MANAGEMENT OF EDF VERSION @@ -19,10 +19,11 @@ # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -import Numeric, MLab -from Numeric import take, size -import copy, os -import LinearAlgebra +import os +import copy + +import numpy as NP +import numpy.linalg as linalg try: import aster @@ -33,34 +34,38 @@ try: except: pass +# ------------------------------------------------------------------------------ def calcul_gradient(A,erreur): - grad = Numeric.dot(Numeric.transpose(A),erreur) + grad = NP.dot(NP.transpose(A),erreur) return grad +# ------------------------------------------------------------------------------ +def calcul_norme2(V): + a = NP.array(V) + return NP.dot(a,NP.transpose(a))**0.5 + # ------------------------------------------------------------------------------ # ------------------------------------------------------------------------------ - class Dimension: """ Classe gérant l'adimensionnement et le dimensionnement """ - def __init__(self,val_initiales,para): + def __init__(self,val_initiales): """ Le constructeur calcul la matrice D et son inverse """ self.val_init = val_initiales dim =len(self.val_init) - self.D = Numeric.zeros((dim,dim),Numeric.Float) + self.D = NP.zeros((dim,dim), float) for i in range(dim): self.D[i][i] = self.val_init[i] - self.inv_D=LinearAlgebra.inverse(self.D) + self.inv_D=linalg.inv(self.D) # ------------------------------------------------------------------------------ - - def adim_sensi(self,A): + def adim_sensi(self, A): for i in range(A.shape[0]): for j in range(A.shape[1]): A[i,j] = A[i,j] * self.val_init[j] @@ -68,8 +73,7 @@ class Dimension: # ------------------------------------------------------------------------------ - - def redim_sensi(self,A): + def redim_sensi(self, A): for i in range(A.shape[0]): for j in range(A.shape[1]): A[i,j] = A[i,j] / self.val_init[j] @@ -77,16 +81,15 @@ class Dimension: # ------------------------------------------------------------------------------ - - def adim(self,tab): - tab_adim = Numeric.dot(self.inv_D,copy.copy(tab)) + def adim(self, tab): + tab_adim = NP.dot(self.inv_D,copy.copy(tab)) return tab_adim # ------------------------------------------------------------------------------ - def redim(self,tab_adim): - tab = Numeric.dot(self.D,tab_adim) + def redim(self, tab_adim): + tab = NP.dot(self.D,tab_adim) return tab # ------------------------------------------------------------------------------ @@ -98,42 +101,37 @@ class Dimension: # ------------------------------------------------------------------------------ # ------------------------------------------------------------------------------ - def cond(matrix): - e1=LinearAlgebra.eigenvalues(matrix) + e1=linalg.eigvals(matrix) e=map(abs,e1) size=len(e) - e=Numeric.sort(e) - try: + e=NP.sort(e) + if NP.all(e[0] != 0): condi=e[size-1]/e[0] - except ZeroDivisionError: + else: condi=0.0 return condi,e[size-1],e[0] - - # ------------------------------------------------------------------------------ # ------------------------------------------------------------------------------ - def norm(matrix): - e=LinearAlgebra.Heigenvalues(matrix) + e=linalg.eigvalsh(matrix) size=len(e) - e=Numeric.sort(e) + e=NP.sort(e) norm=e[size-1] return norm # ------------------------------------------------------------------------------ # ------------------------------------------------------------------------------ - def lambda_init(matrix): """ Routine qui calcule la valeur initial du parametre de regularisation l. """ condi,emax,emin=cond(matrix) - id=Numeric.identity(matrix.shape[0]) + id=NP.identity(matrix.shape[0]) if (condi==0.0): l=1.e-3*norm(matrix) elif (condi<=10000): @@ -145,8 +143,7 @@ def lambda_init(matrix): # ------------------------------------------------------------------------------ # ------------------------------------------------------------------------------ - -def Levenberg_bornes(val,Dim,val_init,borne_inf,borne_sup,A,erreur,l,ul_out): +def Levenberg_bornes(val, Dim, val_init, borne_inf, borne_sup, A, erreur, l, ul_out): """ On resoud le système par contraintes actives: Q.dval + s + d =0 @@ -157,24 +154,24 @@ def Levenberg_bornes(val,Dim,val_init,borne_inf,borne_sup,A,erreur,l,ul_out): s.(borne_sup - dval)=0 """ dim = len(val) - id = Numeric.identity(dim) + id = NP.identity(dim) # Matrice du système - Q=Numeric.matrixmultiply(Numeric.transpose(A),A) +l*id + Q=NP.dot(NP.transpose(A),A) +l*id # Second membre du système - d=Numeric.matrixmultiply(Numeric.transpose(A),erreur) + d=NP.dot(NP.transpose(A),erreur) # Ens. de liaisons actives - Act=Numeric.array([]) + Act=NP.array([], dtype=int) k=0 done=0 # Increment des parametres - dval=Numeric.zeros(dim,Numeric.Float) + dval=NP.zeros(dim) while done <1 : k=k+1 - I=Numeric.ones(dim) + I=NP.ones(dim, dtype=int) for i in Act: I[i]=0 - I=Numeric.nonzero(Numeric.greater(I,0)) - s=Numeric.zeros(dim,Numeric.Float) + I=NP.nonzero(NP.greater(I,0))[0] + s=NP.zeros(dim) for i in Act: # test sur les bornes (on stocke si on est en butée haute ou basse) if (val[i]+dval[i]>=borne_sup[i]): @@ -185,41 +182,43 @@ def Levenberg_bornes(val,Dim,val_init,borne_inf,borne_sup,A,erreur,l,ul_out): s[i]=-1. if (len(I)!=0): # xi=-Q(I)-1.(d(I)+Q(I,Act).dval(Act)) - t_QI = take(Q, I) - t_tQI_Act = take(t_QI, Act, 1) - t_adim_Act = take(Dim.adim(dval), Act) - if size(t_tQI_Act) > 0 and size(t_adim_Act) > 0: - smemb = take(d, I) + Numeric.dot(t_tQI_Act, t_adim_Act) + t_QI = NP.take(Q, I, axis=0) + t_tQI_Act = NP.take(t_QI, Act, axis=1) + t_adim_Act = NP.take(Dim.adim(dval), Act) + if NP.size(t_tQI_Act) > 0 and NP.size(t_adim_Act) > 0: + smemb = NP.take(d, I) + NP.dot(t_tQI_Act, t_adim_Act) else: - smemb = take(d, I) - xi=-LinearAlgebra.solve_linear_equations(take(t_QI, I, 1), smemb) - for i in Numeric.arange(len(I)): + smemb = NP.take(d, I) + xi=-linalg.solve(NP.take(t_QI, I, axis=1), smemb) + for i in NP.arange(len(I)): dval[I[i]]=xi[i]*val_init[I[i]] if (len(Act)!=0): # s(Av)=-d(Act)-Q(Act,:).dval - sa=-take(d,Act)-Numeric.dot(take(Q,Act),Dim.adim(dval)) + sa=-NP.take(d,Act)-NP.dot(NP.take(Q,Act,axis=0),Dim.adim(dval)) for i in range(len(Act)): if (s[Act[i]]==-1.): s[Act[i]]=-sa[i] else: s[Act[i]]=sa[i] # Nouvel ens. de liaisons actives - Act=Numeric.concatenate((Numeric.nonzero(Numeric.greater(dval,borne_sup-val)),Numeric.nonzero(Numeric.less(dval,borne_inf-val)),Numeric.nonzero(Numeric.greater(s,0.)))) + Act=NP.concatenate((NP.nonzero(NP.greater(dval,borne_sup-val))[0], + NP.nonzero(NP.less(dval,borne_inf-val))[0], + NP.nonzero(NP.greater(s,0.))[0])).astype(int) done=(max(val+dval-borne_sup)<=0)&(min(val+dval-borne_inf)>=0)&(min(s)>=0.0) # Pour éviter le cyclage if (k>50): try: l=l*2 - Q=Numeric.matrixmultiply(Numeric.transpose(A),A) +l*id + Q=NP.dot(NP.transpose(A),A) +l*id k=0 except: res=open(os.getcwd()+'/fort.'+str(ul_out),'a') - res.write('\n\nQ = \n'+Numeric.array2string(Q-l*id,array_output=1,separator=',')) - res.write('\n\nd = '+Numeric.array2string(d,array_output=1,separator=',')) - res.write('\n\nval = '+Numeric.array2string(val,array_output=1,separator=',')) - res.write('\n\nval_ini= '+Numeric.array2string(val_init,array_output=1,separator=',')) - res.write('\n\nborne_inf= '+Numeric.array2string(borne_inf,array_output=1,separator=',')) - res.write('\n\nborne_sup= '+Numeric.array2string(borne_sup,array_output=1,separator=',')) + res.write('\n\nQ = \n'+NP.array2string(Q-l*id,array_output=1,separator=',')) + res.write('\n\nd = '+NP.array2string(d,array_output=1,separator=',')) + res.write('\n\nval = '+NP.array2string(val,array_output=1,separator=',')) + res.write('\n\nval_ini= '+NP.array2string(val_init,array_output=1,separator=',')) + res.write('\n\nborne_inf= '+NP.array2string(borne_inf,array_output=1,separator=',')) + res.write('\n\nborne_sup= '+NP.array2string(borne_sup,array_output=1,separator=',')) UTMESS('F','RECAL0_18') return newval=copy.copy(val+dval) @@ -228,24 +227,23 @@ def Levenberg_bornes(val,Dim,val_init,borne_inf,borne_sup,A,erreur,l,ul_out): # ------------------------------------------------------------------------------ # ------------------------------------------------------------------------------ - -def actualise_lambda(l,val,new_val,A,erreur,new_J,old_J): +def actualise_lambda(l, val, new_val, A, erreur, new_J, old_J): dim = len(val) - id = Numeric.identity(dim) + id = NP.identity(dim) # Matrice du système - Q=Numeric.matrixmultiply(Numeric.transpose(A),A) +l*id + Q=NP.dot(NP.transpose(A),A) +l*id # Second membre du système - d=Numeric.matrixmultiply(Numeric.transpose(A),erreur) + d=NP.dot(NP.transpose(A),erreur) old_Q=old_J - new_Q=old_J+0.5*Numeric.dot(Numeric.transpose(new_val-val),Numeric.dot(Q,new_val-val))+Numeric.dot(Numeric.transpose(new_val-val),d) + new_Q=old_J+0.5*NP.dot(NP.transpose(new_val-val),NP.dot(Q,new_val-val))+NP.dot(NP.transpose(new_val-val),d) # Ratio de la décroissance réelle et de l'approx. quad. - try: + if NP.all((old_Q-new_Q) != 0.): R=(old_J-new_J)/(old_Q-new_Q) if (R<0.25): l = l*10. elif (R>0.75): l = l/15. - except ZeroDivisionError: + else: if (old_J>new_J): l = l*10. else: @@ -255,14 +253,13 @@ def actualise_lambda(l,val,new_val,A,erreur,new_J,old_J): # ------------------------------------------------------------------------------ # ------------------------------------------------------------------------------ - -def test_convergence(gradient_init,erreur,A,s): +def test_convergence(gradient_init, erreur, A, s): """ Renvoie le residu """ gradient = calcul_gradient(A,erreur)+s try: - epsilon = Numeric.dot(gradient,gradient)/Numeric.dot(gradient_init,gradient_init) + epsilon = NP.dot(gradient,gradient)/NP.dot(gradient_init,gradient_init) except: UTMESS('F', "RECAL0_19") return @@ -272,8 +269,7 @@ def test_convergence(gradient_init,erreur,A,s): # ------------------------------------------------------------------------------ # ------------------------------------------------------------------------------ - -def calcul_etat_final(para,A,iter,max_iter,prec,residu,Messg): +def calcul_etat_final(para, A, iter, max_iter, prec, residu, Messg): """ Fonction appelée quand la convergence est atteinte on calcule le Hessien et les valeurs propres et vecteurs @@ -282,16 +278,19 @@ def calcul_etat_final(para,A,iter,max_iter,prec,residu,Messg): At*A = hessien """ - if ((iter < max_iter) or (residu < prec)): - Hessien = Numeric.matrixmultiply(Numeric.transpose(A),A) +# if ((iter < max_iter) or (residu < prec)): + if 1==1: + Hessien = NP.dot(NP.transpose(A),A) # Desactive temporairement les FPE qui pourraient etre generees (a tord!) par blas aster.matfpe(-1) - valeurs_propres,vecteurs_propres = LinearAlgebra.eigenvectors(Hessien) -# valeurs_propres,vecteurs_propres = MLab.eig(Hessien) - sensible=Numeric.nonzero(Numeric.greater(abs(valeurs_propres/max(abs(valeurs_propres))),1.E-1)) - insensible=Numeric.nonzero(Numeric.less(abs(valeurs_propres/max(abs(valeurs_propres))),1.E-2)) + valeurs_propres,vecteurs_propres = linalg.eig(Hessien) + vecteurs_propres=NP.transpose(vecteurs_propres) # numpy et Numeric n'ont pas la meme convention + sensible=NP.nonzero(NP.greater(abs(valeurs_propres/max(abs(valeurs_propres))),1.E-1))[0] + insensible=NP.nonzero(NP.less(abs(valeurs_propres/max(abs(valeurs_propres))),1.E-2))[0] # Reactive les FPE aster.matfpe(1) Messg.affiche_calcul_etat_final(para,Hessien,valeurs_propres,vecteurs_propres,sensible,insensible) + + diff --git a/Aster/Cata/cataSTA10/Macro/reca_calcul_aster.py b/Aster/Cata/cataSTA10/Macro/reca_calcul_aster.py index b06ece5e..aeb7f070 100644 --- a/Aster/Cata/cataSTA10/Macro/reca_calcul_aster.py +++ b/Aster/Cata/cataSTA10/Macro/reca_calcul_aster.py @@ -1,4 +1,4 @@ -#@ MODIF reca_calcul_aster Macro DATE 13/10/2009 AUTEUR COURTOIS M.COURTOIS +#@ MODIF reca_calcul_aster Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS # -*- coding: iso-8859-1 -*- # RESPONSABLE ASSIRE A.ASSIRE # CONFIGURATION MANAGEMENT OF EDF VERSION @@ -19,756 +19,425 @@ # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -# mode_include = False -# __follow_output = False -# table_sensibilite = False -__commandes_aster__ = False debug = False -import copy, Numeric, types, os, sys, pprint, math -from glob import glob +import copy +import types +import os +import sys +import pprint +import math +import glob +import socket +import shutil + +import numpy as NP from Utilitai.System import ExecCommand from Utilitai.Utmess import UTMESS -# Nom de la routine -nompro = 'MACR_RECAL' - - -# ------------------------------------------------------------------------------ - -class PARAMETRES: - - def __init__(self, METHODE, UNITE_RESU, INFO=1, fich_output='./REPE_OUT/output_esclave.txt', mode_include=False, follow_output=False, table_sensibilite=False, memjeveux_esclave=None, PARA_DIFF_FINI=1.E-3, ITER_MAXI=10, ITER_FONC_MAXI=100): - - self.METHODE = METHODE - self.UNITE_RESU = UNITE_RESU - self.INFO = INFO - self.fich_output = fich_output - self.PARA_DIFF_FINI = PARA_DIFF_FINI - self.ITER_FONC_MAXI = ITER_FONC_MAXI - self.ITER_MAXI = ITER_MAXI, - - try: - import Cata, aster - from Cata.cata import INCLUDE, DETRUIRE, FIN, DEFI_FICHIER, IMPR_TABLE, LIRE_TABLE, INFO_EXEC_ASTER, EXTR_TABLE, CREA_TABLE - from Accas import _F - except: - mode_include = False - - if not mode_include: - try: - from Macro.lire_table_ops import lecture_table - mode_aster = True - except: - try: - sys.path.append( './Python/Macro' ) - from Macro.lire_table_ops import lecture_table - mode_aster = False - except: - UTMESS('F','RECAL0_20') - self.mode_include = mode_include - self.follow_output = follow_output - self.mode_aster = mode_aster - self.memjeveux_esclave = memjeveux_esclave - self.table_sensibilite = table_sensibilite - - self.vector_output = False - self.error_output = False +from recal import Affiche_Param, CALCULS_ASTER, CALC_ERROR +from reca_utilitaires import Random_Tmp_Name # ------------------------------------------------------------------------------ - class CALCUL_ASTER: - def __init__(self, PARAMETRES, UL, para, reponses, LIST_SENSI=[], LIST_DERIV=[]): - - self.UL = UL - self.para = para - self.reponses = reponses - self.LIST_SENSI = LIST_SENSI - self.LIST_DERIV = LIST_DERIV - - self.METHODE = PARAMETRES.METHODE - self.UNITE_RESU = PARAMETRES.UNITE_RESU - self.INFO = PARAMETRES.INFO - self.fich_output = PARAMETRES.fich_output - self.mode_include = PARAMETRES.mode_include - self.follow_output = PARAMETRES.follow_output - self.table_sensibilite = PARAMETRES.table_sensibilite - self.mode_aster = PARAMETRES.mode_aster - self.memjeveux_esclave = PARAMETRES.memjeveux_esclave - self.PARA_DIFF_FINI = PARAMETRES.PARA_DIFF_FINI - self.ITER_FONC_MAXI = PARAMETRES.ITER_FONC_MAXI - self.vector_output = PARAMETRES.vector_output - self.error_output = PARAMETRES.vector_output - - self.UNITE_GRAPHIQUE = None - self.new_export = 'tmp_export' - self.nom_fichier_mess_fils = None - self.nom_fichier_resu_fils = None - - self.fichier_esclave = None - - self.evaluation_fonction = 0 - - self.L_J_init = None - self.val = None - self.L = None - self.L_deriv_sensible = None - + def __init__(self, jdc, METHODE, + UNITE_ESCL, + UNITE_RESU, + para, + reponses, + PARA_DIFF_FINI=1.E-3, + vector_output=True, + GRADIENT=None, + DYNAMIQUE=None, + #LANCEMENT='DISTRIBUE', + CALCUL_ESCLAVE=None, + INFO=0, + ): + + self.METHODE = METHODE + self.UNITE_ESCL = UNITE_ESCL + self.UNITE_RESU = UNITE_RESU + self.para = para + self.reponses = reponses + self.PARA_DIFF_FINI = PARA_DIFF_FINI + self.vector_output = vector_output + + self.memjeveux_esclave = CALCUL_ESCLAVE['memjeveux_esclave'] + self.mem_aster = CALCUL_ESCLAVE['mem_aster'] + self.MODE = CALCUL_ESCLAVE['MODE'] + self.MEMOIRE = CALCUL_ESCLAVE['MEMOIRE'] + self.TEMPS = CALCUL_ESCLAVE['TEMPS'] + self.CLASSE = CALCUL_ESCLAVE['CLASSE'] + self.ACTUALISATION = CALCUL_ESCLAVE['ACTUALISATION'] + self.NMAX_SIMULT = CALCUL_ESCLAVE['NMAX_SIMULT'] + self.LANCEMENT = CALCUL_ESCLAVE['LANCEMENT'] + + self.INFO = INFO + + # Optionnels + self.UNITE_GRAPHIQUE = None + self.export = None + self.follow_output = None + self.GRADIENT = GRADIENT + self.DYNAMIQUE = DYNAMIQUE + #self.LANCEMENT = LANCEMENT + + # Variables locales + self.new_export = os.path.join(os.getcwd(), 'tmp_export') + + # Variables calculees + self.evaluation_fonction = 0 + + # Initialisation + self.reset() + + # Dynamique : pour l'appariement manuel des modes en dynamique + self.graph_mac = False + + # JDC + self.jdc = jdc # ------------------------------------------------------------------------------ - - def Lancement_Commande(self, cmd): - - if self.INFO>=1: UTMESS('I','EXECLOGICIEL0_8',valk=cmd) - - fich_output = self.fich_output - follow_output = self.follow_output - - # Lancement d'Aster avec le deuxieme export - iret, txt_output = ExecCommand(cmd, follow_output=self.follow_output,verbose=False) - - if fich_output: - # Recuperation du .mess 'fils' - f=open(fich_output, 'w') - f.write( txt_output ) - f.close() - - if self.INFO>=1: UTMESS('I','EXECLOGICIEL0_12',valk=cmd) - - diag = self.Recuperation_Diagnostic(txt_output) - - return + def Set_Parameters(self, **args): + for cle in args.keys(): + exec( "%s=%s" % (cle, args[cle]) ) # ------------------------------------------------------------------------------ + def reset(self): - def Recuperation_Diagnostic(self, output): + self.Lcalc = None + self.erreur = None + self.residu = None + self.norme = None + self.A_nodim = None + self.A = None + self.norme_A_nodim = None + self.norme_A = None + self.L = None +# self.L_J_init = None - txt = '--- DIAGNOSTIC JOB :' - diag = '' - for ligne in output.splitlines(): - if ligne.find(txt) > -1: - diag = ligne.split(txt)[-1].strip() - break - if self.INFO>=1: UTMESS('I','RECAL0_21',valk=diag) + # ------------------------------------------------------------------------------ + def calcul_Aster(self, val, dX=None): + + # ---------------------------------------------------------------------------- + # Commun + # ---------------------------------------------------------------------------- + self.val = val + info = self.INFO + + # MACR_RECAL inputs + parametres = self.LIST_PARA + calcul = self.RESU_CALC + experience = self.RESU_EXP + + # Current estimation + X0 = val + dX = dX + + # Objet Calcul + C = CALCULS_ASTER( + # MACR_RECAL inputs + parametres = parametres, + calcul = calcul, + experience = experience, + LANCEMENT = self.LANCEMENT, + jdc = self.jdc, + ) + + # Traitement special pour la dynamique (affichage des MAC dans l'esclave) + if self.DYNAMIQUE: C.SetDynamiqueMode(self.DYNAMIQUE, self.graph_mac) + + + # ---------------------------------------------------------------------------- + # ASRUN distribue + # ---------------------------------------------------------------------------- + if self.LANCEMENT == 'DISTRIBUTION': + + # Creation du repertoire temporaire pour l'execution de l'esclave + tmp_macr_recal = self.Creation_Temporaire_Esclave() + + # Creation du fichier .export de l'esclave + self.Creation_Fichier_Export_Esclave(tmp_macr_recal) + + # Code_Aster installation + if os.environ.has_key('ASTER_ROOT'): + ASTER_ROOT = os.environ['ASTER_ROOT'] + else: + import aster + ASTER_ROOT = os.path.join(aster.repout(), '..') + as_run = os.path.join(ASTER_ROOT, 'bin', 'as_run') - if diag in ['OK', 'NOOK_TEST_RESU', '_ALARM', '_COPY_ERROR']: return True - else: - UTMESS('F','RECAL0_22') + # General + resudir = None + clean = True + NMAX_SIMULT = self.NMAX_SIMULT + # Study + export = self.new_export - # ------------------------------------------------------------------------------ + C.follow_output = self.follow_output - def Remplace_fichier_esclave(self, val_in): pass + # Lancement des calculs + fonctionnelle, gradient = C.run( + # Current estimation + X0, + dX, + # Code_Aster installation + ASTER_ROOT = ASTER_ROOT, + as_run = as_run, - # ------------------------------------------------------------------------------ + # General + resudir = resudir, + clean = clean, + info = info, + NMAX_SIMULT = NMAX_SIMULT, - def calcul_Aster(self, val, INFO=0): - - self.val = val - UL = self.UL - para = self.para - reponses = self.reponses - UNITE_RESU = self.UNITE_RESU - LIST_SENSI = self.LIST_SENSI - LIST_DERIV = self.LIST_DERIV - - mode_include = self.mode_include - follow_output = self.follow_output - table_sensibilite = self.table_sensibilite - - if self.evaluation_fonction > self.ITER_FONC_MAXI: - UTMESS('F', 'RECAL0_23') - self.evaluation_fonction += 1 - - - if not mode_include: - - # Creation du repertoire temporaire pour l'execution de l'esclave - tmp_macr_recal = self.Creation_Temporaire_Esclave() - - # Creation du fichier .export de l'esclave - self.Creation_Fichier_Export_Esclave(tmp_macr_recal) - - # Fichier esclave a modifier (si methode EXTERNE alors on prend directement le fichier esclave, sinon c'est le fort.UL dans le repertoire d'execution - try: - if self.METHODE=='EXTERNE': - fic = open(self.fichier_esclave,'r') - else: - fic = open('fort.'+str(UL),'r') - - # On stocke le contenu de fort.UL dans la variable fichier qui est une string - fichier=fic.read() - # On stocke le contenu initial de fort.UL dans la variable fichiersauv - fichiersauv=copy.copy(fichier) - fic.close() - except: - UTMESS('F', 'RECAL0_24', valk=self.fichier_esclave) - - # chemin vers as_run - if os.environ.has_key('ASTER_ROOT'): - as_run = os.path.join(os.environ['ASTER_ROOT'], 'ASTK', 'ASTK_SERV', 'bin', 'as_run') - elif os.path.isfile(aster.repout() + os.sep + 'as_run'): - as_run = aster.repout() + os.sep + 'as_run' - else: - as_run = 'as_run' - if INFO>=1: UTMESS('A', 'RECAL0_83') - - if __commandes_aster__: - try: - from Cata.cata import INCLUDE, DETRUIRE, FIN, DEFI_FICHIER, IMPR_TABLE, LIRE_TABLE, INFO_EXEC_ASTER, EXTR_TABLE, CREA_TABLE - except: - message = "Erreur" - UTMESS('F', 'DVP_1') - - # Utilisation du module Python de LIRE_TABLE - if self.mode_aster: - from Macro.lire_table_ops import lecture_table - else: - try: - sys.path.append( './Python/Macro' ) - from lire_table_ops import lecture_table - except: - UTMESS('F','RECAL0_20') - - txt = [] - for i in para: - txt.append( "\t\t\t%s : %s" % (i, val[para.index(i)]) ) - if INFO>=1: UTMESS('I','RECAL0_25',valk='\n'.join(txt)) - - - # MARCHE PAS !! -# # Quelques verifications/modifications sur le fichier esclave, pour blindage -# fichiernew=[] -# for ligne in fichier.split('\n'): -# # DEBUT et FIN (on retire les espaces entre le mot-clé et la premiere parenthese) -# for (txt1, txt2) in [('DEBUT','('), ('FIN','(')]: -# if ligne.find( txt1 )!=-1 and ligne.find( txt2 )!=-1: -# index_deb1 = ligne.index(txt1) -# ligne1 = ligne[ index_deb1+len(txt1):] -# if ligne.find( txt1 )!=-1: -# -# -# for (txt1, txt2) in [('DEBUT','('), ('FIN','(')]: -# if ligne.find( txt1 )!=-1 and ligne.find( txt2 )!=-1: -# index_deb1 = ligne.index(txt1) -# index_fin1 = index_deb1 + len(txt1) -# index_deb2 = ligne.index(txt2) -# index_fin2 = index_deb1 + len(txt2) -# ligne = ligne[:index_fin1]+ligne[index_deb2:] -# # on retire les parametes en commentaires -# for txt in para: -# if ligne.find(txt)!=-1: -# if ligne.replace(' ', '')[0] == '#': ligne = '' -# fichiernew.append(ligne) -# fichier = '\n'.join(fichiernew) - - - - # On supprime tous les commentaires du fichier esclave - fichiernew=[] - for ligne in fichier.split('\n'): - if ligne.strip() != '': - if ligne.replace(' ', '')[0] == '#': ligne = '' - fichiernew.append(ligne) - fichier = '\n'.join(fichiernew) - - - #Fichier_Resu est une liste ou l'on va stocker le fichier modifié - #idée générale :on délimite des 'blocs' dans fichier - #on modifie ou non ces blocs suivant les besoins - #on ajoute ces blocs dans la liste Fichier_Resu - Fichier_Resu=[] - - # Dans le cas du mode INCLUDE on enleve le mot-clé DEBUT - if mode_include: - try: - #cherche l'indice de DEBUT() - index_deb=fichier.index('DEBUT(') - while( fichier[index_deb]!='\n'): - index_deb=index_deb+1 - #on restreint fichier en enlevant 'DEBUT();' - fichier = fichier[index_deb+1:] - except: - #on va dans l'except si on a modifié le fichier au moins une fois - pass - -# print 60*'o' -# print fichier -# print 60*'o' - - # On enleve le mot-clé FIN() - try: - #cherche l'indice de FIN() - index_fin = fichier.index('FIN(') - #on restreint fichier en enlevant 'FIN();' - fichier = fichier[:index_fin] - except : pass - -# print 60*'o' -# print fichier -# print 60*'o' - - #-------------------------------------------------------------------------------- - #on cherche à délimiter le bloc des parametres dans le fichier - #Tout d'abord on cherche les indices d'apparition des paras dans le fichier - #en effet l'utilisateur n'est pas obligé de rentrer les paras dans optimise - #avec le meme ordre que son fichier de commande - index_para = Numeric.zeros(len(para)) - for i in range(len(para)): - index_para[i] = fichier.index(para[i]) - - #On range les indices par ordre croissant afin de déterminer - #les indice_max et indice_min - index_para = Numeric.sort(index_para) - index_first_para = index_para[0] - index_last_para = index_para[len(index_para)-1] - - - #on va délimiter les blocs intermédiaires entre chaque para "utiles" à l'optimsation - bloc_inter ='\n' - for i in range(len(para)-1): - j = index_para[i] - k = index_para[i+1] - while(fichier[j]!= '\n'): - j=j+1 - bloc_inter=bloc_inter + fichier[j:k] + '\n' - - #on veut se placer sur le premier retour chariot que l'on trouve sur la ligne du dernier para - i = index_last_para - while(fichier[i] != '\n'): - i = i + 1 - index_last_para = i - #on délimite les blocs suivants: - pre_bloc = fichier[:index_first_para] #fichier avant premier parametre - post_bloc = fichier[ index_last_para+ 1:] #fichier après dernier parametre - - #on ajoute dans L tous ce qui est avant le premier paramètre - Fichier_Resu.append(pre_bloc) - Fichier_Resu.append('\n') - - # Liste des parametres utilisant la SENSIBILITE - liste_sensibilite = [] - if len(LIST_SENSI)>0: - for i in LIST_SENSI: - liste_sensibilite.append( i ) - - #On ajoute la nouvelle valeur des parametres - dim_para=len(para) - for j in range(dim_para): - if not para[j] in liste_sensibilite: - Fichier_Resu.append(para[j]+'='+str(val[j]) + ';' + '\n') - else: - Fichier_Resu.append(para[j]+'=DEFI_PARA_SENSI(VALE='+str(val[j]) + ',);' + '\n') - - - #On ajoute à Fichier_Resu tous ce qui est entre les parametres - Fichier_Resu.append(bloc_inter) - - Fichier_Resu.append(post_bloc) - - #-------------------------------------------------------------------------------- - #on va ajouter la fonction d'extraction du numarray de la table par la méthode Array - #et on stocke les réponses calculées dans la liste Lrep - #qui va etre retournée par la fonction calcul_Aster - if mode_include: - self.g_context['Lrep'] = [] - Fichier_Resu.append('Lrep=[]'+'\n') - for i in range(len(reponses)): - Fichier_Resu.append('t'+str(reponses[i][0])+'='+str(reponses[i][0])+'.EXTR_TABLE()'+'\n') - Fichier_Resu.append('F = '+'t'+str(reponses[i][0])+'.Array('+"'"+str(reponses[i][1])+"'"+','+"'"+str(reponses[i][2])+"'"+')'+'\n') - Fichier_Resu.append('Lrep.append(F)'+'\n') - - #ouverture du fichier fort.3 et mise a jour de celui ci - x=open('fort.'+str(UL),'w') - if mode_include: - x.writelines('from Accas import _F \nfrom Cata.cata import * \n') - x.writelines(Fichier_Resu) - x.close() - - del(pre_bloc) - del(post_bloc) - del(fichier) - - # ---------------------------------------------------------------------------------- - # Execution d'une deuxieme instance d'Aster - - if not mode_include: - - # Ajout des commandes d'impression des tables Resultats et Derivees à la fin du fichier esclave - Fichier_Resu = [] - num_ul = '99' - - # Tables correspondant aux Resultats - for i in range(len(reponses)): - _ul = str(int(100+i)) - - try: os.remove( tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+_ul ) - except: pass - - Fichier_Resu.append("\n# Recuperation de la table : " + str(reponses[i][0]) + "\n") - Fichier_Resu.append("DEFI_FICHIER(UNITE="+num_ul+", FICHIER='"+tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+_ul+"',);\n") - Fichier_Resu.append("IMPR_TABLE(TABLE="+str(reponses[i][0])+", FORMAT='ASTER', UNITE="+num_ul+", INFO=1, FORMAT_R='E30.20',);\n") - Fichier_Resu.append("DEFI_FICHIER(ACTION='LIBERER', UNITE="+num_ul+",);\n") - - # Tables correspondant aux Derivees - if len(LIST_SENSI)>0: - i = 0 - for _para in LIST_SENSI: - _lst_tbl = LIST_DERIV[_para][0] - for _lst_tbl in LIST_DERIV[_para]: - i += 1 - _tbl = _lst_tbl[0] - - _ul = str(int(100+len(reponses)+i)) - try: os.remove( tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+_ul ) - except: pass - - Fichier_Resu.append("\n# Recuperation de la table derivee : " + _tbl + " (parametre " + _para + ")\n") - Fichier_Resu.append("DEFI_FICHIER(UNITE="+num_ul+", FICHIER='"+tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+_ul+"',);\n") - if table_sensibilite: - Fichier_Resu.append("IMPR_TABLE(TABLE="+_tbl+", SENSIBILITE="+_para+", FORMAT='ASTER', UNITE="+num_ul+", INFO=1, FORMAT_R='E30.20',);\n") - else: - Fichier_Resu.append("IMPR_TABLE(TABLE="+_tbl+", FORMAT='ASTER', UNITE="+num_ul+", INFO=1, FORMAT_R='E30.20',);\n") - Fichier_Resu.append("DEFI_FICHIER(ACTION='LIBERER', UNITE="+num_ul+",);\n") - - # Ecriture du "nouveau" fichier .comm - x=open('fort.'+str(UL),'a') - x.write( '\n'.join(Fichier_Resu) ) - x.write('\nFIN();\n') - x.close() - -# os.system("cat %s" % self.new_export) - - # Lancement du calcul Aster esclave - cmd = '%s %s' % (as_run, self.new_export) - self.Lancement_Commande(cmd) - - # Recuperation du .mess et du .resu 'fils' - if self.METHODE != 'EXTERNE': - if self.nom_fichier_mess_fils: - cmd = 'cp ' + tmp_macr_recal + os.sep + self.nom_fichier_mess_fils + ' ./REPE_OUT/' - os.system( cmd ) - if self.nom_fichier_resu_fils: - cmd = 'cp ' + tmp_macr_recal + os.sep + self.nom_fichier_resu_fils + ' ./REPE_OUT/' - os.system( cmd ) - - if __commandes_aster__: - # Unite logique libre - _tbul_libre=INFO_EXEC_ASTER(LISTE_INFO='UNITE_LIBRE') - _ul_libre=_tbul_libre['UNITE_LIBRE',1] + # Study + export = export, + ) - # ------------------------------------------------------ - # Recuperation des tableaux resultats - Lrep=[] - _TB = [None]*len(reponses) - for i in range(len(reponses)): - if __commandes_aster__: + # ---------------------------------------------------------------------------- + # Aiguillage vers INCLUDE + # ---------------------------------------------------------------------------- + if self.LANCEMENT == 'INCLUSION': + C.UNITE_ESCL = self.UNITE_ESCL - # Version par des commandes Aster - # ------- + # Lancement des calculs + fonctionnelle, gradient = C.run( + # Current estimation + X0, + dX, + # General + info, + ) - DEFI_FICHIER(UNITE=_ul_libre, FICHIER=tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+str(int(100+i)), ); - try: - _TB[i]=LIRE_TABLE(UNITE=_ul_libre, - FORMAT='ASTER', - NUME_TABLE=1, - SEPARATEUR=' ',); - DEFI_FICHIER(ACTION='LIBERER', UNITE=_ul_libre,); - tREPONSE=_TB[i].EXTR_TABLE() - - F = tREPONSE.Array( str(reponses[i][1]), str(reponses[i][2]) ) - Lrep.append(F) - except: - UTMESS('F', 'RECAL0_26') + # ---------------------------------------------------------------------------- + # Sortie + # ---------------------------------------------------------------------------- + if dX: self.evaluation_fonction += 1+ len(dX) + else: self.evaluation_fonction += 1 - else: + self.Lcalc = C.Lcalc - # Version par utilisation directe du python de lire_table - # ------- - - # Chemin vers le fichier contenant la table - _fic_table = tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+str(int(100+i)) - - try: - file=open(_fic_table,'r') - texte=file.read() - file.close() - except Exception, err: - ier=1 - UTMESS('F', 'RECAL0_27', valk=str(err)) - - try: - table_lue = lecture_table(texte, 1, ' ') - list_para = table_lue.para - tab_lue = table_lue.values() - except Exception, err: - UTMESS('F', 'RECAL0_28', valk=str(err)) - - try: - nb_val = len(tab_lue[ list_para[0] ]) - F = Numeric.zeros((nb_val,2), Numeric.Float) - for k in range(nb_val): -# F[k][0] = tab_lue[ list_para[0] ][1][k] -# F[k][1] = tab_lue[ list_para[1] ][1][k] - F[k][0] = tab_lue[ str(reponses[i][1]) ][k] - F[k][1] = tab_lue[ str(reponses[i][2]) ][k] - Lrep.append(F) - except Exception, err: - UTMESS('F', 'RECAL0_29', valk=str(err)) - - - # ------------------------------------------------------ - # Recuperation des tableaux des derivees (SENSIBILITE) - L_deriv={} - if len(LIST_SENSI)>0: - _lon = 0 - for _para in LIST_SENSI: - _lon += len(LIST_DERIV[_para]) - _TBD = [None]*_lon - - i = 0 - for _para in LIST_SENSI: - - L_deriv[_para] = [] - _lst_tbl = LIST_DERIV[_para][0] - - for _lst_tbl in LIST_DERIV[_para]: - j = LIST_DERIV[_para].index(_lst_tbl) - _tbl = _lst_tbl[0] - - if __commandes_aster__: - - # Version par des commandes Aster - # ------- - - DEFI_FICHIER(UNITE=_ul_libre, FICHIER=tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+str(int(100+len(reponses)+1+i)),); - _TBD[i]=LIRE_TABLE(UNITE=_ul_libre, - FORMAT='ASTER', - NUME_TABLE=1, - SEPARATEUR=' ',); - DEFI_FICHIER(ACTION='LIBERER', UNITE=_ul_libre,); - tREPONSE=_TBD[i].EXTR_TABLE() - DF = tREPONSE.Array( str(LIST_DERIV[_para][j][1]), str(LIST_DERIV[_para][j][2]) ) - L_deriv[_para].append(DF) - i+=1 - - else: - - # Version par utilisation directe du python de lire_table - # ------- - - # Chemin vers le fichier contenant la table - _fic_table = tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+str(int(100+len(reponses)+1+i)) - - try: - file=open(_fic_table,'r') - texte=file.read() - file.close() - except Exception, err: - UTMESS('F', 'RECAL0_27', valk=str(err)) - - try: - table_lue = lecture_table(texte, 1, ' ') - list_para = table_lue.para - tab_lue = table_lue.values() - except Exception, err: - UTMESS('F', 'RECAL0_28', valk=str(err)) - - try: - nb_val = len(tab_lue[ list_para[0] ]) - DF = Numeric.zeros((nb_val,2), Numeric.Float) - for k in range(nb_val): -# DF[k][0] = tab_lue[ list_para[0] ][1][k] -# DF[k][1] = tab_lue[ list_para[1] ][1][k] - DF[k][0] = tab_lue[ str(LIST_DERIV[_para][j][1]) ][k] - DF[k][1] = tab_lue[ str(LIST_DERIV[_para][j][2]) ][k] - L_deriv[_para].append(DF) - i+=1 - except Exception, err: - UTMESS('F', 'RECAL0_29', valk=str(err)) - - - # Nettoyage du export - try: os.remove(self.new_export) - except: pass - - # Nettoyage du repertoire temporaire - if self.METHODE == 'EXTERNE': listdir = ['REPE_TABLE', 'base', 'REPE_IN'] - else: listdir = ['.', 'REPE_TABLE', 'base', 'REPE_OUT', 'REPE_IN'] - for dir in listdir: - try: - for fic in os.listdir(tmp_macr_recal+os.sep+dir): - try: os.remove(tmp_macr_recal+os.sep+dir+os.sep+fic) - except: pass - except: pass + if not dX: return self.Lcalc[0], {} + else: return fonctionnelle, gradient + # ------------------------------------------------------------------------------ + def Affiche_Param(self, val): + """ Affiche les parametres """ + return Affiche_Param(self.para, val) - # ---------------------------------------------------------------------------------- - # Ou bien on inclue le fichier Esclave - elif mode_include: + # ------------------------------------------------------------------------------ + def calcul_F(self, val): + """ + Calcul de F + """ + UTMESS('I', 'RECAL0_25', valk=self.Affiche_Param(val) ) - if debug: os.system('cp fort.'+str(UL)+' REPE_OUT/') - - INCLUDE(UNITE = UL) - - Lrep = self.g_context['Lrep'] - L_deriv = None + # Reset les variables deja calculees par les calculs precedents + self.reset() - # Destruction des concepts Aster - reca_utilitaires.detr_concepts(self) + # Calcul pour le jeu de parametre val + fonctionnelle, gradient = self.calcul_Aster(val, dX=None) + # Calcul de l'erreur par rapport aux donnees experimentale + E = CALC_ERROR( + experience = self.RESU_EXP, + X0 = val, + calcul = self.RESU_CALC, + poids = self.Simul.poids, + objective_type = 'vector', + info = self.INFO, + ) + self.erreur = E.CalcError(self.Lcalc) + + # norme de l'erreur + self.norme = NP.sum( [x**2 for x in self.erreur] ) - # ---------------------------------------------------------------------------------- - # Ou alors probleme ? - else: sys.exit(1) + if debug: + print "self.reponses=", self.reponses + print "F=", E.F + print "L_J=", E.L_J + print "L_J_init=", E.L_J_init + print "J=", E.J + print 'erreur=', self.erreur + print "norme de l'erreur=", self.norme + print "norme de J (fonctionnelle)=", str(E.J) + if self.INFO>=2: + UTMESS('I', 'RECAL0_30') + if self.evaluation_fonction >1: UTMESS('I', 'RECAL0_39', valk=str(self.evaluation_fonction)) - del(Fichier_Resu) - - # on remet le fichier dans son etat initial - x=open('fort.'+str(UL),'w') - x.writelines(fichiersauv) - x.close() - - return Lrep, L_deriv - + if self.vector_output: + if self.INFO>=2: UTMESS('I', 'RECAL0_35', valr=self.norme) + return self.erreur + else: + if self.INFO>=2: UTMESS('I', 'RECAL0_36', valr=self.norme) + return self.norme # ------------------------------------------------------------------------------ - - def calcul_FG(self, val): - - self.L, self.L_deriv_sensible = self.calcul_Aster(val, INFO=self.INFO) - self.L_J, self.erreur = self.Simul.multi_interpole(self.L, self.reponses) - if not self.L_J_init: self.L_J_init = copy.copy(self.L_J) - self.J = self.Simul.norme_J(self.L_J_init, self.L_J, self.UNITE_RESU) - - # Calcul des derivees - self.A_nodim = self.Simul.sensibilite(self, self.L, self.L_deriv_sensible, val, self.PARA_DIFF_FINI) - - self.A = self.Dim.adim_sensi( copy.copy(self.A_nodim) ) -# self.residu = self.reca_algo.test_convergence(self.gradient_init, self.erreur, self.A, Numeric.zeros(len(self.gradient_init),Numeric.Float) ) - self.residu = 0. - - if self.vector_output: - return self.erreur, self.residu, self.A_nodim, self.A - else: - # norme de l'erreur - self.norme = Numeric.dot(self.erreur, self.erreur)**0.5 - - self.norme_A_nodim = Numeric.zeros( (1,len(self.para)), Numeric.Float ) - self.norme_A = Numeric.zeros( (1,len(self.para)), Numeric.Float ) - for c in range(len(self.A[0,:])): - norme_A_nodim = 0 - norme_A = 0 - for l in range(len(self.A[:,0])): - norme_A_nodim += self.A_nodim[l,c] * self.A_nodim[l,c] - norme_A += self.A[l,c] * self.A[l,c] - self.norme_A_nodim[0,c] = math.sqrt( norme_A_nodim ) - self.norme_A[0,c] = math.sqrt( norme_A ) - - return self.norme, self.residu, self.norme_A_nodim, self.norme_A + def calcul_F2(self, val): + """ + Calcul de F (et de G) mais renvoit juste la fonctionnelle + Sert pour les algorithmes qui veulent une fonction ou F, une fonction pour G mais qu'on veut pouvoir tout calculer en distibue + """ + a, b, c, d = self.calcul_FG(val) + if self.vector_output: return self.erreur + else: return self.norme # ------------------------------------------------------------------------------ - - def calcul_F(self, val): - - self.L, self.L_deriv_sensible = self.calcul_Aster(val, INFO=self.INFO) - L_J, erreur = self.Simul.multi_interpole(self.L, self.reponses) - if not self.L_J_init: self.L_J_init = copy.copy(L_J) - J = self.Simul.norme_J(self.L_J_init, L_J, self.UNITE_RESU) - - # norme de l'erreur - norme = Numeric.sum( [x**2 for x in erreur] ) - - if debug: - print 'erreur=', erreur - print "norme de l'erreur=", norme - print "norme de J (fonctionnelle)=", str(J) - - if self.INFO>=1: - UTMESS('I', 'RECAL0_30') - if self.evaluation_fonction >1: - UTMESS('I', 'RECAL0_1', valk=str(self.evaluation_fonction)) - UTMESS('I', 'RECAL0_31', valk=J) - - if self.vector_output: - if self.INFO>=1: - UTMESS('I', 'RECAL0_32', valk=str(norme)) - return erreur - else: - if self.INFO>=1: - UTMESS('I', 'RECAL0_33', valk=str(norme)) - return norme + def calcul_FG(self, val): + """ + Calcul de F et de G + """ + UTMESS('I', 'RECAL0_26', valk=self.Affiche_Param(val) ) + + # Reset les variables deja calculees par les calculs precedents + self.reset() + + # Calcul pour le jeu de parametres val + dX = len(val)*[self.PARA_DIFF_FINI] + fonctionnelle, gradient = self.calcul_Aster(val, dX) + + # Calcul de l'erreur par rapport aux donnees experimentale + E = CALC_ERROR( + experience = self.RESU_EXP, + X0 = val, + calcul = self.RESU_CALC, + poids = self.Simul.poids, + objective_type = 'vector', + info = self.INFO, + ) + + self.erreur, self.residu, self.A_nodim, self.A = E.CalcSensibilityMatrix(Lcalc=self.Lcalc, val=val, dX=None, pas=self.PARA_DIFF_FINI) + + if debug: + print "A_nodim=", self.A_nodim + print "self.A=", self.A + print "self.erreur=", self.erreur + print "self.residu=", self.residu + print "self.vector_output=", self.vector_output + + + if self.vector_output: + return self.erreur, self.residu, self.A_nodim, self.A + else: + # norme de l'erreur + self.norme = NP.dot(self.erreur, self.erreur)**0.5 + self.norme_A_nodim = NP.zeros( (1,len(self.para))) + self.norme_A = NP.zeros( (1,len(self.para))) + for c in range(len(self.A[0,:])): + norme_A_nodim = 0 + norme_A = 0 + for l in range(len(self.A[:,0])): + norme_A_nodim += self.A_nodim[l,c] * self.A_nodim[l,c] + norme_A += self.A[l,c] * self.A[l,c] + self.norme_A_nodim[0,c] = math.sqrt( norme_A_nodim ) + self.norme_A[0,c] = math.sqrt( norme_A ) + return self.norme, self.residu, self.norme_A_nodim, self.norme_A # ------------------------------------------------------------------------------ - def calcul_G(self, val): + """ + Calcul de G + """ + UTMESS('I', 'RECAL0_27', valk=self.Affiche_Param(val) ) - # Si le calcul Aster est deja effectue pour val on ne le refait pas - if (self.val == val) and self.L and self.L_deriv_sensible: pass - else: - self.L, self.L_deriv_sensible = self.calcul_Aster(val, INFO=self.INFO) - A = self.Simul.sensibilite(self, self.L, self.L_deriv_sensible, val, self.PARA_DIFF_FINI) - A = self.Dim.adim_sensi(A) - L_J, erreur = self.Simul.multi_interpole(self.L, self.reponses) - grad = Numeric.dot(Numeric.transpose(A),erreur) - if debug: print 'grad=', grad - return grad + # Si le calcul Aster (et ses derivees) est deja effectue pour val on ne le refait pas + if not ( (self.val == val) and self.A): + self.erreur, self.residu, self.A_nodim, self.A = self.calcul_FG(val) + return NP.dot(NP.transpose(self.A), self.erreur) # ------------------------------------------------------------------------------ - def Creation_Temporaire_Esclave(self): """ Creation du repertoire temporaire d'execution du calcul esclace """ - # Creation du repertoire temporaire tmp_macr_recal = os.getcwd() + os.sep + 'tmp_macr_recal' +# tmp_macr_recal = Random_Tmp_Name( prefix = os.getenv('HOME') + os.sep + 'tmp_macr_recal_' ) try: os.mkdir(tmp_macr_recal) except: pass - if not os.path.exists(tmp_macr_recal): UTMESS('F','RECAL0_34',valk=tmp_macr_recal) + if not os.path.exists(tmp_macr_recal): UTMESS('F','RECAL0_82',valk=tmp_macr_recal) try: os.mkdir(tmp_macr_recal + os.sep + 'REPE_TABLE') except: pass - if not os.path.exists(tmp_macr_recal + os.sep + 'REPE_TABLE'): UTMESS('F','RECAL0_34',valk=tmp_macr_recal + os.sep + 'REPE_TABLE') + if not os.path.exists(tmp_macr_recal + os.sep + 'REPE_TABLE'): UTMESS('F','RECAL0_82',valk=tmp_macr_recal + os.sep + 'REPE_TABLE') return tmp_macr_recal # ------------------------------------------------------------------------------ - def Creation_Fichier_Export_Esclave(self, tmp_macr_recal): """ Creation du fichier .export pour le calcul esclave """ - from as_profil import ASTER_PROFIL + from asrun.profil import ASTER_PROFIL # Recuperation du fichier .export - list_export = glob('*.export') - - if len(list_export) == 0: UTMESS('F','RECAL0_4') - elif len(list_export) >1: UTMESS('F','RECAL0_5') + if self.export: export = self.export + else: + list_export = glob.glob('*.export') + if len(list_export) == 0: UTMESS('F','RECAL0_4') + elif len(list_export) >1: UTMESS('F','RECAL0_5') + export = list_export[0] # On modifie le profil - prof = ASTER_PROFIL(list_export[0]) + prof = ASTER_PROFIL(export) + + # En local + user_mach = '' + + # Chaine user@hostname (pour les calculs distribues et en batch) + try: username = prof.param['username'][0] + except: + try: username = os.getlogin() + except: + import getpass + username = getpass.getuser() + user_mach_dist = "%s@%s:" % ( username, socket.gethostname() ) + + + # On cherche s'il y a un fichier hostfile pour rajouter user@hostname + l_fr = getattr(prof, 'data') + l_tmp = l_fr[:] + for dico in l_tmp: + if dico['type']=='hostfile': + user_mach = user_mach_dist + break + + # En distribue + if self.TEMPS: prof.param['tpsjob'] = str(self.TEMPS) + if self.MEMOIRE: prof.param['memjob'] = str(self.MEMOIRE) + + # En batch et distribue + if self.MODE == 'BATCH': +# user_mach = "%s@%s:" % ( prof.param['username'][0], socket.gethostname() ) + user_mach = user_mach_dist + prof.param['mode'] = 'batch' + if self.mem_aster: prof.param['mem_aster'] = str(self.mem_aster) + + # classe reservee sur la machine Aster + if self.CLASSE: + prof.param['classe'] = self.CLASSE # xterm if prof.param.has_key('xterm'): @@ -791,7 +460,7 @@ class CALCUL_ASTER: l_fr.remove(dico) if lab == 'resu': - dico['path'] = os.path.join(tmp_macr_recal, os.path.basename(dico['path'])) + dico['path'] = user_mach + os.path.join(tmp_macr_recal, os.path.basename(dico['path'])) # fichiers else: @@ -799,7 +468,6 @@ class CALCUL_ASTER: # Nom du fichier .mess (pour recuperation dans REPE_OUT) if dico['ul'] == '6': self.nom_fichier_mess_fils = os.path.basename(dico['path']) -# self.nom_fichier_mess_fils = os.path.join(os.getcwd(), 'fort.%d' % self.UL) # Nom du fichier .resu (pour recuperation dans REPE_OUT) if dico['ul'] == '8': @@ -811,24 +479,34 @@ class CALCUL_ASTER: l_fr.remove(dico) # Fichier d'unite logique UL devient le nouveau .comm - elif dico['ul'] == str(self.UL): + elif dico['ul'] == str(self.UNITE_ESCL): self.fichier_esclave = dico['path'] dico['type'] = 'comm' dico['ul'] = '1' - dico['path'] = os.path.join(os.getcwd(), 'fort.%d' % self.UL) + dico['path'] = user_mach + os.path.join(os.getcwd(), 'fort.%d' % self.UNITE_ESCL) # Tous les autres fichiers en Resultat elif lab == 'resu': - if self.UNITE_GRAPHIQUE and dico['ul'] == str(self.UNITE_GRAPHIQUE): l_fr.remove(dico) - else: - dico['path'] = os.path.join(tmp_macr_recal, os.path.basename(dico['path'])) +# if self.UNITE_GRAPHIQUE and dico['ul'] == str(self.UNITE_GRAPHIQUE): l_fr.remove(dico) +# else: +# dico['path'] = user_mach + os.path.join(tmp_macr_recal, os.path.basename(dico['path'])) + l_fr.remove(dico) # Tous les autres fichiers en Donnees elif lab == 'data': if dico['type'] not in ('exec', 'ele'): if dico['ul'] != '0': # Traite le cas des sources python sourchargees - if self.METHODE !='EXTERNE': - dico['path'] = os.path.join(os.getcwd(), 'fort.%s' % dico['ul']) + # Si distant/distribue on doit prendre les fichiers de donnes dans un endroit partage entre les machines/noeuds + if user_mach: + src = dico['path'] + dst = os.path.join(tmp_macr_recal, os.path.basename(dico['path'])) + try: + shutil.copyfile(src, dst) + dico['path'] = user_mach + os.path.join(tmp_macr_recal, os.path.basename(dico['path'])) + except Exception, e: + print e + else: + dico['path'] = user_mach + os.path.join(os.getcwd(), 'fort.%s' % dico['ul']) # sinon on garde la ligne telle quelle setattr(prof, lab, l_fr) @@ -837,8 +515,7 @@ class CALCUL_ASTER: prof.WriteExportTo(self.new_export) if debug: os.system('cp ' + self.new_export + ' /tmp') + os.system('cp ' + self.new_export + ' /tmp') + #os.system('sleep 500') # --FIN CLASSE ---------------------------------------------------------------------------- - - - diff --git a/Aster/Cata/cataSTA10/Macro/reca_controles.py b/Aster/Cata/cataSTA10/Macro/reca_controles.py index a3c61e1b..af8a861c 100644 --- a/Aster/Cata/cataSTA10/Macro/reca_controles.py +++ b/Aster/Cata/cataSTA10/Macro/reca_controles.py @@ -1,4 +1,4 @@ -#@ MODIF reca_controles Macro DATE 21/09/2009 AUTEUR COURTOIS M.COURTOIS +#@ MODIF reca_controles Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS # -*- coding: iso-8859-1 -*- # RESPONSABLE ASSIRE A.ASSIRE # CONFIGURATION MANAGEMENT OF EDF VERSION @@ -19,11 +19,17 @@ # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -import string, copy, Numeric, types, os, sys, pprint +import string +import copy +import types +import os +import sys +import pprint # Nom de la routine nompro = 'MACR_RECAL' +from Noyau.N_types import is_float, is_str, is_enum #_____________________________________________ @@ -32,7 +38,6 @@ nompro = 'MACR_RECAL' #_____________________________________________ # ------------------------------------------------------------------------------ - def erreur_de_type(code_erreur,X): """ code_erreur ==0 --> X est une liste @@ -43,19 +48,18 @@ def erreur_de_type(code_erreur,X): txt = "" if(code_erreur == 0 ): - if type(X) is not types.ListType: + if not is_enum(X): txt="\nCette entrée: " +str(X)+" n'est pas une liste valide" if(code_erreur == 1 ): - if type(X) is not types.StringType: + if not is_str(X): txt="\nCette entrée: " +str(X)+" n'est pas une chaine de caractère valide ; Veuillez la ressaisir en lui appliquant le type char de python" if(code_erreur == 2 ): - if type(X) is not types.FloatType: + if not is_float(X): txt="\nCette entrée: " +str(X)+" n'est pas une valeur float valide ; Veuillez la ressaisir en lui appliquant le type float de python" return txt # ------------------------------------------------------------------------------ - def erreur_dimension(PARAMETRES,REPONSES): """ On verifie que la dimension de chaque sous_liste de parametre est 4 @@ -73,7 +77,6 @@ def erreur_dimension(PARAMETRES,REPONSES): # ------------------------------------------------------------------------------ - def compare__dim_rep__dim_RESU_EXP(REPONSES,RESU_EXP): """ X et Y sont deux arguments qui doivent avoir la meme dimension @@ -87,7 +90,6 @@ def compare__dim_rep__dim_RESU_EXP(REPONSES,RESU_EXP): # ------------------------------------------------------------------------------ - def compare__dim_poids__dim_RESU_EXP(POIDS,RESU_EXP): """ POIDS et Y sont deux arguments qui doivent avoir la meme dimension @@ -101,7 +103,6 @@ def compare__dim_poids__dim_RESU_EXP(POIDS,RESU_EXP): # ------------------------------------------------------------------------------ - def verif_fichier(UL,PARAMETRES,REPONSES): """ On verifie les occurences des noms des PARAMETRES et REPONSES @@ -126,7 +127,6 @@ def verif_fichier(UL,PARAMETRES,REPONSES): # ------------------------------------------------------------------------------ - def verif_valeurs_des_PARAMETRES(PARAMETRES): """ On verifie que pour chaque PARAMETRES de l'optimisation @@ -163,7 +163,6 @@ def verif_valeurs_des_PARAMETRES(PARAMETRES): # ------------------------------------------------------------------------------ - def verif_UNITE(GRAPHIQUE,UNITE_RESU): """ On vérifie que les unités de résultat et @@ -178,7 +177,6 @@ def verif_UNITE(GRAPHIQUE,UNITE_RESU): # ------------------------------------------------------------------------------ - def gestion(UL,PARAMETRES,REPONSES,RESU_EXP,POIDS,GRAPHIQUE,UNITE_RESU,METHODE): """ Cette methode va utiliser les methodes de cette classe declarée ci-dessus diff --git a/Aster/Cata/cataSTA10/Macro/reca_evol.py b/Aster/Cata/cataSTA10/Macro/reca_evol.py new file mode 100644 index 00000000..775a93cf --- /dev/null +++ b/Aster/Cata/cataSTA10/Macro/reca_evol.py @@ -0,0 +1,165 @@ +#@ MODIF reca_evol Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS + +# 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. +# ====================================================================== +# + +''' +Le programme d'optimisation d'une fonctionelle base sur l'algorithm genetique, +developpement issu du contrat PdM-AMA +''' + +import numpy +import math +import random + + + +def evolutivo(fonc,val,nb_iter,err_min,nb_parents,nb_fils,sigma,borne_inf,borne_sup,graine): + +#initialisation du vecteur des parametres + par_ini=[] +#les valeurs initiales des parametres sont recuperees + for ind in val: + if ind: + par_ini.append(ind) + +#valeur du critere d arret + val_crit=nb_iter + +#initialisation et remplisage du vecteur des parents + Parents_ini=[] + for ind in range(nb_parents): + Parents_ini.append(par_ini) + #P sera le vecteur des parents retourne par la fonction figli + P=[] + erreurs=[] + erreurs_ini=[] + #le premier vecteur d erreurs sera calcule par la fonction errore + #a partir des valeurs initiales des parents + + # On affiche egalement la fenetre MAC pour un appariement manual + fonc.graph_mac=True + err_ini=fonc.calcul_F(par_ini) + #on rempli l'erreur pour chaque parent initial + for ind in range(nb_parents): + erreurs_ini.append(err_ini) + P.append(Parents_ini) + erreurs.append(erreurs_ini[:]) + in_ciclo=True + iter=1 + #ici on demarre la boucle de minimisation de la fonction erreur + while in_ciclo: + if graine != None: random.seed(graine) + F=fils(P[-1],nb_parents,nb_fils,sigma,borne_inf, borne_sup) + + #on fait la selection des meilleurs fils - p + (p,err)=selection(fonc,F,P[-1],erreurs[-1],nb_parents) + + #P est le nouveau jeu de parents + #attention on stocke ici tous l historique des parents et c'est le meme pour les erreurs dans erreurs + P.append(p) + + erreurs.append(err) + #on lance un calcul avec le meilleur jeu de parametres juste pour l'appariement des MAC + fonc.graph_mac=True + err_mac=fonc.calcul_F(P[-1][0]) + if erreurs[-1][0]<=err_min: + in_ciclo=False + iter+=1 + if iter>val_crit: + in_ciclo=False + + return P[-1][0] + + + +def selection(fonc,fils,parents,err_parents,nb_parents): + + """ + Selection des meilleurs fils a chaque iteration + """ + + famille=[] + err=[] + for ind in fils: + fonc.graph_mac=False + err.append(fonc.calcul_F(ind)) + for ind in err_parents: + err.append(ind) + for ind in fils: + famille.append(ind) + for ind in parents: + famille.append(ind) + + ordre=numpy.argsort(err).tolist() + fam_ordonne=[] + err_ordonne=[] + for ind in ordre: + fam_ordonne.append(famille[ind]) + err_ordonne.append(err[ind]) + + return fam_ordonne[0:int(nb_parents)], err_ordonne[0:int(nb_parents)] + + + + +def fils(parents,nb_parents,nb_fils,sigma,borne_inf, borne_sup): + """ + Creation des fils + """ + + F=[] + for ind in range(int(math.floor(nb_fils/nb_parents))): + for ind2 in range(nb_parents): + F.append(genere_fils(parents[ind2],sigma,borne_inf, borne_sup)) +#le dernier parent est le plus prolific car il va completer le nombres de fils +#mais il est aussi le meilleur parent car correspond a l'erreur minimale + for ind2 in range(nb_fils%nb_parents): + F.append(genere_fils(parents[ind2],sigma,borne_inf, borne_sup)) + + return F + +#les fils sont generes ici +def genere_fils(parent,sigma,borne_inf, borne_sup): + + """ + Creation d'un seul fils avec prise en compte des bornes + """ + errate=True + while errate: + errate=False +#F est le vecteur de fils a remplir ici avec la fonction random +#a partir des valeurs du parent courant + F=[] + for ind in parent: + F.append(ind+ind/100.*random.gauss(0,sigma)) +#la variable parametre initialise ici est un index pour defiler les valeurs de F + parametre=0 + for ind in parent: + test1=F[parametre]>=borne_inf[parametre] + test2=F[parametre]<=borne_sup[parametre] + if test1 & test2: + pass + else: + errate=True +# print "parametre hors bornes" + parametre+=1 +# print 'fils genere:',F + return F + diff --git a/Aster/Cata/cataSTA10/Macro/reca_graphique.py b/Aster/Cata/cataSTA10/Macro/reca_graphique.py index c3ce8c88..21d6ce7d 100644 --- a/Aster/Cata/cataSTA10/Macro/reca_graphique.py +++ b/Aster/Cata/cataSTA10/Macro/reca_graphique.py @@ -1,4 +1,4 @@ -#@ MODIF reca_graphique Macro DATE 16/05/2007 AUTEUR ASSIRE A.ASSIRE +#@ MODIF reca_graphique Macro DATE 22/04/2010 AUTEUR ASSIRE A.ASSIRE # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -21,7 +21,6 @@ import string, copy, Numeric, types import Cata from Cata.cata import DEFI_FICHIER, IMPR_FONCTION -from Utilitai.Utmess import UTMESS from Accas import _F try: diff --git a/Aster/Cata/cataSTA10/Macro/reca_interp.py b/Aster/Cata/cataSTA10/Macro/reca_interp.py index 5b14f4eb..dfada4ec 100644 --- a/Aster/Cata/cataSTA10/Macro/reca_interp.py +++ b/Aster/Cata/cataSTA10/Macro/reca_interp.py @@ -1,4 +1,4 @@ -#@ MODIF reca_interp Macro DATE 21/09/2009 AUTEUR COURTOIS M.COURTOIS +#@ MODIF reca_interp Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS # -*- coding: iso-8859-1 -*- # RESPONSABLE ASSIRE A.ASSIRE # CONFIGURATION MANAGEMENT OF EDF VERSION @@ -19,18 +19,15 @@ # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -import os, sys, pprint -import Numeric -from Utilitai.Utmess import UTMESS +import os +import numpy as NP -try: import Macro -except: pass +from Utilitai.Utmess import UTMESS #=========================================================================================== - -# INTERPOLATION, CALCUL DE SENSIBILITE, ETC.... +# INTERPOLATION, ETC.... #-------------------------------------- class Sim_exp : @@ -39,8 +36,7 @@ class Sim_exp : self.resu_exp = result_exp self.poids = poids -# ------------------------------------------------------------------------------ - + # ------------------------------------------------------------------------------ def InterpolationLineaire (self, x0, points) : """ Interpolation Lineaire de x0 sur la fonction discrétisée yi=points(xi) i=1,..,n @@ -52,7 +48,7 @@ class Sim_exp : n = len(points) if ( x0 < points[0][0] ) or ( x0 > points[n-1][0] ) : - UTMESS('F','RECAL0_35', valk=(str(x0), str(points[0][0]), str(points[n-1][0]))) + UTMESS('F','RECAL0_48', valk=(str(x0), str(points[0][0]), str(points[n-1][0]))) i = 1 while x0 > points[i][0]: @@ -65,8 +61,7 @@ class Sim_exp : -# ------------------------------------------------------------------------------ - + # ------------------------------------------------------------------------------ def DistVertAdimPointLigneBrisee (self, M, points) : """ Distance verticale d'un point M à une ligne brisée composée de n points @@ -89,34 +84,31 @@ class Sim_exp : return d -# ------------------------------------------------------------------------------ - + # ------------------------------------------------------------------------------ def _Interpole(self, F_calc,experience,poids) : #ici on passe en argument "une" experience """ La Fonction Interpole interpole une et une seule F_calc sur F_exp et renvoie l'erreur seulement """ - n = 0 resu_num = F_calc n_exp = len(experience) # nombre de points sur la courbe expérimentale num.i - stockage = Numeric.ones(n_exp, Numeric.Float) # matrice de stockage des erreurs en chaque point + stockage = NP.ones(n_exp) # matrice de stockage des erreurs en chaque point for j in xrange(n_exp) : d = self.DistVertAdimPointLigneBrisee(experience[j], resu_num) - try: + if NP.all(experience[j][1] != 0.): stockage[n] = d/experience[j][1] - except ZeroDivisionError: + else: stockage[n] = d n = n + 1 # on totalise le nombre de points valables - err = Numeric.ones(n, Numeric.Float) + err = NP.ones(n, dtype=float) for i in xrange(n) : err[i] = poids*stockage[i] return err -# ------------------------------------------------------------------------------ - + # ------------------------------------------------------------------------------ def multi_interpole(self, L_F, reponses): """ Cette fonction appelle la fonction interpole et retourne les sous-fonctionnelles J et l'erreur. @@ -124,31 +116,29 @@ class Sim_exp : """ L_erreur=[] - for i in range(len(reponses)): + for i in range(len(reponses)): err = self._Interpole(L_F[i],self.resu_exp[i],self.poids[i]) L_erreur.append(err) -# print "L_erreur=", L_erreur - # On transforme L_erreur en tab num dim=[] J=[] for i in range(len(L_erreur)): dim.append(len(L_erreur[i])) - dim_totale = Numeric.sum(dim) + dim_totale = NP.sum(dim) L_J = self.calcul_J(L_erreur) a=0 - erreur = Numeric.zeros((dim_totale),Numeric.Float) + erreur = NP.zeros((dim_totale)) for n in range(len(L_erreur)): for i in range(dim[n]): erreur[i+a] = L_erreur[n][i] a = dim[n] del(L_erreur) #on vide la liste puisqu'on n'en a plus besoin - return L_J,erreur + return L_J,erreur -# ------------------------------------------------------------------------------ + # ------------------------------------------------------------------------------ def multi_interpole_sensib(self, L_F, reponses): """ Cette fonction retourne seulement l'erreur, elle est appelée dans la methode sensibilité. @@ -163,9 +153,8 @@ class Sim_exp : return L_erreur -# ------------------------------------------------------------------------------ - - def calcul_J(self,L_erreur): + # ------------------------------------------------------------------------------ + def calcul_J(self, L_erreur): L_J = [] for i in range(len(L_erreur)): total = 0 @@ -175,139 +164,23 @@ class Sim_exp : return L_J -# ------------------------------------------------------------------------------ - - def norme_J(self,L_J_init,L_J,unite_resu=None): + # ------------------------------------------------------------------------------ + def norme_J(self, L_J_init, L_J, unite_resu=None): """ Cette fonction calcul une valeur normée de J """ for i in range(len(L_J)): - try: + if NP.all(L_J_init[i] != 0.): L_J[i] = L_J[i]/L_J_init[i] - except ZeroDivisionError: + else: if unite_resu: fic=open(os.getcwd()+'/fort.'+str(unite_resu),'a') fic.write(message) fic.close() - UTMESS('F', "RECAL0_36", valr=L_J_init) + UTMESS('F', "RECAL0_44", valr=L_J_init) return - J = Numeric.sum(L_J) + J = NP.sum(L_J) J = J/len(L_J) return J - -# ------------------------------------------------------------------------------ - -# def sensibilite(self,objet,UL,F,L_deriv_sensible,val,para,reponses,pas,unite_resu,LIST_SENSI=[],LIST_DERIV=[],INFO=1): - - def sensibilite(self, CALCUL_ASTER, F, L_deriv_sensible, val, pas): - - # CALCUL_ASTER est l'objet regroupant le calcul de F et des derivées, ainsi que les options - UL = CALCUL_ASTER.UL - para = CALCUL_ASTER.para - reponses = CALCUL_ASTER.reponses - unite_resu = CALCUL_ASTER.UNITE_RESU - LIST_SENSI = CALCUL_ASTER.LIST_SENSI - LIST_DERIV = CALCUL_ASTER.LIST_DERIV - INFO = CALCUL_ASTER.INFO - - - - # Erreur de l'interpolation de F_interp : valeur de F interpolée sur les valeurs experimentales - F_interp = self.multi_interpole_sensib(F, reponses) #F_interp est une liste contenant des tab num des reponses interpolés - - # Creation de la liste des matrices de sensibilités - L_A=[] - for i in range(len(reponses)): - L_A.append(Numeric.zeros((len(self.resu_exp[i]),len(val)),Numeric.Float) ) - - for k in range(len(val)): # pour une colone de A (dim = nb parametres) - - # On utilise les differences finies pour calculer la sensibilité - # -------------------------------------------------------------- - # Dans ce cas, un premier calcul_Aster pour val[k] a deja ete effectué, on effectue un autre calcul_Aster pour val[k]+h - - if para[k] not in LIST_SENSI: - - # Message - if INFO>=2: UTMESS('I','RECAL0_37',valk=para[k]) - - fic=open(os.getcwd()+'/fort.'+str(unite_resu),'a') - fic.write('\nCalcul de la sensibilité par differences finies pour : '+para[k]) - fic.close() - - # Perturbation - h = val[k]*pas - val[k] = val[k] + h - - # Calcul_Aster pour la valeur perturbée - F_perturbe, L_deriv = CALCUL_ASTER.calcul_Aster(val) - - # Erreur de l'interpolation de F_perturb : valeur de F (perturbée) interpolée sur les valeurs experimentales - F_perturbe_interp =self.multi_interpole_sensib(F_perturbe, reponses) - - # On replace les parametres a leurs valeurs initiales - val[k] = val[k] - h - - # Calcul de L_A (matrice sensibilité des erreurs sur F interpolée) - for j in range(len(reponses)): - for i in range(len(self.resu_exp[j])): - try: - L_A[j][i,k] = -1*(F_interp[j][i] - F_perturbe_interp[j][i])/h - except ZeroDivisionError: - fic=open(os.getcwd()+'/fort.'+str(unite_resu),'a') - fic.write('\n Probleme de division par zéro dans le calcul de la matrice de sensiblité') - fic.write('\n Le parametre '+para[k]+'est nul ou plus petit que la précision machine') - fic.close() - UTMESS('F','RECAL0_38',valk=para[k]) - return - - - # On utilise le calcul de SENSIBILITE - # -------------------------------------------------------------- - # Dans ce cas, L_deriv_sensible a deja ete calculé pour le premier calcul pour val[k], aucun autre calcul_F n'est a lancer - else: - if INFO>=2: UTMESS('I','RECAL0_39',valk=para[k]) - - # Message - fic=open(os.getcwd()+'/fort.'+str(unite_resu),'a') - fic.write('\nCalcul de la sensibilité par la SENSIBILITE pour : '+para[k]) - fic.close() - - L_deriv_sensible_interp = L_deriv_sensible - - # Calcul de L_A (matrice sensibilité des erreurs sur F interpolée) - for j in range(len(reponses)): - for i in range(len(self.resu_exp[j])): - - # On interpole la fonction derivée aux points experimentaux - val_derivee_interpolee = self.InterpolationLineaire( self.resu_exp[j][i][0], L_deriv_sensible_interp[ para[k] ][:][j] ) - - # Application du poids de la reponse courante j - val_derivee_interpolee = val_derivee_interpolee*self.poids[j] - - try: - L_A[j][i,k] = -1.* ( val_derivee_interpolee ) / self.resu_exp[j][i][1] - except ZeroDivisionError: - L_A[j][i,k] = -1.* ( val_derivee_interpolee ) - - # fin - # -------------------------------------------------------------- - - # On construit la matrice de sensiblité sous forme d'un tab num - dim =[] - for i in range(len(L_A)): - dim.append(len(L_A[i])) - dim_totale = Numeric.sum(dim) - a=0 - A = Numeric.zeros((dim_totale,len(val)),Numeric.Float) - for n in range(len(L_A)): - for k in range(len(val)): - for i in range(dim[n]): - A[i+a][k] = L_A[n][i,k] - a=dim[n] - - del(L_A) # On ecrase tout ce qu'il y a dans L_A puisqu'on n'en a plus besoin - - return A diff --git a/Aster/Cata/cataSTA10/Macro/reca_mac.py b/Aster/Cata/cataSTA10/Macro/reca_mac.py new file mode 100644 index 00000000..f7bf786f --- /dev/null +++ b/Aster/Cata/cataSTA10/Macro/reca_mac.py @@ -0,0 +1,129 @@ +#@ MODIF reca_mac Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS + +# 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. +# ====================================================================== +''' +On regroupe ici les fonctions Python necessaires au lancement +de la fenetre graphique d'appariement manuel des MAC pour le +recalage en dynamique +''' +import numpy as NP + +from Tkinter import Tk, Frame, StringVar, Entry, Label, Button +from Meidee.modes import MacWindowFrame + +def extract_mac_array( mac_mode ): + + data1 = mac_mode.EXTR_TABLE().Array('NUME_MODE_1','MAC') + data2 = mac_mode.EXTR_TABLE().Array('NUME_MODE_2','MAC') + + N = int(NP.maximum.reduce(data1[:,0])) + M = int(NP.maximum.reduce(data2[:,0])) + mac = NP.zeros( (N,M) ) + for i in range(data1.shape[0]): + i1 = int(data1[i,0])-1 + i2 = int(data2[i,0])-1 + mac[ i1, i2 ] = data1[i,1] + return mac + + +def get_modes(resu): + + afreq = resu.LIST_PARA()['FREQ'] + + return afreq + + +class fenetre_mac: + + def __init__(self,resu1,resu2,mac): + self.resu1 = resu1 + self.resu2 = resu2 + self.mac = mac + self.root = Tk() + + nom1 = resu1.nom + nom2 = resu2.nom + titre = "MAC pour la base " + nom1 + " et " + nom2 + size = (20,300) + + # la fenetre de MAC + mac_win = MacWindowFrame( self.root, titre, nom1, nom2, size) + mac_win.grid(row=0,column=0) + + self.freq1 = get_modes(resu1) + self.freq2 = get_modes(resu2) + # la variable NUMERIQUE qui contient ces memes listes. On remplit + # ces valeurs quand on ferme la fenetre + self.l1 = None + self.l2 = None + # la variable GRAPHIQUE qui donne le contenu des listes + self.var_l1 = StringVar() + self.var_l2 = StringVar() + + mac_win.set_modes(self.freq1,self.freq2,self.mac) + + # Une deuxieme fentre, dans laquelle on peut modifier l'appariement des modes + f = Frame(self.root) + f.grid(row=1, column=0,sticky='news') + f.columnconfigure(0,weight=1) + f.columnconfigure(1,weight=4) + + Label(f,text="Liste de mode 1").grid(row=0,column=0,sticky='e') + l1 = Entry(f, textvariable=self.var_l1 ) + l1.grid(row=0,column=1,sticky='ew')#,columnspan=3) + Label(f,text="Liste de mode 2").grid(row=1,column=0,sticky='e') + l2 = Entry(f, textvariable=self.var_l2 ) + l2.grid(row=1,column=1,sticky='ew')#,columnspan=3) + close = Button(f,text='Fermer',command=self.close_win) + + close.grid(row=2,column=1,sticky='e') + + self.set_default_pair() + + self.root.mainloop() + + def get_pair(self): + """rend une double liste donnant les appariements de modes""" + return [self.var_l1.get(),self.var_l2.get()] + + def set_pair(self,liste): + """affiche une liste d'appariement donnee""" + self.var_l1.set(liste[0]) + self.var_l2.set(liste[1]) + + def set_default_pair(self): + """ affiche la liste d'appariement par defaut. Le nombre de modes + correspond au plus petit nombre de modes entre resu1 et resu2""" + nb_mod = min(len(self.freq1),len(self.freq2)) + self.var_l1.set(range(1,nb_mod+1)) + self.var_l2.set(range(1,nb_mod+1)) + + def close_win(self): + self.l1 = self.var_l1.get() + self.l2 = self.var_l2.get() + self.root.quit() + + + def get_list(self): + exec('l1='+self.l1) + exec('l2='+self.l2) + return l1,l2 + + + diff --git a/Aster/Cata/cataSTA10/Macro/reca_message.py b/Aster/Cata/cataSTA10/Macro/reca_message.py index 49e05cce..4c362ef3 100644 --- a/Aster/Cata/cataSTA10/Macro/reca_message.py +++ b/Aster/Cata/cataSTA10/Macro/reca_message.py @@ -1,4 +1,4 @@ -#@ MODIF reca_message Macro DATE 21/09/2009 AUTEUR COURTOIS M.COURTOIS +#@ MODIF reca_message Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS # -*- coding: iso-8859-1 -*- # RESPONSABLE ASSIRE A.ASSIRE # CONFIGURATION MANAGEMENT OF EDF VERSION @@ -19,150 +19,131 @@ # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -import os, Numeric - +import os +import numpy as NP +from Utilitai.Utmess import UTMESS, MessageLog +from recal import Affiche_Param #=========================================================================================== # AFFICHAGE DES MESSAGES class Message : - """classe gérant l'affichage des messages concernant le déroulement de l'optmisation """ - #Constructeur de la classe - -# ------------------------------------------------------------------------------ + """ + classe gérant l'affichage des messages concernant le déroulement de l'optmisation + """ + # ------------------------------------------------------------------------------ def __init__(self,para,val_init,resu_exp,ul_out): self.nom_para = para self.resu_exp = resu_exp self.val_init = val_init self.resu_exp = resu_exp - self.ul_out = ul_out + self.ul_out = ul_out -# ------------------------------------------------------------------------------ + + # ------------------------------------------------------------------------------ def get_filename(self): return os.getcwd()+'/fort.'+str(self.ul_out) + # ------------------------------------------------------------------------------ def initialise(self): - res=open(self.get_filename(), 'w') - res.close() - - txt = ' MACR_RECAL\n\n' - self.ecrire(txt) - -# ------------------------------------------------------------------------------ - - def ecrire(self,txt): - res=open(self.get_filename(), 'a') - res.write(txt+'\n') - res.flush() - res.close() + """ Initialisation du fichier """ + UTMESS('I','RECAL0_1', cc=self.get_filename()) -# ------------------------------------------------------------------------------ - + # ------------------------------------------------------------------------------ def affiche_valeurs(self,val): + """ Affichage de la valeur des parametres """ + txt = Affiche_Param(self.nom_para, val) + UTMESS('I','RECAL0_32', valk=txt, cc=self.get_filename()) - txt = '\n=> Paramètres = ' - for i in range(len(val)): - txt += '\n '+ self.nom_para[i]+' = '+str(val[i]) - self.ecrire(txt) -# ------------------------------------------------------------------------------ - + # ------------------------------------------------------------------------------ def affiche_fonctionnelle(self,J): - - txt = '\n=> Fonctionnelle = '+str(J) - self.ecrire(txt) - -# ------------------------------------------------------------------------------ - - def affiche_result_iter(self,iter,J,val,residu,Act=[],): - - txt = '\n=======================================================\n' - txt += 'Iteration '+str(iter)+' :\n' - txt += '\n=> Fonctionnelle = '+str(J) - txt += '\n=> Résidu = '+str(residu) - - self.ecrire(txt) - - txt = '' + """ Affichage de la fonctionnelle """ + UTMESS('I','RECAL0_33', valr=J, cc=self.get_filename()) + + + # ------------------------------------------------------------------------------ + def affiche_result_iter(self, iter, J, val, residu, Act=[], ecart_para=None, ecart_fonc=None): + """ Affichage du message recapitulatif de l'iteration + """ + UTMESS('I','RECAL0_30') + UTMESS('I','RECAL0_79', cc=self.get_filename()) + UTMESS('I','RECAL0_31', vali=iter, cc=self.get_filename()) + self.affiche_fonctionnelle(J) + UTMESS('I','RECAL0_34', valr=residu, cc=self.get_filename()) + if ecart_para: UTMESS('I','RECAL0_37', valr=ecart_para, cc=self.get_filename()) + if ecart_fonc: UTMESS('I','RECAL0_38', valr=ecart_fonc, cc=self.get_filename()) + + # Affichage des parametres self.affiche_valeurs(val) + # Si les parametres sont en butee if (len(Act)!=0): + lpara = ' '.join([self.nom_para[i] for i in Act]) if (len(Act)==1): - txt += '\n\n Le paramètre ' + UTMESS('I','RECAL0_46', valk=lpara, cc=self.get_filename()) else: - txt += '\n\n Les paramètres ' - for i in Act: - txt += self.nom_para[i]+' ' - if (len(Act)==1): - txt += '\n est en butée sur un bord de leur domaine admissible.' - else: - txt += '\n sont en butée sur un bord de leur domaine admissible.' - txt += '\n=======================================================\n\n' - self.ecrire(txt) + UTMESS('I','RECAL0_47', valk=lpara, cc=self.get_filename()) + UTMESS('I','RECAL0_80', cc=self.get_filename()) -# ------------------------------------------------------------------------------ + # ------------------------------------------------------------------------------ def affiche_etat_final_convergence(self,iter,max_iter,iter_fonc,max_iter_fonc,prec,residu,Act=[]): - - txt = '' - if ((iter <= max_iter) or (residu <= prec) or (iter_fonc <= max_iter_fonc) ): - txt += '\n=======================================================\n' - txt += ' CONVERGENCE ATTEINTE ' - if (len(Act)!=0): - txt += "\n\n ATTENTION : L'OPTIMUM EST ATTEINT AVEC " - txt += "\n DES PARAMETRES EN BUTEE SUR LE BORD " - txt += "\n DU DOMAINE ADMISSIBLE " - txt += '\n=======================================================\n' + """ Affichage du message recapitulatif a la fin du processus d'optimisation + """ + if ((iter < max_iter) and (residu <= prec) and (iter_fonc < max_iter_fonc) ): + UTMESS('I','RECAL0_56', cc=self.get_filename()) + if (len(Act)!=0): UTMESS('I','RECAL0_58', cc=self.get_filename()) else: - txt += "\n=======================================================\n" - txt += ' CONVERGENCE NON ATTEINTE ' - if (iter > max_iter): - txt += "\n Le nombre maximal d'itération ("+str(max_iter)+") a été dépassé" - if (iter_fonc > max_iter_fonc): - txt += "\n Le nombre maximal d'evaluation de la fonction ("+str(max_iter_fonc)+") a été dépassé" - txt += '\n=======================================================\n' - self.ecrire(txt) + UTMESS('I','RECAL0_57', cc=self.get_filename()) + if (iter >= max_iter): UTMESS('I','RECAL0_55', cc=self.get_filename()) + if (iter_fonc >= max_iter_fonc): UTMESS('I','RECAL0_54', cc=self.get_filename()) + UTMESS('I','RECAL0_80', cc=self.get_filename()) -# ------------------------------------------------------------------------------ + # ------------------------------------------------------------------------------ def affiche_calcul_etat_final(self,para,Hessien,valeurs_propres,vecteurs_propres,sensible,insensible): - - txt = '\n\nValeurs propres du Hessien:\n' - txt += str( valeurs_propres) - txt += '\n\nVecteurs propres associés:\n' - txt += str( vecteurs_propres) - txt += '\n\n --------' - txt += '\n\nOn peut en déduire que :' - # Paramètres sensibles - if (len(sensible)!=0): - txt += '\n\nLes combinaisons suivantes de paramètres sont prépondérantes pour votre calcul :\n' - k=0 - for i in sensible: - k=k+1 - colonne=vecteurs_propres[:,i] - numero=Numeric.nonzero(Numeric.greater(abs(colonne/max(abs(colonne))),1.E-1)) - txt += '\n '+str(k)+') ' - for j in numero: - txt += '%+3.1E ' %colonne[j]+'* '+para[j]+' ' - txt += '\n associée à la valeur propre %3.1E \n' %valeurs_propres[i] - # Paramètres insensibles - if (len(insensible)!=0): - txt += '\n\nLes combinaisons suivantes de paramètres sont insensibles pour votre calcul :\n' - k=0 - for i in insensible: - k=k+1 - colonne=vecteurs_propres[:,i] - numero=Numeric.nonzero(Numeric.greater(abs(colonne/max(abs(colonne))),1.E-1)) - txt += '\n '+str(k)+') ' - for j in numero: - txt += '%+3.1E ' %colonne[j]+'* '+para[j]+' ' - txt += '\n associée à la valeur propre %3.1E \n' %valeurs_propres[i] - - self.ecrire(txt) + """ Affichage des informations de l'optimisation (valeurs propres, vecteurs propres, etc.) + """ + UTMESS('I','RECAL0_60', valk=str(valeurs_propres), cc=self.get_filename()) + UTMESS('I','RECAL0_61', valk=str(vecteurs_propres), cc=self.get_filename()) + UTMESS('I','RECAL0_62', cc=self.get_filename()) + + if (len(sensible)!=0 or len(insensible)!=0): + UTMESS('I','RECAL0_63', cc=self.get_filename()) + + # Parametres sensibles + if (len(sensible)!=0): + UTMESS('I','RECAL0_64', cc=self.get_filename()) + k=0 + for i in sensible: + k=k+1 + colonne=vecteurs_propres[:,i] + numero=NP.nonzero(NP.greater(abs(colonne/max(abs(colonne))),1.E-1))[0] + txt = '\n '+str(k)+') ' + for j in numero: + txt += '%+3.1E ' %colonne[j]+'* '+para[j]+' ' + UTMESS('I','RECAL0_65', valk=(txt, str(valeurs_propres[i])), cc=self.get_filename()) + + # Parametres insensibles + if (len(insensible)!=0): + UTMESS('I','RECAL0_66', cc=self.get_filename()) + k=0 + for i in insensible: + k=k+1 + colonne=vecteurs_propres[:,i] + numero=NP.nonzero(NP.greater(abs(colonne/max(abs(colonne))),1.E-1))[0] + txt = '\n '+str(k)+') ' + for j in numero: + txt += '%+3.1E ' %colonne[j]+'* '+para[j]+' ' + UTMESS('I','RECAL0_65', valk=(txt, str(valeurs_propres[i])), cc=self.get_filename()) + + if (len(sensible)!=0 or len(insensible)!=0): + UTMESS('I','RECAL0_62', cc=self.get_filename()) diff --git a/Aster/Cata/cataSTA10/Macro/reca_utilitaires.py b/Aster/Cata/cataSTA10/Macro/reca_utilitaires.py index c44e6961..c0b6a23d 100644 --- a/Aster/Cata/cataSTA10/Macro/reca_utilitaires.py +++ b/Aster/Cata/cataSTA10/Macro/reca_utilitaires.py @@ -1,4 +1,4 @@ -#@ MODIF reca_utilitaires Macro DATE 13/10/2009 AUTEUR COURTOIS M.COURTOIS +#@ MODIF reca_utilitaires Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS # -*- coding: iso-8859-1 -*- # RESPONSABLE ASSIRE A.ASSIRE # CONFIGURATION MANAGEMENT OF EDF VERSION @@ -19,8 +19,14 @@ # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -import Numeric, LinearAlgebra, copy, os, string, types, sys, glob -from Numeric import take +import copy +import os +import string +import types +import sys +import glob + +import numpy as NP try: import Gnuplot except: pass @@ -46,13 +52,13 @@ except: def transforme_list_Num(parametres,res_exp): """ - Transforme les données entrées par l'utilisateur en tableau Numeric + Transforme les données entrées par l'utilisateur en tableau numpy """ dim_para = len(parametres) #donne le nb de parametres - val_para = Numeric.zeros(dim_para,Numeric.Float) - borne_inf = Numeric.zeros(dim_para,Numeric.Float) - borne_sup = Numeric.zeros(dim_para,Numeric.Float) + val_para = NP.zeros(dim_para) + borne_inf = NP.zeros(dim_para) + borne_sup = NP.zeros(dim_para) para = [] for i in range(dim_para): para.append(parametres[i][0]) @@ -93,10 +99,16 @@ def detr_concepts(self): # ------------------------------------------------------------------------------ - - - - +def Random_Tmp_Name(prefix=None): + crit = False + while crit == False: + nombre = int(random.random()*10000000) + if prefix: fic = prefix + str(nombre) + else: + if os.environ.has_key('TEMP'): fic = os.path.join( os.environ['TEMP'], 'file%s' % str(nombre) ) + else: fic = '/tmp/file' + str(nombre) + if not os.path.isfile(fic): crit = True + return fic @@ -107,7 +119,6 @@ def detr_concepts(self): #_____________________________________________ -#def temps_CPU(self,restant_old,temps_iter_old): def temps_CPU(restant_old,temps_iter_old): """ Fonction controlant le temps CPU restant @@ -134,7 +145,7 @@ def temps_CPU(restant_old,temps_iter_old): temps_iter=(temps_iter_old + (restant_old-restant))/2. if ((temps_iter>0.96*restant)or(restant<0.)): err=1 - msg = MessageLog.GetText('F', 'RECAL0_40') + msg = MessageLog.GetText('F', 'RECAL0_53') raise CPU_Exception, msg return restant,temps_iter,err diff --git a/Aster/Cata/cataSTA10/Macro/recal.py b/Aster/Cata/cataSTA10/Macro/recal.py index d582a572..a4a03926 100644 --- a/Aster/Cata/cataSTA10/Macro/recal.py +++ b/Aster/Cata/cataSTA10/Macro/recal.py @@ -1,4 +1,4 @@ -#@ MODIF recal Macro DATE 06/07/2009 AUTEUR COURTOIS M.COURTOIS +#@ MODIF recal Macro DATE 26/05/2010 AUTEUR ASSIRE A.ASSIRE # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -19,340 +19,1469 @@ # ====================================================================== +#___________________________________________________________________________ +# +# MODULE DE CALCUL DISTRIBUE POUR MACR_RECAL +# +# Utilisable en mode EXTERNE, voir les flags avec "python recal.py -h" +#___________________________________________________________________________ -import string, copy, Numeric, types -import Cata -from Cata.cata import INCLUDE, DETRUIRE +import os +import sys +import shutil +import tempfile +import glob +import math +import copy +import re +import platform +from math import log10 +import numpy as NP -#_____________________________________________ -# -# DIVERS UTILITAIRES POUR LA MACRO -#_____________________________________________ - - -# Transforme les données entrées par l'utilisateur en tableau Numeric -def transforme_list_Num(parametres,res_exp): - dim_para = len(parametres) #donne le nb de parametres - val_para = Numeric.zeros(dim_para,Numeric.Float) - borne_inf = Numeric.zeros(dim_para,Numeric.Float) - borne_sup = Numeric.zeros(dim_para,Numeric.Float) - para = [] - for i in range(dim_para): - para.append(parametres[i][0]) - val_para[i] = parametres[i][1] - borne_inf[i] = parametres[i][2] - borne_sup[i] = parametres[i][3] - return para,val_para,borne_inf,borne_sup +# Importation de commandes Aster +try: + import aster + import Macro + from Accas import _F + from Cata import cata + from Cata.cata import * +except ImportError: + pass + +include_pattern = "# -->INCLUDE<--" +debug = False + +# ------------------------------------------------------------------------------- +# ------------------------------------------------------------------------------- +def get_absolute_path(path): + """Retourne le chemin absolu en suivant les liens éventuels. + """ + if os.path.islink(path): + path = os.path.realpath(path) + res = os.path.normpath(os.path.abspath(path)) + return res + +# ------------------------------------------------------------------------------- +#if os.environ.has_key('bibpytdir'): sys.path.append( os.environ['bibpytdir'] ) + +# recupere "bibpyt" à partir de "bibpyt/Macro/recal.py" +sys.path.append(get_absolute_path(os.path.join(sys.argv[0], '..', '..'))) + +try: + from Utilitai.Utmess import UTMESS +except: + def UTMESS(code='I', txt='',valk='', vali='', valr=''): + print txt, valk, vali, valr + if code=='F': sys.exit() + + +# # ------------------------------------------------------------------------------- +# def find_parameter(content, param): +# """ +# Return the lowest index in content where param is found and +# the index of the end of the command. +# """ +# pos, endpos = -1, -1 +# re_start = re.compile('^ *%s *\=' % re.escape(param), re.M) +# mat_start = re_start.search(content) +# if mat_start is not None: +# pos = mat_start.start() +# endpos = search_enclosed(content, pos) +# return pos, endpos + + + +# ------------------------------------------------------------------------------- +def find_parameter(content, param): + """ + Supprime les parametres du fichier de commande + """ + re_start = re.compile('^ *%s *\=' % re.escape(param), re.M) + l=[] + for line in content.split('\n'): + mat_start = re_start.search(line) + if mat_start is None: l.append(line) + return '\n'.join(l) + + +# ------------------------------------------------------------------------------- +def Affiche_Param(para, val): + """Affiche les parametres + """ + t = [] + for p, v in zip(para, val): + t.append( " %s : %s" % ( p.ljust(9), v) ) + return '\n'.join(t) + + +# ------------------------------------------------------------------------------- +def make_include_files(UNITE_INCLUDE, calcul, parametres): + """ Module permettant de generer les fichiers a inclure (mode INCLUSION) + """ + +# # Importation de commandes Aster +# try: +# import aster +# import Macro +# from Accas import _F +# from Cata.cata import * +# except ImportError: +# raise "Le mode INCLUSION doit etre lance depuis Aster" + + try: + ASTER_ROOT = os.path.join(aster.repout, '..') + sys.path.append(os.path.join(ASTER_ROOT, 'ASTK', 'ASTK_SERV', 'lib')) + sys.path.append(os.path.join(ASTER_ROOT, 'lib', 'python%s.%s' % (sys.version_info[0], sys.version_info[1] ) , 'site-packages')) + except: pass + try: + from asrun.utils import find_command, search_enclosed + except Exception, e: + print e + UTMESS('F','RECAL0_99') + + + # ---------------------------------------------------------------------------- + # Preparation des fichiers + # ---------------------------------------------------------------------------- + liste_reponses = [] + for reponse in [ x[0] for x in calcul ]: + if not reponse in liste_reponses: liste_reponses.append(reponse) + + try: + old = "fort.%s" % UNITE_INCLUDE + pre = "fort.%s.pre" % UNITE_INCLUDE + new = "fort.%s.new" % UNITE_INCLUDE + + # Lecture du fichier + f=open(old, 'r') + newtxt = f.read() + f.close() + + # On retire la commande DEBUT + pos, endpos = find_command(newtxt, "DEBUT") + if endpos!=-1: newtxt = newtxt[endpos+1:] + if newtxt[0]==';': newtxt = newtxt[1:] # Bug dans find_command si la commande se termine par un ";" + + # On retire les parametres + list_params = [x[0] for x in parametres] + for param in list_params: + newtxt = find_parameter(newtxt, param) + + # Isole la partie a inclure si elle est specifiee + n = newtxt.find(include_pattern) + pretxt = None + if n!=-1: + pretxt = newtxt[:n] + pretxt = "# -*- coding: iso-8859-1 -*-\n" + pretxt + # Ecriture du nouveau fichier + fw=open(pre, 'w') + fw.write(pretxt) + fw.close() + newtxt = newtxt[n+len(include_pattern):] + + # Retire la commande FIN + pos, endpos = find_command(newtxt, "FIN") + if pos!=-1: newtxt = newtxt[:pos] + + # Ajoute un global pour ramener les courbes dans l'espace Aster + newtxt = "global %s\n" % ','.join(liste_reponses) + newtxt + + # Ajoute un encodage pour eviter les erreurs dues aux accents (ssna110a par exemple) + newtxt = "# -*- coding: iso-8859-1 -*-\n" + newtxt + + # Ecriture du nouveau fichier + fw=open(new, 'w') + fw.write(newtxt) + fw.close() + except Exception, e: + raise e + + return + + +# ------------------------------------------------------------------------------- def mes_concepts(list_concepts=[],base=None): - # Fonction qui liste les concepts créés + """ Fonction qui liste les concepts créés """ for e in base.etapes: if e.nom in ('INCLUDE','MACR_RECAL',) : - list_concepts=list(mes_concepts(list_concepts=list_concepts,base=e)) + list_concepts=list(mes_concepts(list_concepts=list_concepts,base=e)) elif (e.sd != None) and (e.parent.nom=='INCLUDE') : - nom_concept=e.sd.get_name() - if not(nom_concept in list_concepts): - list_concepts.append( nom_concept ) + nom_concept=e.sd.get_name() + if not(nom_concept in list_concepts): + list_concepts.append( nom_concept ) return tuple(list_concepts) +# ------------------------------------------------------------------------------- def detr_concepts(self): liste_concepts=mes_concepts(base=self.parent) for e in liste_concepts: nom = string.strip(e) - DETRUIRE( OBJET =self.g_context['_F'](CHAINE = nom),INFO=1) + DETRUIRE( OBJET =self.g_context['_F'](CHAINE = nom), INFO=2) if self.jdc.g_context.has_key(nom) : del self.jdc.g_context[nom] del(liste_concepts) -def calcul_F(self,UL,para,val,reponses): - fic = open('fort.'+str(UL),'r') - #On stocke le contenu de fort.UL dans la variable fichier qui est un string - fichier=fic.read() - #On stocke le contenu initial de fort.UL dans la variable fichiersauv - fichiersauv=copy.copy(fichier) - fic.close() - - #Fichier_Resu est une liste ou l'on va stocker le fichier modifié - #idée générale :on délimite des 'blocs' dans fichier - #on modifie ou non ces blocs suivant les besoins - #on ajoute ces blocs dans la liste Fichier_Resu - Fichier_Resu=[] - - try: - #cherche l'indice de DEBUT() - index_deb=string.index(fichier,'DEBUT(') - while( fichier[index_deb]!='\n'): - index_deb=index_deb+1 - #on restreind fichier en enlevant 'DEBUT();' - fichier = fichier[index_deb+1:] - except : - #on va dans l'except si on a modifié le fichier au moins une fois - pass - +# ------------------------------------------------------------------------------- +def get_tables(tables_calc, tmp_repe_table, prof): + """ Recupere les resultats Aster (Table Aster -> numpy) + """ + assert (tables_calc is not None) + assert (tmp_repe_table is not None) + + # Import du module lire_table + if os.environ.has_key('ASTER_ROOT'): + version = prof['version'][0] + bibpyt = os.path.join(os.environ['ASTER_ROOT'], version, 'bibpyt') + sys.path.append(bibpyt) + for mdl in glob.glob(os.path.join(bibpyt, '*')): + sys.path.append(os.path.join(os.environ['ASTER_ROOT'], version, 'bibpyt', mdl)) + try: + from lire_table_ops import lecture_table + except: + UTMESS('F','RECAL0_23') + + reponses = tables_calc + Lrep=[] + for i in range(len(reponses)): + _fic_table = tmp_repe_table + os.sep + "fort."+str(int(100+i)) + try: - #cherche l'indice de FIN() - index_fin = string.index(fichier,'FIN(') - #on restreind fichier en enlevant 'FIN();' - fichier = fichier[:index_fin] - except : pass - #-------------------------------------------------------------------------------- - #on cherche à délimiter le bloc des parametres dans le fichier - #Tout d'abord on cherche les indices d'apparition des paras dans le fichier - #en effet l'utilisateur n'est pas obligé de rentrer les paras dans optimise - #avec le meme ordre de son fichier de commande - index_para = Numeric.zeros(len(para)) - for i in range(len(para)): - index_para[i] = string.index(fichier,para[i]) - #On range les indices par ordre croissant afin de déterminer - #les indice_max et indice_min - index_para = Numeric.sort(index_para) - index_first_para = index_para[0] - index_last_para = index_para[len(index_para)-1] - - - #on va délimiter les blocs intermédiaires entre chaque para "utiles" à l'optimsation - bloc_inter ='\n' - for i in range(len(para)-1): - j = index_para[i] - k = index_para[i+1] - while(fichier[j]!= '\n'): - j=j+1 - bloc_inter=bloc_inter + fichier[j:k] + '\n' - - #on veut se placer sur le premier retour chariot que l'on trouve sur la ligne du dernier para - i = index_last_para - while(fichier[i] != '\n'): - i = i + 1 - index_last_para = i - #on délimite les blocs suivants: - pre_bloc = fichier[:index_first_para] #fichier avant premier parametre - post_bloc = fichier[ index_last_para+ 1:] #fichier après dernier parametre - - #on ajoute dans L tous ce qui est avant le premier paramètre - Fichier_Resu.append(pre_bloc) - Fichier_Resu.append('\n') - #On ajoute la nouvelle valeur des parametres - dim_para=len(para) - for j in range(dim_para): - Fichier_Resu.append(para[j]+'='+str(val[j]) + ';' + '\n') - #On ajoute à Fichier_Resu tous ce qui est entre les parametres - Fichier_Resu.append(bloc_inter) - - Fichier_Resu.append(post_bloc) - #-------------------------------------------------------------------------------- - #on va ajouter la fonction d'extraction du numarray de la table par la méthode Array - #et on stocke les réponses calculées dans la liste Lrep - #qui va etre retournée par la fonction calcul_F - self.g_context['Lrep'] = [] - Fichier_Resu.append('Lrep=[]'+'\n') - for i in range(len(reponses)): - Fichier_Resu.append('t'+str(reponses[i][0])+'='+str(reponses[i][0])+'.EXTR_TABLE()'+'\n') - Fichier_Resu.append('_F_ = '+'t'+str(reponses[i][0])+'.Array('+"'"+str(reponses[i][1])+"'"+','+"'"+str(reponses[i][2])+"'"+')'+'\n') - Fichier_Resu.append('Lrep.append(_F_)'+'\n') - - #ouverture du fichier fort.3 et mise a jour de celui ci - x=open('fort.'+str(UL),'w') - x.writelines('from Accas import _F \nfrom Cata.cata import * \n') - x.writelines(Fichier_Resu) - x.close() - del(Fichier_Resu) - del(pre_bloc) - del(post_bloc) - del(fichier) - - INCLUDE(UNITE = UL) - detr_concepts(self) - # on remet le fichier dans son etat initial - x=open('fort.'+str(UL),'w') - x.writelines(fichiersauv) - x.close() - return self.g_context['Lrep'] - - -#_____________________________________________ -# -# CONTROLE DES ENTREES UTILISATEUR -#_____________________________________________ - -def erreur_de_type(code_erreur,X): - #code_erreur ==0 --> X est une liste - #code erreur ==1 --> X est un char - #code erreur ==2 --> X est un float - #test est un boolean (test = 0 défaut et 1 si un test if est verifier - txt="" - if(code_erreur == 0 ): - if type(X) is not types.ListType: - txt="\nCette entrée: " +str(X)+" n'est pas une liste valide" - if(code_erreur == 1 ): - if type(X) is not types.StringType: - txt="\nCette entrée: " +str(X)+" n'est pas une chaine de caractère valide ; Veuillez la ressaisir en lui appliquant le type char de python" - if(code_erreur == 2 ): - if type(X) is not types.FloatType: - txt="\nCette entrée: " +str(X)+" n'est pas une valeur float valide ; Veuillez la ressaisir en lui appliquant le type float de python" - return txt - - -def erreur_dimension(PARAMETRES,REPONSES): -#On verifie que la dimension de chaque sous_liste de parametre est 4 -#et que la dimension de chaque sous_liste de REPONSES est 3 - txt="" - for i in range(len(PARAMETRES)): - if (len(PARAMETRES[i]) != 4): - txt=txt + "\nLa sous-liste de la variable paramètre numéro " + str(i+1)+" n'est pas de longueur 4" - for i in range(len(REPONSES)): - if (len(REPONSES[i]) != 3): - txt=txt + "\nLa sous-liste de la variable réponse numéro " + str(i+1)+" n'est pas de longueur 3" - return txt - - -def compare__dim_rep__dim_RESU_EXP(REPONSES,RESU_EXP): - # X et Y sont deux arguments qui doivent avoir la meme dimension - # pour éviter l'arret du programme - txt="" - if( len(REPONSES) != len(RESU_EXP)): - txt="\nVous avez entré " +str(len(REPONSES))+ " réponses et "+str(len(RESU_EXP))+ " expériences ; On doit avoir autant de réponses que de résultats expérimentaux" - return txt - -def verif_RESU_EXP(RESU_EXP): - # RESU_EXP doit etre une liste de tableaux Numeric de taille Nx2 - # pour éviter l'arret du programme - txt="" - for index,resu in enumerate(RESU_EXP): - if (isinstance(resu,Numeric.ArrayType)): - if (len(Numeric.shape(resu)) != 2): - txt="\nLa courbe experimentale no " +str(index+1)+ " n'est pas un tableau de N lignes et 2 colonnes." - else: - if (Numeric.shape(resu)[1] != 2): - txt="\nLa courbe experimentale no " +str(index+1)+ " n'est pas un tableau de N lignes et 2 colonnes." + f=open(_fic_table,'r') + texte=f.read() + f.close() + except Exception, err: + ier=1 + UTMESS('F','RECAL0_24',valk=str(err)) + + try: + table_lue = lecture_table(texte, 1, ' ') + list_para = table_lue.para + tab_lue = table_lue.values() + except Exception, err: + ier=1 + else: + ier=0 + + if ier!=0 : UTMESS('F','RECAL0_24',valk=str(err)) + + F = table2numpy(tab_lue, list_para, reponses, i) + Lrep.append(F) + + + return Lrep + + +# -------------------------------------------------------------------------------------------------- +def table2numpy(tab_lue, list_para, reponses, i): + """ Extraction des resultats depuis la table Aster + """ + try: + nb_val = len(tab_lue[ list_para[0] ]) + F = NP.zeros((nb_val,2)) + for k in range(nb_val): + F[k][0] = tab_lue[ str(reponses[i][1]) ][k] + F[k][1] = tab_lue[ str(reponses[i][2]) ][k] + except Exception, err: + UTMESS('F','RECAL0_24',valk=str(err)) + return F + + +# -------------------------------------------------------------------------------------------------- +def Ecriture_Fonctionnelle(output_file, type_fonctionnelle, fonctionnelle): + + try: os.remove(output_file) + except: pass + + f=open(output_file, 'w') + if type_fonctionnelle == 'vector': + try: fonctionnelle = fonctionnelle.tolist() + except: pass + fonctionnelle = str(fonctionnelle).replace('[','').replace(']','').replace('\n', ' ') + f.write( str(fonctionnelle) ) + f.close() + + +# -------------------------------------------------------------------------------------------------- +def Ecriture_Derivees(output_file, derivees): + + try: os.remove(output_file) + except: pass + + # on cherche a imprimer la gradient calcule a partir de Fcalc + if type(derivees) in [list, tuple]: + t = [] + for l in derivees: + l = str(l).replace('[', '').replace(']', '') + t.append( l ) + txt = '\n'.join(t) + + # On cherche a imprimer la matrice des sensibilite (A ou A_nodim) + elif type(derivees) == NP.ndarray: + t = [] + a = derivees + for c in range(len(a[0,:])): + l = a[:,c].tolist() + l = str(l).replace('[', '').replace(']', '') + t.append( l ) + txt = '\n'.join(t) + + else: raise "Wrong type for gradient !" + + # Ecriture + f=open(output_file, 'w') + f.write(txt) + f.close() + + + +# -------------------------------------------------------------------------------------------------- +# -------------------------------------------------------------------------------------------------- +class CALCULS_ASTER: + """ + Classe gérant les calculs Aster (distribues ou include) + """ + + # --------------------------------------------------------------------------- + def __init__(self, + + # MACR_RECAL inputs are optional here (if passed to self.run methods) + parametres = None, + calcul = None, + experience = None, + LANCEMENT = 'DISTRIBUTION', + jdc = None, + ): + + self.parametres = parametres + self.calcul = calcul + self.experience = experience + #self.eval_esclave = mode_esclave + self.LANCEMENT = LANCEMENT + self.UNITE_ESCL = None + self.UNITE_INCLUDE = None + self.ASTER_ROOT = None + + self.jdc = jdc + + self.list_params = [x[0] for x in parametres] + self.list_params.sort() + + # Valable uniquement pour le mode INCLUDE + self.pre = None + self.pretxt = None + self.new = None + self.newtxt = None + + # Mode dynamique desactive par defaut + self.SetDynamiqueMode(None, None) + + + # --------------------------------------------------------------------------------------------------------- + def SetDynamiqueMode(self, DYNAMIQUE, graph_mac): + self.DYNAMIQUE = DYNAMIQUE + self.graph_mac = graph_mac + + + # --------------------------------------------------------------------------------------------------------- + # --------------------------------------------------------------------------------------------------------- + def run(self, + + # Current estimation + X0, + dX = None, + + # Code_Aster installation + ASTER_ROOT = None, + as_run = None, + + # General + resudir = None, + clean = True, + info = None, + NMAX_SIMULT = None, + + # Study + export = None, + + # MACR_RECAL inputs + parametres = None, + calcul = None, + experience = None, + ): + + # Current estimation + self.X0 = X0 + self.dX = dX + + # Code_Aster installation + self.ASTER_ROOT = ASTER_ROOT + self.as_run = as_run + + # General + self.resudir = resudir + self.clean = clean + self.info = info + if not NMAX_SIMULT: NMAX_SIMULT = 0 + self.NMAX_SIMULT = NMAX_SIMULT + + # Study + self.export = export + + # MACR_RECAL inputs + if parametres: self.parametres = parametres + if calcul: self.calcul = calcul + if experience: self.experience = experience + + parametres = self.parametres + calcul = self.calcul + experience = self.experience + + list_params = self.list_params + + if dX: CalcGradient = True + else: CalcGradient = False + self.CalcGradient = CalcGradient + + self.list_diag = [] + + # Pour le moment on conserve un seul fichier + self.UNITE_INCLUDE = self.UNITE_ESCL + + + # ---------------------------------------------------------------------------- + # Liste de tous les jeux de parametres (initial + differences finies) + # ---------------------------------------------------------------------------- + list_val = [] + + # Dictionnaire des parametres du point courant + dic = dict( zip( list_params, X0 ) ) + list_val.append( dic ) + + # Calcul du gradient (perturbations des differences finies) + if CalcGradient: + UTMESS('I','RECAL0_16') + # Dictionnaires des parametres des calculs esclaves + for n in range(1,len(dX)+1): + l = [0] * len(dX) + l[n-1] = dX[n-1] + X = [ X0[i] * (1+l[i]) for i in range(len(dX)) ] + dic = dict( zip( list_params, X ) ) + list_val.append( dic ) + + + # ---------------------------------------------------------------------------- + # Aiguillage vers INCLUDE + # ---------------------------------------------------------------------------- + if self.LANCEMENT == 'INCLUSION': + UTMESS('I','RECAL0_29', valk=self.LANCEMENT) + fonctionnelle, gradient = self.run_include(list_val) + + + # ---------------------------------------------------------------------------- + # Aiguillage vers ASRUN distribue + # ---------------------------------------------------------------------------- + elif self.LANCEMENT == 'DISTRIBUTION': + UTMESS('I','RECAL0_29', valk=self.LANCEMENT) + fonctionnelle, gradient = self.run_distrib(list_val) + + + # ---------------------------------------------------------------------------- + # Erreur d'aiguillage + # ---------------------------------------------------------------------------- + else: + raise "Erreur : mode %s inconnu!" % self.LANCEMENT + + + #sys.exit() + # ---------------------------------------------------------------------------- + # Sortie + # ---------------------------------------------------------------------------- + return fonctionnelle, gradient + + + + # --------------------------------------------------------------------------------------------------------- + # --------------------------------------------------------------------------------------------------------- + def run_include(self,list_val): + """ Module permettant de lancer N+1 calculs via un mecanisme d'include + """ + +# # Importation de commandes Aster +# try: +# import aster +# import Macro +# from Accas import _F +# from Cata import cata +# from Cata.cata import * +# except ImportError: +# raise "Simu_point_mat doit etre lance depuis Aster" + + try: + import aster + import Macro + from Cata import cata + from Cata.cata import OPER, MACRO + from Accas import _F + + # Declaration de toutes les commandes Aster + import cata + for k,v in cata.__dict__.items() : + #print k,v + if isinstance(v, (OPER, MACRO)): + #print k,v + #self.jdc.current_context[k]= v + exec("from Cata.cata import %s" % k) + #self.jdc.current_context['_F']=cata.__dict__['_F'] + except Exception, e: + raise "Le mode INCLUDE doit etre lance depuis Aster : \nErreur : " % e + + + list_params = self.list_params + calcul = self.calcul + reponses = self.calcul + +# AA : marche pas car on peut oublier des courbes, tant pis on refait des extract en trop.. +# liste_reponses = [] +# for reponse in [ x[0] for x in calcul ]: +# if not reponse in liste_reponses: liste_reponses.append(reponse) + + liste_reponses = [ x[0] for x in calcul ] + + + # ---------------------------------------------------------------------------- + # Boucle sur les N+1 calculs + # ---------------------------------------------------------------------------- + Lcalc = [] + for i in range(len(list_val)): + params = list_val[i] + + + # ---------------------------------------------------------------------------- + # Affectation des valeurs des parametres + # ---------------------------------------------------------------------------- + for nompara in list_params: + valpara = params[nompara] + exec( "%s=%s" % (nompara, valpara) ) # YOUN__ = X0[0], DSDE__ = X0[1], ... + + + # ---------------------------------------------------------------------------- + # Affichage des parametres du calcul courant + # ---------------------------------------------------------------------------- + tpara = Affiche_Param(list_params, [ params[x] for x in list_params] ) + if i==0: UTMESS('I', 'RECAL0_67', valk=tpara) + else: UTMESS('I', 'RECAL0_68', valk=(tpara, list_params[i-1]) ) + + + # ---------------------------------------------------------------------------- + # Lancement du calcul (par un include) + # ---------------------------------------------------------------------------- + new = "fort.%s.new" % self.UNITE_INCLUDE + execfile(new) + + + # ---------------------------------------------------------------------------- + # On considere que le job est OK s'il ne s'est pas plante dans le except precedent.. + # ---------------------------------------------------------------------------- + self.list_diag.append("OK") + + + # ---------------------------------------------------------------------------- + # Extraction des tables + # ---------------------------------------------------------------------------- + Lrep=[] + for i in range(len(liste_reponses)): + reponse = liste_reponses[i] + DETRUIRE(OBJET=_F(CHAINE='VEXTR___'), ALARME='NON', INFO=1) # Faudrait proteger ce nom ici (VEXTR___ peut etre deja utilise dans l'etude) + exec( "VEXTR___ = %s.EXTR_TABLE()" % reponse) + list_para = VEXTR___.para + tab_lue = VEXTR___.values() + F = table2numpy(tab_lue, list_para, reponses, i) + Lrep.append(F) + + + + Lcalc.append( Lrep ) + + + # Destruction des concepts Aster + liste_concepts = self.jdc.g_context.keys() + for c in liste_concepts: + DETRUIRE(OBJET=_F(CHAINE=c), ALARME='NON', INFO=1); + + #detr_concepts(self.jdc) # marche pas ! + #sys.exit() + + + # ---------------------------------------------------------------------------- + # Calcul de la fonctionnelle et du gradient + # ---------------------------------------------------------------------------- + if debug: print "AA4/Lcalc=", Lcalc + fonctionnelle, gradient = self.calc2fonc_gradient(Lcalc) + + + # ---------------------------------------------------------------------------- + # Save all calculated responses + self.Lcalc = Lcalc + # ---------------------------------------------------------------------------- + + + return fonctionnelle, gradient + + + + + + + # --------------------------------------------------------------------------------------------------------- + # --------------------------------------------------------------------------------------------------------- + def run_distrib(self, list_val): + """ Module permettant de lancer N+1 calculs avec le module de calculs distribues d'asrun + """ + + # ---------------------------------------------------------------------------- + # Parametres + # ---------------------------------------------------------------------------- + + # Code_Aster installation + ASTER_ROOT = self.ASTER_ROOT + as_run = self.as_run + + # General + resudir = self.resudir + clean = self.clean + info = self.info + + # Study + export = self.export + + # MACR_RECAL inputs + parametres = self.parametres + calcul = self.calcul + experience = self.experience + + parametres = self.parametres + calcul = self.calcul + experience = self.experience + + CalcGradient = self.CalcGradient + NMAX_SIMULT = self.NMAX_SIMULT + + + # ---------------------------------------------------------------------------- + # Import des modules python d'ASTK + # ---------------------------------------------------------------------------- + if not ASTER_ROOT: + try: ASTER_ROOT = os.path.join(aster.repout, '..') + except: pass + try: + sys.path.append(os.path.join(ASTER_ROOT, 'ASTK', 'ASTK_SERV', 'lib')) + sys.path.append(os.path.join(ASTER_ROOT, 'lib', 'python%s.%s' % (sys.version_info[0], sys.version_info[1] ) , 'site-packages')) + except: pass + try: + from asrun.run import AsRunFactory + from asrun.profil import ASTER_PROFIL + from asrun.common_func import get_hostrc + from asrun.utils import get_timeout + from asrun.parametric import is_list_of_dict + from asrun.thread import Dispatcher + from asrun.distrib import DistribParametricTask + except Exception, e: + print e + UTMESS('F','RECAL0_99') + + + assert is_list_of_dict(list_val) + nbval = len(list_val) + + # ---------------------------------------------------------------------------- + # Generation des etudes esclaves + # ---------------------------------------------------------------------------- + sys.argv = [''] + run = AsRunFactory() + run.options['debug_stderr'] = True # pas d'output d'executions des esclaves dans k'output maitre + + # Master profile + prof = ASTER_PROFIL(filename=export) + tmp_param = tempfile.mkdtemp() + try: username = prof.param['username'][0] + except: username = os.environ['LOGNAME'] + try: noeud = prof.param['noeud'][0] + except: noeud = platform.uname()[1] + tmp_param = "%s@%s:%s" % ( username, noeud, tmp_param) + prof.Set('R', {'type' : 'repe', 'isrep' : True, 'ul' : 0, 'compr' : False, 'path' : tmp_param }) + if info>=2: print prof + + # Si batch n'est pas possible, on bascule en interactif + if prof.param['mode'][0]=='batch' and run.get('batch')=='non': + UTMESS('I','RECAL0_28',valk=noeud) + prof.param['mode'][0] = 'interactif' + + # result directories + if resudir: + if not os.path.isdir(resudir): + try: os.mkdir(resudir) + except: + if info>=1: UTMESS('A','RECAL0_82',valk=resudir) + resudir = None + if not resudir: + # Par defaut, dans un sous-repertoire du repertoire d'execution + pref = 'tmp_macr_recal_' + # On cherche s'il y a un fichier hostfile pour placer les fichiers dans un repertoire partage + l_fr = getattr(prof, 'data') + l_tmp = l_fr[:] + for dico in l_tmp: + if dico['type']=='hostfile': + pref = os.environ['HOME'] + os.sep + 'tmp_macr_recal_' + break + # Si batch alors on place les fichiers dans un repertoire partage + if prof['mode'][0]=='batch': pref = os.environ['HOME'] + os.sep + 'tmp_macr_recal_' + + resudir = tempfile.mkdtemp(prefix=pref) + flashdir = os.path.join(resudir,'flash') + if info>=1: UTMESS('I','RECAL0_81',valk=resudir) + + prof.WriteExportTo( os.path.join(resudir, 'master.export') ) + + # get hostrc object + hostrc = get_hostrc(run, prof) + + # timeout before rejected a job + timeout = get_timeout(prof) + + + # Ajout des impressions de tables a la fin du .comm + t = [] + reponses = calcul + for i in range(len(reponses)): + _ul = str(int(100+i)) + num_ul = '99' + + # Pour la dynamique la table avec la matrice MAC a un traitement different + if self.DYNAMIQUE: + if ('MAC' in reponses[i][2]): + t.append( self.ajout_post_mac( reponses[i] ) ) + + try: os.remove( tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+_ul ) + except: pass + + t.append("\n# Recuperation de la table : " + str(reponses[i][0]) + "\n") + t.append("DEFI_FICHIER(UNITE=" + num_ul + ", FICHIER='" + os.path.join('.', 'REPE_OUT', 'fort.'+_ul) + "',);\n" ) + t.append("IMPR_TABLE(TABLE="+str(reponses[i][0])+", FORMAT='ASTER', UNITE="+num_ul+", INFO=1, FORMAT_R='E30.20',);\n") + t.append("DEFI_FICHIER(ACTION='LIBERER', UNITE="+num_ul+",);\n") + + + # number of threads to follow execution + numthread = 1 + + + # ---------------------------------------------------------------------------- + # Executions des etudes esclaves + # ---------------------------------------------------------------------------- + # ----- Execute calcutions in parallel using a Dispatcher object + # elementary task... + task = DistribParametricTask(run=run, prof=prof, # IN + hostrc=hostrc, + nbmaxitem=self.NMAX_SIMULT, timeout=timeout, + resudir=resudir, flashdir=flashdir, + keywords={'POST_CALCUL': '\n'.join(t)}, + info=info, + nbnook=0, exec_result=[]) # OUT + # ... and dispatch task on 'list_tests' + etiq = 'calc_%%0%dd' % (int(log10(nbval)) + 1) + labels = [etiq % (i+1) for i in range(nbval)] + couples = zip(labels, list_val) + + if info>=2: print couples + execution = Dispatcher(couples, task, numthread=numthread) + + # ---------------------------------------------------------------------------- + # Liste des diagnostics + # ---------------------------------------------------------------------------- + d_diag = {} + for result in task.exec_result: + #print result + label = result[0] + diag = result[2] + if len(result) >= 8: output_filename = os.path.join('~', 'flasheur', str(result[7])) + else: output_filename = '' + d_diag[label] = diag + if not diag[0:2] in ['OK', '_COPY_ERROR']: + UTMESS('A', 'RECAL0_70', valk=(label, output_filename)) + + # Affichage de l'output + try: + f=open(output_filename, 'r') + print f.read() + f.close() + except: pass + + + if not d_diag: + UTMESS('F', 'RECAL0_71', valk=resudir) + self.list_diag = [ d_diag[label] for label in labels ] + + # ---------------------------------------------------------------------------- + # Arret si tous les jobs ne se sont pas deroules correctement + # ---------------------------------------------------------------------------- + iret = 0 + if task.nbnook > 0: + iret = 4 + if iret: + UTMESS('A', 'RECAL0_71', valk=resudir) + run.Sortie(iret) + + + + # ---------------------------------------------------------------------------- + # Recuperation des tables calculees + # ---------------------------------------------------------------------------- + Lcalc = [] + i=0 + for c in labels: + tbl = get_tables(tables_calc=calcul, tmp_repe_table=os.path.join(resudir, c, 'REPE_OUT'), prof=prof) + Lcalc.append( tbl ) # On stocke sous la forme d'une liste de numpy + i+=1 + + + # ---------------------------------------------------------------------------- + # Calcul de la fonctionnelle et du gradient + # ---------------------------------------------------------------------------- + if debug: print "AA4/Lcalc=", Lcalc + fonctionnelle, gradient = self.calc2fonc_gradient(Lcalc) + + + # ---------------------------------------------------------------------------- + # Clean result directories + # ---------------------------------------------------------------------------- + if clean: shutil.rmtree(resudir, ignore_errors=True) + + + # ---------------------------------------------------------------------------- + # Save all calculated responses + # ---------------------------------------------------------------------------- + self.Lcalc = Lcalc + + return fonctionnelle, gradient + + + # --------------------------------------------------------------------------------------------------------- + # --------------------------------------------------------------------------- + def calc2fonc_gradient(self, Lcalc): + """ Calculs de la fonctionnelle et du gradient a partir des tables calculees + """ + + #print "AA1/Lcalc=", Lcalc + + info = self.info + CalcGradient = self.CalcGradient + + # ---------------------------------------------------------------------------- + # Recuperation des tables calculees + # ---------------------------------------------------------------------------- + seq_FX = [] + seq_FY = [] + seq_DIMS = [] + lst_iter = [] + for i in range(len(Lcalc)): + tbl = Lcalc[i] + FX = [] + FY = [] + ldims = [] + for array in tbl: + FX.extend([ x[0] for x in array ]) + FY.extend([ x[1] for x in array ]) + ldims.append(len(array)) + # Agregation des resultats + seq_FX.append(FX) + seq_FY.append(FY) + seq_DIMS.append(ldims) + lst_iter.append(i) + + + # ---------------------------------------------------------------------------- + # Fonctionnelle + # ---------------------------------------------------------------------------- + # Calcul maitre (point X0) + idx0 = lst_iter.index(0) # index (les calculs arrivent-ils dans le desordre?) + FY_X0 = seq_FY[idx0] + fonctionnelle = FY_X0 + + + # ---------------------------------------------------------------------------- + # Procedure d'assemblage du gradient (une liste de liste) + # ---------------------------------------------------------------------------- + gradient = [] + if CalcGradient: + for n in range(len(lst_iter))[1:]: + idx = lst_iter.index(n) + FY = seq_FY[idx] + col = [ (y-x) for x, y in zip(FY, FY_X0) ] + gradient.append(col) + #print 'Calcul numero: %s - Diagnostic: %s' % (n, self.list_diag[idx]) + if info>=1: UTMESS('I', 'RECAL0_74', valk=(str(n), self.list_diag[idx]) ) + + # ---------------------------------------------------------------------------- + # Affichages + # ---------------------------------------------------------------------------- + if info>=2: + UTMESS('I', 'RECAL0_72', valk=str(fonctionnelle)) + import pprint + if CalcGradient: + UTMESS('I', 'RECAL0_73') + pprint.pprint(gradient) + + return fonctionnelle, gradient + + + # --------------------------------------------------------------------------------------------------------- + # --------------------------------------------------------------------------- + def find_parameter0(self, content, param): + """ + Return the lowest index in content where param is found and + the index of the end of the command. + """ + if not self.ASTER_ROOT: + try: ASTER_ROOT = os.path.join(aster.repout, '..') + except: pass + try: + sys.path.append(os.path.join(ASTER_ROOT, 'ASTK', 'ASTK_SERV', 'lib')) + sys.path.append(os.path.join(ASTER_ROOT, 'lib', 'python%s.%s' % (sys.version_info[0], sys.version_info[1] ) , 'site-packages')) + except: pass + try: + from asrun.utils import search_enclosed + except Exception, e: + print e + UTMESS('F','RECAL0_99') + + pos, endpos = -1, -1 + re_start = re.compile('^ *%s *\=' % re.escape(param), re.M) + mat_start = re_start.search(content) + if mat_start is not None: + pos = mat_start.start() + endpos = search_enclosed(content, pos) + return pos, endpos + + + # --------------------------------------------------------------------------------------------------------- + # --------------------------------------------------------------------------- + def find_parameter(self, content, param): + """ + Supprime les parametres du fichier de commande + """ + re_start = re.compile('^ *%s *\=' % re.escape(param), re.M) + l=[] + for line in content.split('\n'): + mat_start = re_start.search(line) + if mat_start is None: l.append(line) + return '\n'.join(l) + + + # --------------------------------------------------------------------------------------------------------- + # --------------------------------------------------------------------------- + def ajout_post_mac(self, reponse): + """ + Ajoute un bloc a la fin de l'esclave pour l'affichage des MAC pour l'appariement manuel + """ + txt = [] + txt.append( "from Macro.reca_mac import extract_mac_array, get_modes, fenetre_mac\n" ) + txt.append( "_mac = extract_mac_array("+str(reponse[0])+")\n" ) + txt.append( "l_mac=[]\n" ) + txt.append( "nb_freq=_mac.shape[1]\n" ) + if (self.DYNAMIQUE['APPARIEMENT_MANUEL']=='OUI' and self.graph_mac): + txt.append( "frame =fenetre_mac(" + self.DYNAMIQUE['MODE_EXP']+"," + self.DYNAMIQUE['MODE_CALC']+",_mac)\n" ) + txt.append( "list_exp,list_num =frame.get_list()\n" ) + txt.append( "for i in range(nb_freq): l_mac.append(_mac[int(list_num[i])-1,int(list_exp[i])-1])\n" ) else: - txt="\nLa courbe experimentale no " +str(index+1)+ " n'est pas un tableau Numeric." - return txt - -def compare__dim_poids__dim_RESU_EXP(POIDS,RESU_EXP): - # POIDS et Y sont deux arguments qui doivent avoir la meme dimension - # pour éviter l'arret du programme - txt="" - if( len(POIDS) != len(RESU_EXP)): - txt="\nVous avez entré " +str(len(POIDS))+ " poids et "+str(len(RESU_EXP))+ " expériences ; On doit avoir autant de poids que de résultats expérimentaux" - return txt - - -def verif_fichier(UL,PARAMETRES,REPONSES): -#On verifie les occurences des noms des PARAMETRES et REPONSES -#dans le fichier de commande ASTER - txt="" - fichier = open('fort.'+str(UL),'r') - fic=fichier.read() - for i in range(len(PARAMETRES)): - if((string.find(fic,PARAMETRES[i][0])==-1) or ((string.find(fic,PARAMETRES[i][0]+'=')==-1) and (string.find(fic,PARAMETRES[i][0]+' ')==-1))): - txt=txt + "\nLe paramètre "+PARAMETRES[i][0]+" que vous avez entré pour la phase d'optimisation n'a pas été trouvé dans votre fichier de commandes ASTER" - for i in range(len(REPONSES)): - if((string.find(fic,REPONSES[i][0])==-1) or ((string.find(fic,REPONSES[i][0]+'=')==-1) and (string.find(fic,REPONSES[i][0]+' ')==-1))): - txt=txt + "\nLa réponse "+REPONSES[i][0]+" que vous avez entrée pour la phase d'optimisation n'a pas été trouvée dans votre fichier de commandes ASTER" - return txt - - -def verif_valeurs_des_PARAMETRES(PARAMETRES): -#On verifie que pour chaque PARAMETRES de l'optimisation -# les valeurs entrées par l'utilisateur sont telles que : -# val_infPARAMETRES[i][3]): - txt=txt + "\nLa borne inférieure "+str(PARAMETRES[i][2])+" de "+PARAMETRES[i][0]+ "est plus grande que sa borne supérieure"+str(PARAMETRES[i][3]) - #verification de l'encadrement de val_init - for i in range(len(PARAMETRES)): - if( (PARAMETRES[i][1] < PARAMETRES[i][2]) or (PARAMETRES[i][1] > PARAMETRES[i][3])): - txt=txt + "\nLa valeur initiale "+str(PARAMETRES[i][1])+" de "+PARAMETRES[i][0]+ " n'est pas dans l'intervalle [borne_inf,born_inf]=["+str(PARAMETRES[i][2])+" , "+str(PARAMETRES[i][3])+"]" - #verification que val_init !=0 - for i in range(len(PARAMETRES)): - if (PARAMETRES[i][1] == 0. ): - txt=txt + "\nProblème de valeurs initiales pour le paramètre "+PARAMETRES[i][0]+" : ne pas donner de valeur initiale nulle mais un ordre de grandeur." - #verification que borne_sup !=0 - for i in range(len(PARAMETRES)): - if (PARAMETRES[i][3] == 0. ): - txt=txt + "\nProblème de borne supérieure pour le paramètre "+PARAMETRES[i][0]+" : ne pas donner de valeur strictement nulle." - #verification que borne_inf !=0 - for i in range(len(PARAMETRES)): - if (PARAMETRES[i][2] == 0. ): - txt=txt + "\nProblème de borne inférieure pour le paramètre "+PARAMETRES[i][0]+" : ne pas donner de valeur strictement nulle." - return txt - - -def verif_UNITE(GRAPHIQUE,UNITE_RESU): - # On vérifie que les unités de résultat et - # de graphique sont différentes - txt="" - GRAPHE_UL_OUT=GRAPHIQUE['UNITE'] - if (GRAPHE_UL_OUT==UNITE_RESU): - txt=txt + "\nLes unités logiques des fichiers de résultats graphiques et de résultats d'optimisation sont les memes." - return txt - - - -def gestion(UL,PARAMETRES,REPONSES,RESU_EXP,POIDS,GRAPHIQUE,UNITE_RESU): - #Cette methode va utiliser les methodes de cette classe declarée ci_dessus - #test est un boolean: test=0 -> pas d'erreur - # test=1 -> erreur détectée - - texte="" - #On vérifie d'abord si PARAMETRES, REPONSES, RESU_EXP sont bien des listes au sens python - #test de PARAMETRES - texte = texte + erreur_de_type(0,PARAMETRES) - #test de REPONSES - texte = texte + erreur_de_type(0,REPONSES) - #test de RESU_EXP - texte = texte + erreur_de_type(0,RESU_EXP) - - #On vérifie si chaque sous liste de PARAMETRES, REPONSES, possède le type adéquat - #test des sous_listes de PARAMETRES - for i in range(len(PARAMETRES)): - texte = texte + erreur_de_type(0,PARAMETRES[i]) - #test des sous_listes de REPONSES - for i in range(len(REPONSES)): - texte = texte + erreur_de_type(0,REPONSES[i]) - - #On verifie si la dimension de chaque sous-liste de : PARAMETRES, REPONSES - #il faut que:la dimension d'une sous-liste de PARAMETRES = 4 - #et que la dimension d'une sous liste de REPONSES = 3 - texte = texte + erreur_dimension(PARAMETRES,REPONSES) - - #on verifie le type et la dimension des résultats expérimentaux - texte = texte + verif_RESU_EXP(RESU_EXP) - #on verifie que l'on a autant de réponses que de résultats expérimentaux - texte = texte + compare__dim_rep__dim_RESU_EXP(REPONSES,RESU_EXP) - #on verifie que l'on a autant de poids que de résultats expérimentaux - texte = texte + compare__dim_poids__dim_RESU_EXP(POIDS,RESU_EXP) - - #on verifie les types des arguments de chaque sous liste de PARAMETRES et REPONSES - #verification du type stringet type float des arguments de PARAMETRES - for i in range(len(PARAMETRES)): - texte = texte + erreur_de_type(1,PARAMETRES[i][0]) - for k in [1,2,3]: - texte = texte + erreur_de_type(2,PARAMETRES[i][k]) - - #verification du type string pour les arguments de REPONSES - for i in range(len(REPONSES)): - for j in range(len(REPONSES[i])): - texte = texte + erreur_de_type(1,REPONSES[i][j]) - - #verification du fichier de commndes ASTER - texte = texte + verif_fichier(UL,PARAMETRES,REPONSES) - - #verifiaction des valeurs des PARAMETRES entrées par l'utilisteur - texte = texte + verif_valeurs_des_PARAMETRES(PARAMETRES) - - #verifiaction des unités logiques renseignées par l'utilisateur - texte = texte + verif_UNITE(GRAPHIQUE,UNITE_RESU) - - return texte - + txt.append( "for i in range(nb_freq): l_mac.append(_mac[i,i])\n" ) + txt.append( "DETRUIRE(CONCEPT=_F(NOM="+str(reponse[0])+"),)\n" ) + txt.append( str(reponse[0]) + "=CREA_TABLE(LISTE=(_F(PARA='NUME_ORDRE',LISTE_I=range(1,nb_freq+1),),_F(PARA='MAC',LISTE_R=l_mac,),),)\n" ) + return '\n'.join(txt) + + +# -------------------------------------------------------------------------------------------------- +# -------------------------------------------------------------------------------------------------- +class CALC_ERROR: + """ + Classe gérant l'erreur par rapport aux donnees experimentales, la matrice des sensibilites + """ + # --------------------------------------------------------------------------- + def __init__(self, experience, X0, calcul, poids=None, objective_type='vector', info=0, unite_resu=None): + + if poids is None: + poids = NP.ones(len(experience)) + self.experience = experience + self.X0 = X0 + self.calcul = calcul + self.poids = poids + self.objective_type = objective_type + self.INFO = info + self.unite_resu = unite_resu + + from Macro import reca_interp, reca_algo + self.test_convergence = reca_algo.test_convergence + self.calcul_gradient = reca_algo.calcul_gradient + self.Simul = reca_interp.Sim_exp(self.experience, self.poids) + try: self.Dim = reca_algo.Dimension(copy.copy(self.X0)) + except: self.Dim = reca_algo.Dimension(copy.copy(self.X0), None) # gere l'ancienne version de MACR_RECAL + #self.Dim = reca_algo.Dimension(copy.copy(self.X0)) + + self.F = None + self.L_J_init = None + self.L_J = None + self.J_init = None + self.J = None + self.L_init = None + self.erreur = None + self.norme = None + self.A = None + self.A_nodim = None + self.norme_A_ = None + self.norme_A_nodim = None + + if info>=3: self.debug = True + else: self.debug = False + #if debug: self.debug = True + self.debug = True + + + # --------------------------------------------------------------------------- + def CalcError(self, Lcalc): + + self.F = Lcalc[0] + if self.L_init is None: self.L_init = copy.copy(self.F) + + self.L_J, self.erreur = self.Simul.multi_interpole(self.F, self.calcul) + if self.L_J_init is None: self.L_J_init = copy.copy(self.L_J) + + self.J = self.Simul.norme_J( copy.copy(self.L_J_init), copy.copy(self.L_J) ) + if self.J_init is None: self.J_init = copy.copy(self.J) + + # norme de l'erreur + self.norme = NP.sum( [x**2 for x in self.erreur] ) + + if self.debug: + print "AA1/F=", self.F + print "AA1/calcul=", self.calcul + print "AA1/L_J=", self.L_J + print "AA1/erreur=", self.erreur + print "AA1/L_J_init=", self.L_J_init + print "AA1/J=", self.J + print "AA1/norme de l'erreur=", self.norme + print "AA1/norme de J (fonctionnelle)=", str(self.J) + + if self.INFO>=1: + UTMESS('I', 'RECAL0_30') + + if self.objective_type=='vector': + if self.INFO>=1: UTMESS('I', 'RECAL0_35', valr=self.norme) + return self.erreur + else: + if self.INFO>=1: UTMESS('I', 'RECAL0_36', valr=self.norme) + return self.norme + + + # --------------------------------------------------------------------------- + def CalcSensibilityMatrix(self, Lcalc, val, dX=None, pas=None): + + """ + Calcul de F(X0) et de tous les F(X0+h) + Formation de la matrice des sensibilites A + N+1 calculs distribues + """ + + if not dX and not pas: raise "Need 'dX' or 'pas' parameter." + if dX and pas: raise "Need 'dX' or 'pas' parameter, not both." + if pas: dX = len(val)*[pas] + if len(dX) != len(val): raise "Error : 'dX' and 'val' parameters aren't compatible (lenght are not equal).\ndX = %s\nval = %s" % (str(dx), str(val)) + + reponses = self.calcul + resu_exp = self.experience + len_para = len(val) # initialement len(self.para) + + + # Erreur de l'interpolation de F_interp : valeur de F interpolée sur les valeurs experimentales + F = Lcalc[0] + F_interp = self.Simul.multi_interpole_sensib(F, reponses) #F_interp est une liste contenant des tab num des reponses interpolés + + + # Creation de la liste des matrices de sensibilités + L_A=[] + for i in range(len(reponses)): + L_A.append(NP.zeros((len(resu_exp[i]),len(val))) ) + + for k in range(len(val)): # pour une colone de A (dim = nb parametres) + + F_perturbe = Lcalc[k+1] + + # Erreur de l'interpolation de F_perturb : valeur de F (perturbée) interpolée sur les valeurs experimentales + F_perturbe_interp = self.Simul.multi_interpole_sensib(F_perturbe, reponses) + + # Calcul de L_A (matrice sensibilité des erreurs sur F interpolée) + h = val[k]*dX[k] + for j in range(len(reponses)): + for i in range(len(resu_exp[j])): + if NP.all(h != 0.): + L_A[j][i,k] = -1*(F_interp[j][i] - F_perturbe_interp[j][i])/h + else: + if self.unite_resu: + fic=open(os.getcwd()+'/fort.'+str(unite_resu),'a') + fic.write('\n Probleme de division par zéro dans le calcul de la matrice de sensiblité') + fic.write('\n Le parametre '+para[k]+'est nul ou plus petit que la précision machine') + fic.close() + UTMESS('F','RECAL0_45',valk=para[k]) + return + + # On construit la matrice de sensiblité sous forme d'un tab num + dim =[] + for i in range(len(L_A)): + dim.append(len(L_A[i])) + dim_totale = NP.sum(dim) + a=0 + self.A_nodim = NP.zeros((dim_totale,len(val))) + for n in range(len(L_A)): + for k in range(len(val)): + for i in range(dim[n]): + self.A_nodim[i+a][k] = L_A[n][i,k] + a=dim[n] + + del(L_A) + + + self.A = self.Dim.adim_sensi( copy.copy(self.A_nodim) ) + + # Si on n'est pas encore passe par CalcError... + if self.erreur is None: + self.erreur = self.CalcError(Lcalc) + self.gradient_init = self.calcul_gradient(self.A, self.erreur) #utile pour le test de convergence, on prend les valeurs dimensionnées + self.residu = self.test_convergence(self.gradient_init, self.erreur, self.A, NP.zeros(len(self.gradient_init))) + + if self.debug: + print "AA1/erreur=", self.erreur + print "AA1/residu=", self.residu + print "AA1/A_nodim=", self.A_nodim + print "AA1/A=", self.A + + + if self.objective_type=='vector': + return self.erreur, self.residu, self.A_nodim, self.A + else: + # norme de l'erreur + self.norme = NP.dot(self.erreur, self.erreur)**0.5 + self.norme_A_nodim = NP.zeros( (1,len_para)) + self.norme_A = NP.zeros( (1,len_para)) + for c in range(len(self.A[0,:])): + norme_A_nodim = 0 + norme_A = 0 + for l in range(len(self.A[:,0])): + norme_A_nodim += self.A_nodim[l,c] * self.A_nodim[l,c] + norme_A += self.A[l,c] * self.A[l,c] + self.norme_A_nodim[0,c] = math.sqrt( norme_A_nodim ) + self.norme_A[0,c] = math.sqrt( norme_A ) + if self.debug: + print "AA1/norme_A_nodim=", self.norme_A_nodim + print "AA1/norme_A=", self.norme_A + return self.erreur, self.residu, self.norme_A_nodim, self.norme_A + + + + + + +# ---------------------------------------------------------------------------------------------------------------------- +# ---------------------------------------------------------------------------------------------------------------------- +if __name__ == '__main__': + + # Execution via YACS ou en externe + isFromYacs = globals().get('ASTER_ROOT', None) + + + # ------------------------------------------------------------------------------------------------------------------ + # Execution depuis YACS + # ------------------------------------------------------------------------------------------------------------------ + if isFromYacs: + # Execution depuis YACS : les parametres sont deja charges en memoire + + # ---------------------------------------------------------------------------- + # Parametres courant + X0 = globals().get('X0', [ 80000., 1000., 30. ]) + dX = globals().get('dX', [ 0.001, 0.001, 0.0001]) + # ---------------------------------------------------------------------------- + + # ---------------------------------------------------------------------------- + # Parametres + os.environ['ASTER_ROOT'] = ASTER_ROOT + if debug: + clean = False + info = 1 + else: + clean = True + info = 0 + # ---------------------------------------------------------------------------- + + + # ------------------------------------------------------------------------------------------------------------------ + # Execution en mode EXTERNE + # ------------------------------------------------------------------------------------------------------------------ + else: + # Execution en mode EXTERNE : on doit depouiller les parametres de la ligne de commande + + + from optparse import OptionParser, OptionGroup + + p = OptionParser(usage='usage: %s fichier_export [options]' % sys.argv[0]) + + # Current estimation + p.add_option('--input', action='store', dest='input', type='string', help='Chaine de texte contenant les parametres') + p.add_option('--input_step', action='store', dest='input_step', type='string', help='Chaine de texte contenant les pas de discretisation des differences finies') + p.add_option('--input_file', action='store', dest='input_file', type='string', default='input.txt', help='Fichier contenant les parametres') + p.add_option('--input_step_file', action='store', dest='input_step_file', type='string', help='Fichier contenant les pas de discretisation des differences finies') + + # Outputs + p.add_option('--output', action='store', dest='output', type='string', default='output.txt', help='fichier contenant la fonctionnelle') + p.add_option('--output_grad', action='store', dest='output_grad', type='string', default='grad.txt', help='fichier contenant le gradient') + + # Code_Aster installation + p.add_option('--aster_root', action='store', dest='aster_root', type='string', help="Chemin d'installation d'Aster") + p.add_option('--as_run', action='store', dest='as_run', type='string', help="Chemin vers as_run") + + # General + p.add_option('--resudir', action='store', dest='resudir', type='string', help="Chemin par defaut des executions temporaires d'Aster") + p.add_option("--noclean", action="store_false", dest="clean", default=True, help="Erase temporary Code_Aster execution directory") + p.add_option('--info', action='store', dest='info', type='int', default=1, help="niveau de message (0, [1], 2)") + p.add_option('--sources_root', action='store', dest='SOURCES_ROOT', type='string', help="Chemin par defaut des surcharges Python") + #p.add_option('--slave_computation', action='store', dest='slave_computation', type='string', default='distrib', help="Evaluation de l'esclave ([distrib], include)") + + # MACR_RECAL parameters + p.add_option('--objective', action='store', dest='objective', type='string', default='fcalc', help="Fonctionnelle ([fcalc]/[error])") + p.add_option('--objective_type', action='store', dest='objective_type', type='string', default='vector', help="type de la fonctionnelle (float/[vector])") + p.add_option('--gradient_type', action='store', dest='gradient_type' , type='string', default='no', help="calcul du gradient par Aster ([no]/normal/adim)") + + # MACR_RECAL inputs + p.add_option('--mr_parameters', action='store', dest='mr_parameters', type='string', default='N_MR_Parameters.py', help="Fichier de parametres de MACR_RECAL : parametres, calcul, experience") + p.add_option('--study_parameters', action='store', dest='study_parameters', type='string', help="Fichier de parametre de l'etude : export") + p.add_option('--parameters', action='store', dest='parameters', type='string', help="Fichier de parametres") + + options, args = p.parse_args() + + + # Study : .export file + if args: export = args[0] + else: + liste = glob.glob('*.export') + export = liste[0] + if not os.path.isfile(export): raise "Export file : is missing!" + + + # Code_Aster installation + ASTER_ROOT = None + if options.aster_root: ASTER_ROOT = options.aster_root + elif os.environ.has_key('ASTER_ROOT'): ASTER_ROOT = os.environ['ASTER_ROOT'] + if not ASTER_ROOT: raise "ASTER_ROOT is missing! Set it by --aster_root flag or environment variable ASTER_ROOT" + if not os.path.isdir(ASTER_ROOT): raise "Wrong directory for ASTER_ROOT : %s" % ASTER_ROOT + os.environ['ASTER_ROOT'] = ASTER_ROOT +# sys.path.append(get_absolute_path(os.path.join(ASTER_ROOT, 'STA10.1', 'bibpyt' ))) +# from Utilitai.Utmess import UTMESS + + if options.as_run: as_run = options.as_run + else: as_run = os.path.join(ASTER_ROOT, 'bin', 'as_run') + + + # General + if options.resudir: resudir = options.resudir + clean = options.clean + +# if options.info == 0: info = False +# elif options.info == 1: info = False +# elif options.info == 2: info = True + info = options.info + + # Import des modules supplementaires + if options.SOURCES_ROOT: + if not os.path.isdir(options.SOURCES_ROOT): raise "Wrong directory for sources_root : %s" % options.SOURCES_ROOT + else: + sys.path.insert(0, options.SOURCES_ROOT) + sys.path.insert(0, os.path.join(options.SOURCES_ROOT, 'sources')) + + + # MACR_RECAL inputs + if options.mr_parameters: + try: + if info>=1: print "Read MR parameters file : %s" % options.mr_parameters + execfile(options.mr_parameters) + except: raise "Wrong file for MR Parameters: %s" % options.mr_parameters + else: raise "MR Parameters file needed ! Use --mr_parameters flag" + parametres = globals().get('parametres', None) + calcul = globals().get('calcul', None) + experience = globals().get('experience', None) + poids = globals().get('poids', None) + + if not parametres: raise "MR Parameters file need to define 'parametres' variable" + if not calcul: raise "MR Parameters file need to define 'calcul' variable" + if type(parametres) != list: raise "Wrong type for 'parametres' variable in MR parameters file : %s" % options.mr_parameters + if type(calcul) != list: raise "Wrong type for 'calcul' variable in MR parameters file : %s" % options.mr_parameters + + if options.objective == 'error': + if type(experience) != list: raise "For error objective output, the 'experience' variable must be a list of arrays" + if type(poids) not in [list, tuple, NP.ndarray]: raise "The 'poids' variable must be a list or an array" + if len(poids) != len(experience): raise "'experience' and 'poids' lists must have the same lenght" + + + # MACR_RECAL parameters + objective = options.objective + objective_type = options.objective_type + gradient_type = options.gradient_type + + + # X0 : read from commandline flag or from file + if not os.path.isfile(options.input_file): options.input_file = None + if not (options.input or options.input_file): raise "Missing input parameters" + if (options.input and options.input_file): raise "Error : please use only one choice for input parameters definition" + + if options.input_file: + try: + f = open(options.input_file, 'r') + options.input = f.read() + f.close() + except: + raise "Can't read input parameters file : %s" % options.input_file + + # Extract X0 from text + try: + txt = options.input.strip() + txt = txt.replace(',', ' ') + txt = txt.replace(';', ' ') + X0 = [ float(x) for x in txt.split() ] + if type(X0) != list: raise "Wrong string for input parameters : %s" % options.input + except: + raise "Can't decode input parameters string : %s.\n It should be a comma separated list." % options.input + + + # dX : read from commandline flag or from file + dX = None + if options.gradient_type == 'no': + if (options.input_step or options.input_step_file): raise "You must set 'gradient_type' to another choice than 'no' or remove input step parameters from commandline" + else: + if not (options.input_step or options.input_step_file): raise "Missing input step parameters" + if (options.input_step and options.input_step_file): raise "Error : please use only one choice for input step parameters definition" + + if options.input_step_file: + try: + f = open(options.input_step_file, 'r') + options.input_step = f.read() + f.close() + except: + raise "Can't read file for discretisation step : %s" % options.input_step_file + + # Extract dX from text + try: + txt = options.input_step.strip() + txt = txt.replace(',', ' ') + txt = txt.replace(';', ' ') + dX = [ float(x) for x in txt.split() ] + if type(dX) != list: raise "Wrong string for discretisation step : %s" % options.input_step + except: + raise "Can't decode input parameters string : %s.\n It should be a comma separated list." % options.input_step + + + + + # ------------------------------------------------------------------------------------------------------------------ + # Execution des calculs (N+1 calculs distribues si dX est fourni) + # ------------------------------------------------------------------------------------------------------------------ + + # Repertoire contenant les resultats des calculs Aster (None = un rep temp est cree) + resudir = globals().get('resudir', None) + + # Affichage des parametres + lpara = [x[0] for x in parametres] + lpara.sort() + if info >=1: + lpara = [x[0] for x in parametres] + lpara.sort() + print "Calcul avec les parametres : \n%s" % Affiche_Param(lpara, X0) + + C = CALCULS_ASTER( + # MACR_RECAL inputs + parametres = parametres, + calcul = calcul, + experience = experience, + ) + + fonctionnelle, gradient = C.run( + # Current estimation + X0 = X0, + dX = dX, + + # Code_Aster installation + ASTER_ROOT = ASTER_ROOT, + as_run = as_run, + + # General + resudir = resudir, + clean = clean, + info = info, + + # Study + export = export, + +# # MACR_RECAL inputs +# parametres = parametres, +# calcul = calcul, +# experience = experience, + ) + + # ------------------------------------------------------------------------------------------------------------------ + # Calcul de l'erreur par rapport aux donnees experimentale + # ------------------------------------------------------------------------------------------------------------------ + if not isFromYacs: # Execution en mode EXTERNE uniquement + + # Calcul de l'erreur par rapport aux donnees experimentale + if objective == 'error': + E = CALC_ERROR( + experience = experience, + X0 = X0, + calcul = calcul, + poids = poids, + objective_type = objective_type, + info=info, + ) + + erreur = E.CalcError(C.Lcalc) + erreur, residu, A_nodim, A = E.CalcSensibilityMatrix(C.Lcalc, X0, dX=dX, pas=None) + + fonctionnelle = erreur + if gradient_type == 'normal': gradient = A + elif gradient_type == 'adim': gradient = A_nodim + else: raise "??" + + + + # ------------------------------------------------------------------------------------------------------------------ + # Ecriture des resultats + # ------------------------------------------------------------------------------------------------------------------ + if not isFromYacs: # Execution en mode EXTERNE uniquement + + # Fonctionnelle + if options.objective_type == 'float': + fonctionnelle = math.sqrt( NP.sum( [x**2 for x in fonctionnelle] ) ) + Ecriture_Fonctionnelle(output_file=options.output, type_fonctionnelle=options.objective_type, fonctionnelle=fonctionnelle) + + # Gradient + if gradient: Ecriture_Derivees(output_file=options.output_grad, derivees=gradient) + + + # ------------------------------------------------------------------------------------------------------------------ + # Affichages + # ------------------------------------------------------------------------------------------------------------------ + if info>=2: + print "\nFonctionnelle au point X0: \n%s" % str(fonctionnelle) + import pprint + if dX: + print "\nGradient au point X0:" + pprint.pprint(gradient) diff --git a/Aster/Cata/cataSTA10/Macro/simu_point_mat_ops.py b/Aster/Cata/cataSTA10/Macro/simu_point_mat_ops.py index ee3487b4..72f95a6b 100644 --- a/Aster/Cata/cataSTA10/Macro/simu_point_mat_ops.py +++ b/Aster/Cata/cataSTA10/Macro/simu_point_mat_ops.py @@ -1,4 +1,4 @@ -#@ MODIF simu_point_mat_ops Macro DATE 18/05/2009 AUTEUR PROIX J-M.PROIX +#@ MODIF simu_point_mat_ops Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -17,485 +17,638 @@ # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, # 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. # ====================================================================== -def simu_point_mat_ops(self, COMP_INCR, MATER, INCREMENT, NEWTON,CONVERGENCE,RECH_LINEAIRE,SIGM_INIT,EPSI_INIT,VARI_INIT, - COMP_ELAS,SUIVI_DDL,ARCHIVAGE,SIGM_IMPOSE,EPSI_IMPOSE,MODELISATION, ANGLE, MASSIF,INFO, **args) : + +def simu_point_mat_ops(self, MATER, INCREMENT,SIGM_IMPOSE,EPSI_IMPOSE,SIGM_INIT,EPSI_INIT,VARI_INIT,NEWTON,CONVERGENCE, + MASSIF,ANGLE,COMP_INCR,COMP_ELAS,INFO,ARCHIVAGE,SUPPORT, **args) : """Simulation de la reponse d'un point materiel""" ier = 0 # La macro compte pour 1 dans la numerotation des commandes self.set_icmd(1) + import math - 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') - LIRE_MAILLAGE = self.get_cmd('LIRE_MAILLAGE') + AFFE_CARA_ELEM = self.get_cmd('AFFE_CARA_ELEM') + AFFE_CHAR_MECA = self.get_cmd('AFFE_CHAR_MECA') AFFE_MATERIAU = self.get_cmd('AFFE_MATERIAU') AFFE_MODELE = self.get_cmd('AFFE_MODELE') - AFFE_CHAR_MECA = self.get_cmd('AFFE_CHAR_MECA') - AFFE_CARA_ELEM = self.get_cmd('AFFE_CARA_ELEM') - STAT_NON_LINE = self.get_cmd('STAT_NON_LINE') - POST_RELEVE_T = self.get_cmd('POST_RELEVE_T') - CALC_TABLE = self.get_cmd('CALC_TABLE') CALC_ELEM = self.get_cmd('CALC_ELEM') - CREA_CHAMP = self.get_cmd('CREA_CHAMP') - MODI_REPERE = self.get_cmd('MODI_REPERE') - MODI_MAILLAGE = self.get_cmd('MODI_MAILLAGE') + CALC_POINT_MAT = self.get_cmd('CALC_POINT_MAT') + CALC_TABLE = self.get_cmd('CALC_TABLE') + CREA_CHAMP = self.get_cmd('CREA_CHAMP') + CREA_RESU = self.get_cmd('CREA_RESU') + DEFI_FONCTION = self.get_cmd('DEFI_FONCTION') + IMPR_TABLE = self.get_cmd('IMPR_TABLE') + LIRE_MAILLAGE = self.get_cmd('LIRE_MAILLAGE') + MODI_MAILLAGE = self.get_cmd('MODI_MAILLAGE') + MODI_REPERE = self.get_cmd('MODI_REPERE') + POST_RELEVE_T = self.get_cmd('POST_RELEVE_T') + STAT_NON_LINE = self.get_cmd('STAT_NON_LINE') from Accas import _F from Utilitai.UniteAster import UniteAster - - + from Utilitai.Utmess import UTMESS + # -- Tests de cohérence __fonczero = DEFI_FONCTION(NOM_PARA = 'INST', VALE = ( 0,0, 10,0 ),PROL_DROITE='CONSTANT',PROL_GAUCHE='CONSTANT') - EPS={} SIG={} + itetra=0 + CMP_EPS=['EPXX','EPYY','EPZZ','EPXY','EPXZ','EPYZ'] + CMP_SIG=['SIXX','SIYY','SIZZ','SIXY','SIXZ','SIYZ'] - if MODELISATION=="3D": - nbsig=6 - CMP_EPS=['EPXX','EPYY','EPZZ','EPXY','EPXZ','EPYZ'] - CMP_SIG=['SIXX','SIYY','SIZZ','SIXY','SIXZ','SIYZ'] - else: - nbsig=3 - CMP_EPS=['EPXX','EPYY','EPXY'] - CMP_SIG=['SIXX','SIYY','SIXY'] - - if SIGM_IMPOSE: - SIG=SIGM_IMPOSE[0].cree_dict_valeurs(SIGM_IMPOSE[0].mc_liste) - for i in SIG.keys(): - if SIG[i]==None : SIG[i]=__fonczero - else: - for i in range(nbsig): - SIG[CMP_SIG[i]]=__fonczero - - if EPSI_IMPOSE: - EPS=EPSI_IMPOSE[0].cree_dict_valeurs(EPSI_IMPOSE[0].mc_liste) - else: - for i in range(nbsig): - EPS[CMP_EPS[i]]=None - - for index in range(nbsig): - iks=CMP_SIG[index] - ike=CMP_EPS[index] - if EPS[ike]!=None and SIG[iks] != __fonczero : - raise ' un seul parmi :' + str(iks) +' '+ str(ike) - -# print 'EPS=',EPS -# print 'SIG=',SIG -# -- Definition du maillage - if MODELISATION=="3D": - - texte_ma = """ - COOR_3D - P0 0.0 0.0 0.0 - P1 1.0 0.0 0.0 - P2 0.0 1.0 0.0 - P3 0.0 0.0 1.0 - FINSF - TRIA3 - F1 P0 P3 P2 - F2 P0 P1 P3 - F3 P0 P2 P1 - F4 P1 P2 P3 - FINSF - TETRA4 - VOLUME = P0 P1 P2 P3 - FINSF - GROUP_MA - TOUT VOLUME - FINSF - GROUP_NO - TOUT P1 P2 P0 P3 - FINSF - FIN - """ - - else : - - texte_ma = """ - COOR_2D - P0 0.0 0.0 - P1 1.0 0.0 - P2 0.0 1.0 - FINSF - SEG2 - S1 P2 P0 - S2 P0 P1 - S3 P1 P2 - FINSF - TRIA3 - VOLUME = P0 P1 P2 - FINSF - GROUP_MA - TOUT VOLUME - FINSF - GROUP_NO - TOUT P1 P2 P0 - FINSF - FIN - """ - - fi_mail = open('simu.mail','w') - fi_mail.write(texte_ma) - fi_mail.close() + if SUPPORT != None : + if SUPPORT=='ELEMENT': + itetra=1 + if itetra==0 : + if COMP_INCR != None : + lcomp = COMP_INCR.List_F()[0] + if lcomp['DEFORMATION'] != 'PETIT' : + itetra=1 + UTMESS('A','COMPOR2_1',valk=lcomp['DEFORMATION'] ) + elif COMP_ELAS != None : + lcomp = COMP_ELAS.List_F()[0] + if lcomp['DEFORMATION'] != 'PETIT' : + itetra=1 + UTMESS('A','COMPOR2_1',valk=lcomp['DEFORMATION'] ) + +#=============================================================== +# cas ou il n'y a pas d'élement fini : appel à CALC_POINT_MAT +#=============================================================== + if itetra == 0 : + + isig=0 + ieps=0 + nbsig=6 +# par défaut contraintes nulles + if SIGM_IMPOSE: + SIG=SIGM_IMPOSE[0].cree_dict_valeurs(SIGM_IMPOSE[0].mc_liste) + isig=1 + if EPSI_IMPOSE: + EPS=EPSI_IMPOSE[0].cree_dict_valeurs(EPSI_IMPOSE[0].mc_liste) + ieps=1 + + motscles={} +# verif + for index in range(nbsig): + iks=CMP_SIG[index] + ike=CMP_EPS[index] + inds=0 + inde=0 + if ieps : + if EPS[ike]!=None : + inde=1 + if isig : + if SIG[iks]!=None : + inds=1 + if inde*inds!=0 : + UTMESS('F','COMPOR2_2',valk=iks) + if inde==1 : + motscles[ike] = EPS[ike] + elif inds==1: + motscles[iks]= SIG[iks] + else: + motscles[iks]=__fonczero + +# Etat initial + etatinit=0 + if SIGM_INIT != None : + motscles['SIGM_INIT'] = SIGM_INIT.List_F() + if EPSI_INIT != None : + motscles['EPSI_INIT'] = EPSI_INIT.List_F() + if VARI_INIT != None : + motscles['VARI_INIT'] = VARI_INIT.List_F() + if NEWTON != None : + motscles['NEWTON'] = NEWTON.List_F() + if CONVERGENCE != None : + motscles['CONVERGENCE'] = CONVERGENCE.List_F() + if MASSIF != None : + motscles['MASSIF'] = MASSIF.List_F() + if COMP_INCR : + motscles['COMP_INCR'] = COMP_INCR.List_F() + if COMP_ELAS : + motscles['COMP_ELAS'] = COMP_ELAS.List_F() +# -- Deroulement du calcul + motscles['INCREMENT'] = INCREMENT.List_F() + + if args.has_key('NB_VARI_TABLE'): + if args['NB_VARI_TABLE'] != None: + motscles['NB_VARI_TABLE'] = args['NB_VARI_TABLE'] + + self.DeclareOut('REPONSE',self.sd) + __REP1 = CALC_POINT_MAT(INFO=INFO,MATER=MATER,ANGLE=ANGLE,**motscles) + + Titre='CALC_POINT_MAT' + if INFO==2 : + IMPR_TABLE(TABLE=__REP1) + +# on ne prend en compte que ARCHIVAGE / LIST_INST + + if ARCHIVAGE != None : + if ARCHIVAGE['LIST_INST'] != None : + lr8=ARCHIVAGE['LIST_INST'] + lr=lr8.Valeurs() + REPONSE=CALC_TABLE( TABLE=__REP1,TITRE=Titre, + ACTION=_F(OPERATION='FILTRE',NOM_PARA='INST', + VALE=lr,PRECISION=ARCHIVAGE['PRECISION']), + ) + else : + REPONSE=CALC_TABLE( TABLE=__REP1,TITRE=Titre, + ACTION=_F(OPERATION='TRI',NOM_PARA='INST'), + ) + else : + REPONSE=CALC_TABLE( TABLE=__REP1,TITRE=Titre, + ACTION=_F(OPERATION='TRI',NOM_PARA='INST'), + ) - UL = UniteAster() - umail = UL.Libre(action='ASSOCIER', nom='simu.mail' ) +#=============================================================== +# cas ou on fait le calcul sur un TETRA4 A UN SEUL POINT DE GAUSS +#=============================================================== + elif itetra==1 : - __MA = LIRE_MAILLAGE(UNITE=umail) - UL.EtatInit() - - - - if MODELISATION=="3D": - __MO = AFFE_MODELE( MAILLAGE = __MA, - AFFE=_F(MAILLE=('VOLUME','F1','F2','F3','F4'),PHENOMENE='MECANIQUE',MODELISATION='3D',)) -## ANGLE : rotation de ANGLE autour de Z uniquement, et seulement pour les déformations -## imposées. - if ANGLE != 0. : - __MA=MODI_MAILLAGE(reuse=__MA ,MAILLAGE = __MA ,ROTATION=_F(POIN_1=(0.,0. ),ANGL = ANGLE),) - c=Numeric.cos(ANGLE*Numeric.pi/180.) - s=Numeric.sin(ANGLE*Numeric.pi/180.) - __C_RIGIDE=AFFE_CHAR_MECA(MODELE=__MO, - DDL_IMPO=_F(NOEUD='P0',DX=0,DY=0.,DZ=0.), - LIAISON_DDL = ( - _F(NOEUD=('P1','P1','P2','P2'),DDL=('DX','DY','DX','DY'),COEF_MULT=(s,-c,c,s),COEF_IMPO=0), - _F(NOEUD=('P1','P3','P3'),DDL=('DZ','DX','DY'),COEF_MULT=(-1.0,c,s),COEF_IMPO=0), - _F(NOEUD=('P2','P3','P3'),DDL=('DZ','DX','DY'),COEF_MULT=(-1.0,-s,c),COEF_IMPO=0),),) - else : -# -- Mouvement de corps rigide - __C_RIGIDE = AFFE_CHAR_MECA(MODELE=__MO, - DDL_IMPO = _F(NOEUD = 'P0',DX = 0,DY = 0,DZ = 0), - LIAISON_DDL = ( - _F(NOEUD=('P2','P1'),DDL=('DX','DY'),COEF_MULT=(1,-1),COEF_IMPO=0), - _F(NOEUD=('P3','P1'),DDL=('DX','DZ'),COEF_MULT=(1,-1),COEF_IMPO=0), - _F(NOEUD=('P3','P2'),DDL=('DY','DZ'),COEF_MULT=(1,-1),COEF_IMPO=0),)) - else: - # MODELISATION 2D - __MO=AFFE_MODELE(MAILLAGE=__MA, - AFFE=_F(MAILLE=('VOLUME','S1','S2','S3'),PHENOMENE='MECANIQUE',MODELISATION=MODELISATION)) -## ANGLE : rotation de ANGLE autour de Z uniquement, et seulement pour les déformations -## imposées. - if ANGLE != 0. : - __MA=MODI_MAILLAGE(reuse=__MA ,MAILLAGE=__MA,ROTATION=_F(POIN_1=(0.,0.),ANGL=ANGLE),) - c=Numeric.cos(ANGLE*Numeric.pi/180.) - s=Numeric.sin(ANGLE*Numeric.pi/180.) - __C_RIGIDE = AFFE_CHAR_MECA(MODELE = __MO, - DDL_IMPO=_F(NOEUD='P0',DX=0,DY=0.), - LIAISON_DDL=(_F(NOEUD=('P1','P1','P2','P2'),DDL=('DX','DY','DX','DY'), - COEF_MULT=(s,-c,c,s),COEF_IMPO=0),),) - else : - __C_RIGIDE = AFFE_CHAR_MECA(MODELE = __MO, - DDL_IMPO = _F(NOEUD = 'P0',DX = 0,DY = 0), - LIAISON_DDL = (_F(NOEUD=('P2','P1'),DDL=('DX','DY'),COEF_MULT=(1,-1),COEF_IMPO=0),)) + EPS={} + SIG={} + MODELISATION="3D" + if args.has_key('MODELISATION'): + if args['MODELISATION'] != None: + MODELISATION=args['MODELISATION'] -# --MASSIF : orientation du materiau (monocristal, orthotropie) - if MASSIF: - ANGMAS=MASSIF[0].cree_dict_valeurs(MASSIF[0].mc_liste) - print "ANGMAS",ANGMAS - if ANGMAS["ANGL_REP"]==None : - __CARA=AFFE_CARA_ELEM(MODELE=__MO,MASSIF=_F(MAILLE='VOLUME',ANGL_EULER=ANGMAS["ANGL_EULER"]),); - else : - __CARA=AFFE_CARA_ELEM(MODELE=__MO,MASSIF=_F(MAILLE='VOLUME',ANGL_REP=ANGMAS["ANGL_REP"]),); - -# -- Chargement en deformation - - __E = [None]*nbsig - - __E[0] = AFFE_CHAR_MECA(MODELE = __MO, - LIAISON_OBLIQUE = _F(NOEUD='P1', DX=1, ANGL_NAUT=ANGLE)) - - __E[1] = AFFE_CHAR_MECA(MODELE = __MO, - LIAISON_OBLIQUE = _F(NOEUD='P2', DY=1, ANGL_NAUT=ANGLE)) - - if MODELISATION=="3D": - - __E[2] = AFFE_CHAR_MECA(MODELE = __MO, - LIAISON_OBLIQUE = _F(NOEUD='P3', DZ=1, ANGL_NAUT=ANGLE)) - - __E[3] = AFFE_CHAR_MECA(MODELE = __MO, - LIAISON_OBLIQUE = _F(NOEUD='P1', DY=1, ANGL_NAUT=ANGLE)) - - __E[4] = AFFE_CHAR_MECA(MODELE = __MO, - LIAISON_OBLIQUE = _F(NOEUD='P1', DZ=1, ANGL_NAUT=ANGLE)) - - __E[5] = AFFE_CHAR_MECA(MODELE = __MO, - LIAISON_OBLIQUE = _F(NOEUD='P2', DZ=1, ANGL_NAUT=ANGLE)) - - else: - c=Numeric.cos(ANGLE*Numeric.pi/180.) - s=Numeric.sin(ANGLE*Numeric.pi/180.) - __E[2] = AFFE_CHAR_MECA(MODELE = __MO, - LIAISON_OBLIQUE = _F(NOEUD='P1', DY=1, ANGL_NAUT=ANGLE),) - -# -- Chargement en contrainte - - __S = [None]*nbsig - - if MODELISATION=="3D": - - r33 = 3**-0.5 - __S[0] = AFFE_CHAR_MECA(MODELE = __MO,FORCE_FACE = ( - _F(MAILLE='F1', FX=-1), - _F(MAILLE='F4', FX= r33),)) - - __S[1] = AFFE_CHAR_MECA(MODELE = __MO,FORCE_FACE = ( - _F(MAILLE='F2', FY=-1), - _F(MAILLE='F4', FY= r33),)) - - __S[2] = AFFE_CHAR_MECA(MODELE = __MO,FORCE_FACE = ( - _F(MAILLE='F3', FZ=-1), - _F(MAILLE='F4', FZ= r33),)) - - __S[3] = AFFE_CHAR_MECA(MODELE = __MO,FORCE_FACE = ( - _F(MAILLE='F1', FY=-1), - _F(MAILLE='F2', FX=-1), - _F(MAILLE='F4', FX= r33, FY=r33),)) - - __S[4] = AFFE_CHAR_MECA(MODELE = __MO,FORCE_FACE = ( - _F(MAILLE='F1', FZ=-1), - _F(MAILLE='F3', FX=-1), - _F(MAILLE='F4', FX= r33, FZ=r33),)) - - __S[5] = AFFE_CHAR_MECA( MODELE = __MO, FORCE_FACE = ( - _F(MAILLE='F2', FZ=-1), - _F(MAILLE='F3', FY=-1), - _F(MAILLE='F4', FY= r33, FZ=r33), ) ) - - else: - r22 = 2**-0.5 - __S[0] = AFFE_CHAR_MECA(MODELE = __MO,FORCE_CONTOUR = ( - _F(MAILLE='S1', FX=-1), - _F(MAILLE='S3', FX= r22), )) - - __S[1] = AFFE_CHAR_MECA(MODELE = __MO,FORCE_CONTOUR = ( - _F(MAILLE='S2', FY=-1), - _F(MAILLE='S3', FY= r22), ) ) - - __S[2] = AFFE_CHAR_MECA(MODELE = __MO,FORCE_CONTOUR = ( - _F(MAILLE='S1', FY=-1), - _F(MAILLE='S2', FX=-1), - _F(MAILLE='S3', FX= r22, FY=r22), ) ) - -# -- Construction de la charge - - l_char = [ _F(CHARGE=__C_RIGIDE) ] - - for i in xrange(nbsig) : - ike=CMP_EPS[i] - if EPS[ike]: - l_char.append( _F(CHARGE=__E[i],FONC_MULT=EPS[ike]) ) - - for i in xrange(nbsig) : - iks=CMP_SIG[i] - l_char.append( _F(CHARGE=__S[i],FONC_MULT=SIG[iks]) ) - -# -- Materiau et modele - __CHMAT=AFFE_MATERIAU(MAILLAGE=__MA,AFFE = _F(MAILLE='VOLUME',MATER=MATER)) - -# Etat initial - SIGINI={} - VARINI={} - LCSIG=[] - LVSIG=[] - init_dico={} - etatinit=0 - -# --contraintes initiales - if SIGM_INIT: - etatinit=1 - SIGINI=SIGM_INIT[0].cree_dict_valeurs(SIGM_INIT[0].mc_liste) - for i in SIGINI.keys(): - if SIGINI[i]!=None : - LCSIG.append(i) - LVSIG.append(SIGINI[i]) - - __SIG_INIT=CREA_CHAMP(MAILLAGE=__MA,OPERATION='AFFE',TYPE_CHAM='CART_SIEF_R', - AFFE=_F(TOUT='OUI', NOM_CMP=LCSIG, VALE=LVSIG,)) - init_dico['SIGM']=__SIG_INIT - -# --variables internes initiales - if VARI_INIT: - etatinit=1 - lnomneu=[] - lnomvar=[] - VARINI=VARI_INIT[0].cree_dict_valeurs(VARI_INIT[0].mc_liste) - nbvari=len(VARINI['VALE']) - for i in range(nbvari): - lnomneu.append('X'+str(i+1)) - lnomvar.append('V'+str(i+1)) - - __NEUT=CREA_CHAMP(OPERATION='AFFE', TYPE_CHAM='CART_NEUT_R', MAILLAGE=__MA, - AFFE=_F( MAILLE ='VOLUME', NOM_CMP = lnomneu, VALE = VARINI['VALE'])) - - __VAR_INIT=CREA_CHAMP(MODELE=__MO,OPERATION='ASSE',TYPE_CHAM='ELGA_VARI_R', - ASSE=_F(TOUT='OUI',CHAM_GD=__NEUT,NOM_CMP=lnomneu,NOM_CMP_RESU=lnomvar)) - init_dico['VARI']=__VAR_INIT - - # --deformations initiales - if EPSI_INIT: - etatinit=1 - EPSINI={} - LCDEPL=[] - LNDEPL=[] - LVDEPL=[] - LIST_AFFE=[] - mon_dico={} - mon_dico["NOEUD"]='P0' - mon_dico["NOM_CMP"]=("DX","DY","DZ") - mon_dico["VALE"]=(0.,0.,0.) - LIST_AFFE.append(mon_dico) + if MODELISATION=="3D": + nbsig=6 + CMP_EPS=['EPXX','EPYY','EPZZ','EPXY','EPXZ','EPYZ'] + CMP_SIG=['SIXX','SIYY','SIZZ','SIXY','SIXZ','SIYZ'] + else: + nbsig=3 + CMP_EPS=['EPXX','EPYY','EPXY'] + CMP_SIG=['SIXX','SIYY','SIXY'] - EPSINI=EPSI_INIT[0].cree_dict_valeurs(EPSI_INIT[0].mc_liste) - mon_dico={} - mon_dico["NOEUD"]='P1' - mon_dico["NOM_CMP"]='DX' - mon_dico["VALE"]=EPSINI['EPXX'] - LIST_AFFE.append(mon_dico) - mon_dico={} - mon_dico["NOEUD"]='P2' - mon_dico["NOM_CMP"]='DY' - mon_dico["VALE"]=EPSINI['EPYY'] - LIST_AFFE.append(mon_dico) - if MODELISATION=="3D": - mon_dico={} - mon_dico["NOEUD"]='P3' - mon_dico["NOM_CMP"]='DZ' - mon_dico["VALE"]=EPSINI['EPZZ'] - LIST_AFFE.append(mon_dico) - mon_dico={} - mon_dico["NOEUD"]='P1' - mon_dico["NOM_CMP"]='DY' - mon_dico["VALE"]=EPSINI['EPXY'] - LIST_AFFE.append(mon_dico) + + if SIGM_IMPOSE: + SIG=SIGM_IMPOSE[0].cree_dict_valeurs(SIGM_IMPOSE[0].mc_liste) + for i in SIG.keys(): + if SIG[i]==None : SIG[i]=__fonczero + else: + for i in range(nbsig): + SIG[CMP_SIG[i]]=__fonczero + + if EPSI_IMPOSE: + EPS=EPSI_IMPOSE[0].cree_dict_valeurs(EPSI_IMPOSE[0].mc_liste) + else: + for i in range(nbsig): + EPS[CMP_EPS[i]]=None + + for index in range(nbsig): + iks=CMP_SIG[index] + ike=CMP_EPS[index] + if EPS[ike]!=None and SIG[iks] != __fonczero : + UTMESS('F','COMPOR2_3',valk= str(iks) +' '+ str(ike)) + +# -- Definition du maillage + if MODELISATION=="3D": + + texte_ma = """ + COOR_3D + P0 0.0 0.0 0.0 + P1 1.0 0.0 0.0 + P2 0.0 1.0 0.0 + P3 0.0 0.0 1.0 + FINSF + TRIA3 + F1 P0 P3 P2 + F2 P0 P1 P3 + F3 P0 P2 P1 + F4 P1 P2 P3 + FINSF + TETRA4 + VOLUME = P0 P1 P2 P3 + FINSF + GROUP_MA + TOUT VOLUME + FINSF + GROUP_NO + TOUT P1 P2 P0 P3 + FINSF + FIN + """ + + else : + + texte_ma = """ + COOR_2D + P0 0.0 0.0 + P1 1.0 0.0 + P2 0.0 1.0 + FINSF + SEG2 + S1 P2 P0 + S2 P0 P1 + S3 P1 P2 + FINSF + TRIA3 + VOLUME = P0 P1 P2 + FINSF + GROUP_MA + TOUT VOLUME + FINSF + GROUP_NO + TOUT P1 P2 P0 + FINSF + FIN + """ + + fi_mail = open('simu.mail','w') + fi_mail.write(texte_ma) + fi_mail.close() + + UL = UniteAster() + umail = UL.Libre(action='ASSOCIER', nom='simu.mail' ) + + __MA = LIRE_MAILLAGE(UNITE=umail) + UL.EtatInit() + + + + if MODELISATION=="3D": + __MO = AFFE_MODELE( MAILLAGE = __MA, + AFFE=_F(MAILLE=('VOLUME','F1','F2','F3','F4'),PHENOMENE='MECANIQUE',MODELISATION='3D',)) +## ANGLE : rotation de ANGLE autour de Z uniquement, et seulement pour les déformations +## imposées. + if ANGLE != 0. : + __MA=MODI_MAILLAGE(reuse=__MA ,MAILLAGE = __MA ,ROTATION=_F(POIN_1=(0.,0. ),ANGL = ANGLE),) + c=math.cos(ANGLE*math.pi/180.) + s=math.sin(ANGLE*math.pi/180.) + __C_RIGIDE=AFFE_CHAR_MECA(MODELE=__MO, + DDL_IMPO=_F(NOEUD='P0',DX=0,DY=0.,DZ=0.), + LIAISON_DDL = ( + _F(NOEUD=('P1','P1','P2','P2'),DDL=('DX','DY','DX','DY'),COEF_MULT=(s,-c,c,s),COEF_IMPO=0), + _F(NOEUD=('P1','P3','P3'),DDL=('DZ','DX','DY'),COEF_MULT=(-1.0,c,s),COEF_IMPO=0), + _F(NOEUD=('P2','P3','P3'),DDL=('DZ','DX','DY'),COEF_MULT=(-1.0,-s,c),COEF_IMPO=0),),) + else : +# -- Mouvement de corps rigide + __C_RIGIDE = AFFE_CHAR_MECA(MODELE=__MO, + DDL_IMPO = _F(NOEUD = 'P0',DX = 0,DY = 0,DZ = 0), + LIAISON_DDL = ( + _F(NOEUD=('P2','P1'),DDL=('DX','DY'),COEF_MULT=(1,-1),COEF_IMPO=0), + _F(NOEUD=('P3','P1'),DDL=('DX','DZ'),COEF_MULT=(1,-1),COEF_IMPO=0), + _F(NOEUD=('P3','P2'),DDL=('DY','DZ'),COEF_MULT=(1,-1),COEF_IMPO=0),)) + else: + # MODELISATION 2D + __MO=AFFE_MODELE(MAILLAGE=__MA, + AFFE=_F(MAILLE=('VOLUME','S1','S2','S3'),PHENOMENE='MECANIQUE',MODELISATION=MODELISATION)) +## ANGLE : rotation de ANGLE autour de Z uniquement, et seulement pour les déformations +## imposées. + if ANGLE != 0. : + __MA=MODI_MAILLAGE(reuse=__MA ,MAILLAGE=__MA,ROTATION=_F(POIN_1=(0.,0.),ANGL=ANGLE),) + c=math.cos(ANGLE*math.pi/180.) + s=math.sin(ANGLE*math.pi/180.) + __C_RIGIDE = AFFE_CHAR_MECA(MODELE = __MO, + DDL_IMPO=_F(NOEUD='P0',DX=0,DY=0.), + LIAISON_DDL=(_F(NOEUD=('P1','P1','P2','P2'),DDL=('DX','DY','DX','DY'), + COEF_MULT=(s,-c,c,s),COEF_IMPO=0),),) + else : + __C_RIGIDE = AFFE_CHAR_MECA(MODELE = __MO, + DDL_IMPO = _F(NOEUD = 'P0',DX = 0,DY = 0), + LIAISON_DDL = (_F(NOEUD=('P2','P1'),DDL=('DX','DY'),COEF_MULT=(1,-1),COEF_IMPO=0),)) + +# --MASSIF : orientation du materiau (monocristal, orthotropie) + if MASSIF: + ANGMAS=MASSIF[0].cree_dict_valeurs(MASSIF[0].mc_liste) + if ANGMAS["ANGL_REP"]==None : + __CARA=AFFE_CARA_ELEM(MODELE=__MO,MASSIF=_F(MAILLE='VOLUME',ANGL_EULER=ANGMAS["ANGL_EULER"]),); + else : + __CARA=AFFE_CARA_ELEM(MODELE=__MO,MASSIF=_F(MAILLE='VOLUME',ANGL_REP=ANGMAS["ANGL_REP"]),); + +# -- Chargement en deformation + + __E = [None]*nbsig + + __E[0] = AFFE_CHAR_MECA(MODELE = __MO, + LIAISON_OBLIQUE = _F(NOEUD='P1', DX=1, ANGL_NAUT=ANGLE)) + + __E[1] = AFFE_CHAR_MECA(MODELE = __MO, + LIAISON_OBLIQUE = _F(NOEUD='P2', DY=1, ANGL_NAUT=ANGLE)) + + if MODELISATION=="3D": + + __E[2] = AFFE_CHAR_MECA(MODELE = __MO, + LIAISON_OBLIQUE = _F(NOEUD='P3', DZ=1, ANGL_NAUT=ANGLE)) + + __E[3] = AFFE_CHAR_MECA(MODELE = __MO, + LIAISON_OBLIQUE = _F(NOEUD='P1', DY=1, ANGL_NAUT=ANGLE)) + + __E[4] = AFFE_CHAR_MECA(MODELE = __MO, + LIAISON_OBLIQUE = _F(NOEUD='P1', DZ=1, ANGL_NAUT=ANGLE)) + + __E[5] = AFFE_CHAR_MECA(MODELE = __MO, + LIAISON_OBLIQUE = _F(NOEUD='P2', DZ=1, ANGL_NAUT=ANGLE)) + + else: + c=math.cos(ANGLE*math.pi/180.) + s=math.sin(ANGLE*math.pi/180.) + __E[2] = AFFE_CHAR_MECA(MODELE = __MO, + LIAISON_OBLIQUE = _F(NOEUD='P1', DY=1, ANGL_NAUT=ANGLE),) + +# -- Chargement en contrainte + + __S = [None]*nbsig + + if MODELISATION=="3D": + + r33 = 3**-0.5 + __S[0] = AFFE_CHAR_MECA(MODELE = __MO,FORCE_FACE = ( + _F(MAILLE='F1', FX=-1), + _F(MAILLE='F4', FX= r33),)) + + __S[1] = AFFE_CHAR_MECA(MODELE = __MO,FORCE_FACE = ( + _F(MAILLE='F2', FY=-1), + _F(MAILLE='F4', FY= r33),)) + + __S[2] = AFFE_CHAR_MECA(MODELE = __MO,FORCE_FACE = ( + _F(MAILLE='F3', FZ=-1), + _F(MAILLE='F4', FZ= r33),)) + + __S[3] = AFFE_CHAR_MECA(MODELE = __MO,FORCE_FACE = ( + _F(MAILLE='F1', FY=-1), + _F(MAILLE='F2', FX=-1), + _F(MAILLE='F4', FX= r33, FY=r33),)) + + __S[4] = AFFE_CHAR_MECA(MODELE = __MO,FORCE_FACE = ( + _F(MAILLE='F1', FZ=-1), + _F(MAILLE='F3', FX=-1), + _F(MAILLE='F4', FX= r33, FZ=r33),)) + + __S[5] = AFFE_CHAR_MECA( MODELE = __MO, FORCE_FACE = ( + _F(MAILLE='F2', FZ=-1), + _F(MAILLE='F3', FY=-1), + _F(MAILLE='F4', FY= r33, FZ=r33), ) ) + + else: + r22 = 2**-0.5 + __S[0] = AFFE_CHAR_MECA(MODELE = __MO,FORCE_CONTOUR = ( + _F(MAILLE='S1', FX=-1), + _F(MAILLE='S3', FX= r22), )) + + __S[1] = AFFE_CHAR_MECA(MODELE = __MO,FORCE_CONTOUR = ( + _F(MAILLE='S2', FY=-1), + _F(MAILLE='S3', FY= r22), ) ) + + __S[2] = AFFE_CHAR_MECA(MODELE = __MO,FORCE_CONTOUR = ( + _F(MAILLE='S1', FY=-1), + _F(MAILLE='S2', FX=-1), + _F(MAILLE='S3', FX= r22, FY=r22), ) ) + +# -- Construction de la charge + + l_char = [ _F(CHARGE=__C_RIGIDE) ] + + for i in xrange(nbsig) : + ike=CMP_EPS[i] + if EPS[ike]: + l_char.append( _F(CHARGE=__E[i],FONC_MULT=EPS[ike]) ) + + for i in xrange(nbsig) : + iks=CMP_SIG[i] + l_char.append( _F(CHARGE=__S[i],FONC_MULT=SIG[iks]) ) + +# variables de commande + mcvarc=[] + if args.has_key('AFFE_VARC'): + if args['AFFE_VARC'] != None: + lvarc = args['AFFE_VARC'].List_F() + nbvarc=len(lvarc) + for ivarc in range(nbvarc) : + typech = 'NOEU_' + str(lvarc[ivarc]['NOM_VARC']) + '_F' + dico={} + __CHVARC=CREA_CHAMP(TYPE_CHAM=typech, + OPERATION='AFFE', + MAILLAGE=__MA, + AFFE=_F(MAILLE='VOLUME', + NOM_CMP=lvarc[ivarc]['NOM_VARC'], + VALE_F=lvarc[ivarc]['VALE_FONC'], + ), + ), + __LIST2 = INCREMENT.List_F()[0]['LIST_INST'] + __TEMP=CREA_RESU(OPERATION='AFFE',TYPE_RESU='EVOL_THER',NOM_CHAM='TEMP', + AFFE = _F(CHAM_GD = __CHVARC,LIST_INST = __LIST2,), + ) + dico["MAILLE"]='VOLUME' + dico["EVOL"]=__TEMP + dico["NOM_VARC"]=lvarc[ivarc]['NOM_VARC'] + if lvarc[ivarc]['VALE_REF'] != None: + dico["VALE_REF"]=lvarc[ivarc]['VALE_REF'] + mcvarc.append(dico) +# -- Materiau et modele + if len(mcvarc) > 0 : + __CHMAT=AFFE_MATERIAU(MAILLAGE=__MA,AFFE = _F(MAILLE='VOLUME',MATER=MATER), + AFFE_VARC=mcvarc, + ) + else : + __CHMAT=AFFE_MATERIAU(MAILLAGE=__MA,AFFE = _F(MAILLE='VOLUME',MATER=MATER)) + +# Etat initial + SIGINI={} + VARINI={} + LCSIG=[] + LVSIG=[] + init_dico={} + etatinit=0 + +# --contraintes initiales + if SIGM_INIT: + etatinit=1 + SIGINI=SIGM_INIT[0].cree_dict_valeurs(SIGM_INIT[0].mc_liste) + for i in SIGINI.keys(): + if SIGINI[i]!=None : + LCSIG.append(i) + LVSIG.append(SIGINI[i]) + + __SIG_INIT=CREA_CHAMP(MAILLAGE=__MA,OPERATION='AFFE',TYPE_CHAM='CART_SIEF_R', + AFFE=_F(TOUT='OUI', NOM_CMP=LCSIG, VALE=LVSIG,)) + init_dico['SIGM']=__SIG_INIT + +# --variables internes initiales + if VARI_INIT: + etatinit=1 + lnomneu=[] + lnomvar=[] + VARINI=VARI_INIT[0].cree_dict_valeurs(VARI_INIT[0].mc_liste) + nbvari=len(VARINI['VALE']) + for i in range(nbvari): + lnomneu.append('X'+str(i+1)) + lnomvar.append('V'+str(i+1)) + + __NEUT=CREA_CHAMP(OPERATION='AFFE', TYPE_CHAM='CART_NEUT_R', MAILLAGE=__MA, + AFFE=_F( MAILLE ='VOLUME', NOM_CMP = lnomneu, VALE = VARINI['VALE'])) + + __VAR_INIT=CREA_CHAMP(MODELE=__MO,OPERATION='ASSE',TYPE_CHAM='ELGA_VARI_R', + ASSE=_F(TOUT='OUI',CHAM_GD=__NEUT,NOM_CMP=lnomneu,NOM_CMP_RESU=lnomvar)) + init_dico['VARI']=__VAR_INIT + + # --deformations initiales + if EPSI_INIT: + etatinit=1 + EPSINI={} + LCDEPL=[] + LNDEPL=[] + LVDEPL=[] + LIST_AFFE=[] mon_dico={} - mon_dico["NOEUD"]='P2' - mon_dico["NOM_CMP"]='DX' - mon_dico["VALE"]=EPSINI['EPXY'] + mon_dico["NOEUD"]='P0' + mon_dico["NOM_CMP"]=("DX","DY","DZ") + mon_dico["VALE"]=(0.,0.,0.) LIST_AFFE.append(mon_dico) + + EPSINI=EPSI_INIT[0].cree_dict_valeurs(EPSI_INIT[0].mc_liste) mon_dico={} mon_dico["NOEUD"]='P1' - mon_dico["NOM_CMP"]='DZ' - mon_dico["VALE"]=EPSINI['EPXZ'] - LIST_AFFE.append(mon_dico) - mon_dico={} - mon_dico["NOEUD"]='P3' mon_dico["NOM_CMP"]='DX' - mon_dico["VALE"]=EPSINI['EPXZ'] + mon_dico["VALE"]=EPSINI['EPXX'] LIST_AFFE.append(mon_dico) mon_dico={} mon_dico["NOEUD"]='P2' - mon_dico["NOM_CMP"]='DZ' - mon_dico["VALE"]=EPSINI['EPYZ'] - LIST_AFFE.append(mon_dico) - mon_dico={} - mon_dico["NOEUD"]='P3' mon_dico["NOM_CMP"]='DY' - mon_dico["VALE"]=EPSINI['EPYZ'] + mon_dico["VALE"]=EPSINI['EPYY'] LIST_AFFE.append(mon_dico) - else: - mon_dico={} - mon_dico["NOEUD"]='P1', - mon_dico["NOM_CMP"]='DY' - mon_dico["VALE"]=EPSINI['EPXY'] - LIST_AFFE.append(mon_dico) - mon_dico={} - mon_dico["NOEUD"]='P2' - mon_dico["NOM_CMP"]='DX' - mon_dico["VALE"]=EPSINI['EPXY'] - LIST_AFFE.append(mon_dico) - __DEP_INI=CREA_CHAMP(MAILLAGE=__MA,OPERATION='AFFE',TYPE_CHAM='NOEU_DEPL_R',AFFE=LIST_AFFE) - init_dico['DEPL']=__DEP_INI + if MODELISATION=="3D": + mon_dico={} + mon_dico["NOEUD"]='P3' + mon_dico["NOM_CMP"]='DZ' + mon_dico["VALE"]=EPSINI['EPZZ'] + LIST_AFFE.append(mon_dico) + mon_dico={} + mon_dico["NOEUD"]='P1' + mon_dico["NOM_CMP"]='DY' + mon_dico["VALE"]=EPSINI['EPXY'] + LIST_AFFE.append(mon_dico) + mon_dico={} + mon_dico["NOEUD"]='P2' + mon_dico["NOM_CMP"]='DX' + mon_dico["VALE"]=EPSINI['EPXY'] + LIST_AFFE.append(mon_dico) + mon_dico={} + mon_dico["NOEUD"]='P1' + mon_dico["NOM_CMP"]='DZ' + mon_dico["VALE"]=EPSINI['EPXZ'] + LIST_AFFE.append(mon_dico) + mon_dico={} + mon_dico["NOEUD"]='P3' + mon_dico["NOM_CMP"]='DX' + mon_dico["VALE"]=EPSINI['EPXZ'] + LIST_AFFE.append(mon_dico) + mon_dico={} + mon_dico["NOEUD"]='P2' + mon_dico["NOM_CMP"]='DZ' + mon_dico["VALE"]=EPSINI['EPYZ'] + LIST_AFFE.append(mon_dico) + mon_dico={} + mon_dico["NOEUD"]='P3' + mon_dico["NOM_CMP"]='DY' + mon_dico["VALE"]=EPSINI['EPYZ'] + LIST_AFFE.append(mon_dico) + else: + mon_dico={} + mon_dico["NOEUD"]='P1', + mon_dico["NOM_CMP"]='DY' + mon_dico["VALE"]=EPSINI['EPXY'] + LIST_AFFE.append(mon_dico) + mon_dico={} + mon_dico["NOEUD"]='P2' + mon_dico["NOM_CMP"]='DX' + mon_dico["VALE"]=EPSINI['EPXY'] + LIST_AFFE.append(mon_dico) + __DEP_INI=CREA_CHAMP(MAILLAGE=__MA,OPERATION='AFFE',TYPE_CHAM='NOEU_DEPL_R',AFFE=LIST_AFFE) + init_dico['DEPL']=__DEP_INI + +# -- Deroulement du calcul + motscles={} + if COMP_INCR : + motscles['COMP_INCR'] = COMP_INCR.List_F() + if COMP_ELAS : + motscles['COMP_ELAS'] = COMP_ELAS.List_F() + + motscles['CONVERGENCE'] = CONVERGENCE.List_F() -# -- Deroulement du calcul - motscles={} - if COMP_INCR : - motscles['COMP_INCR'] = COMP_INCR.List_F() - if COMP_ELAS : - motscles['COMP_ELAS'] = COMP_ELAS.List_F() - motscles['CONVERGENCE'] = CONVERGENCE.List_F() - motscles['NEWTON'] = NEWTON.List_F() - if RECH_LINEAIRE : - motscles['RECH_LINEAIRE'] = RECH_LINEAIRE.List_F() - motscles['INCREMENT'] = INCREMENT.List_F() - - if SUIVI_DDL : - motscles['SUIVI_DDL'] = SUIVI_DDL.List_F() - - if ARCHIVAGE : - motscles['ARCHIVAGE'] = ARCHIVAGE.List_F() - - if etatinit == 1 : - - if MASSIF: - __EVOL1 = STAT_NON_LINE(INFO = INFO,CARA_ELEM=__CARA,MODELE = __MO,CHAM_MATER = __CHMAT, - ETAT_INIT=init_dico, EXCIT = l_char,**motscles) - else: - __EVOL1 = STAT_NON_LINE(INFO = INFO,MODELE = __MO,CHAM_MATER = __CHMAT, - ETAT_INIT=init_dico, EXCIT = l_char,**motscles) - - else: - - if MASSIF: - __EVOL1 = STAT_NON_LINE(INFO = INFO,MODELE = __MO, CARA_ELEM=__CARA,CHAM_MATER = __CHMAT, - EXCIT = l_char,**motscles) - else: - __EVOL1 = STAT_NON_LINE(INFO = INFO,MODELE = __MO, CHAM_MATER = __CHMAT, - EXCIT = l_char,**motscles) - - - __EVOL1 = CALC_ELEM(reuse = __EVOL1,RESULTAT = __EVOL1, - OPTION = ('SIEF_ELNO_ELGA','EPSI_ELNO_DEPL','VARI_ELNO_ELGA')) - - if MODELISATION=="3D": - angles=(ANGLE,0,0) - __EVOL=MODI_REPERE(RESULTAT=__EVOL1, MODI_CHAM=( - _F(NOM_CHAM='DEPL',NOM_CMP=('DX','DY','DZ'),TYPE_CHAM='VECT_3D',), - _F(NOM_CHAM='SIEF_ELNO_ELGA',NOM_CMP=('SIXX','SIYY','SIZZ','SIXY','SIXZ','SIYZ'),TYPE_CHAM='TENS_3D',), - _F(NOM_CHAM='EPSI_ELNO_DEPL',NOM_CMP=('EPXX','EPYY','EPZZ','EPXY','EPXZ','EPYZ'),TYPE_CHAM='TENS_3D',), - ), - DEFI_REPERE=_F(REPERE='UTILISATEUR',ANGL_NAUT=angles),); - else : - angles=ANGLE - __EVOL=MODI_REPERE(RESULTAT=__EVOL1,MODI_CHAM=( - _F(NOM_CHAM='DEPL',NOM_CMP=('DX','DY'),TYPE_CHAM='VECT_2D',), - _F(NOM_CHAM='SIEF_ELNO_ELGA',NOM_CMP=('SIXX','SIYY','SIZZ','SIXY'),TYPE_CHAM='TENS_2D',), - _F(NOM_CHAM='EPSI_ELNO_DEPL',NOM_CMP=('EPXX','EPYY','EPZZ','EPXY'),TYPE_CHAM='TENS_2D',), - ), - DEFI_REPERE=_F(REPERE='UTILISATEUR',ANGL_NAUT=angles),); - -# -- Recuperation des courbes - - __REP_VARI = POST_RELEVE_T(ACTION = ( - _F(INTITULE='VARI_INT',RESULTAT=__EVOL1,NOM_CHAM='VARI_ELNO_ELGA', - TOUT_CMP='OUI',OPERATION='EXTRACTION',NOEUD='P0'),)) - - - __REP_EPSI = POST_RELEVE_T(ACTION = ( - _F(INTITULE='EPSILON',RESULTAT=__EVOL,NOM_CHAM='EPSI_ELNO_DEPL', - TOUT_CMP='OUI',OPERATION='EXTRACTION',NOEUD = 'P0'),)) - - __REP_SIGM = POST_RELEVE_T(ACTION = ( - _F(INTITULE = 'SIGMA',RESULTAT = __EVOL,NOM_CHAM = 'SIEF_ELNO_ELGA', - TOUT_CMP = 'OUI',OPERATION = 'EXTRACTION',NOEUD = 'P0'),)) - - __REP_INV = POST_RELEVE_T(ACTION = ( - _F(INTITULE = 'INV',RESULTAT = __EVOL,NOM_CHAM = 'SIEF_ELNO_ELGA', - INVARIANT = 'OUI',OPERATION = 'EXTRACTION',NOEUD = 'P0'),)) - - __REP_INV=CALC_TABLE( TABLE=__REP_INV,reuse=__REP_INV, - ACTION=_F(OPERATION='EXTR',NOM_PARA=('INST','TRACE','VMIS'), ) ) - - self.DeclareOut('REPONSE',self.sd) + motscles['NEWTON'] = NEWTON.List_F() + + if args.has_key('RECH_LINEAIRE'): + if args['RECH_LINEAIRE'] != None: + motscles['RECH_LINEAIRE'] = args['RECH_LINEAIRE'].List_F() + + motscles['INCREMENT'] = INCREMENT.List_F() - REPONSE=CALC_TABLE( TABLE=__REP_EPSI,TITRE='TABLE ',ACTION=( - _F(OPERATION='COMB',TABLE=__REP_SIGM,NOM_PARA=('INST'), ), - _F(OPERATION='COMB',TABLE=__REP_INV ,NOM_PARA=('INST'), ), - _F(OPERATION='COMB',TABLE=__REP_VARI,NOM_PARA=('INST'), ),)) + if ARCHIVAGE : + motscles['ARCHIVAGE'] = ARCHIVAGE.List_F() + + if etatinit == 1 : + + if MASSIF: + __EVOL1 = STAT_NON_LINE(INFO = INFO,CARA_ELEM=__CARA,MODELE = __MO,CHAM_MATER = __CHMAT, + ETAT_INIT=init_dico, EXCIT = l_char,**motscles) + else: + __EVOL1 = STAT_NON_LINE(INFO = INFO,MODELE = __MO,CHAM_MATER = __CHMAT, + ETAT_INIT=init_dico, EXCIT = l_char,**motscles) + + else: + + if MASSIF: + __EVOL1 = STAT_NON_LINE(INFO = INFO,MODELE = __MO, CARA_ELEM=__CARA,CHAM_MATER = __CHMAT, + EXCIT = l_char,**motscles) + else: + __EVOL1 = STAT_NON_LINE(INFO = INFO,MODELE = __MO, CHAM_MATER = __CHMAT, + EXCIT = l_char,**motscles) + + + __EVOL1 = CALC_ELEM(reuse = __EVOL1,RESULTAT = __EVOL1, + OPTION = ('SIEF_ELNO_ELGA','EPSI_ELNO_DEPL','VARI_ELNO_ELGA')) + + if MODELISATION=="3D": + angles=(ANGLE,0,0) + __EVOL=MODI_REPERE(RESULTAT=__EVOL1, MODI_CHAM=( + _F(NOM_CHAM='DEPL',NOM_CMP=('DX','DY','DZ'),TYPE_CHAM='VECT_3D',), + _F(NOM_CHAM='SIEF_ELNO_ELGA',NOM_CMP=('SIXX','SIYY','SIZZ','SIXY','SIXZ','SIYZ'),TYPE_CHAM='TENS_3D',), + _F(NOM_CHAM='EPSI_ELNO_DEPL',NOM_CMP=('EPXX','EPYY','EPZZ','EPXY','EPXZ','EPYZ'),TYPE_CHAM='TENS_3D',), + ), + DEFI_REPERE=_F(REPERE='UTILISATEUR',ANGL_NAUT=angles),); + else : + angles=ANGLE + __EVOL=MODI_REPERE(RESULTAT=__EVOL1,MODI_CHAM=( + _F(NOM_CHAM='DEPL',NOM_CMP=('DX','DY'),TYPE_CHAM='VECT_2D',), + _F(NOM_CHAM='SIEF_ELNO_ELGA',NOM_CMP=('SIXX','SIYY','SIZZ','SIXY'),TYPE_CHAM='TENS_2D',), + _F(NOM_CHAM='EPSI_ELNO_DEPL',NOM_CMP=('EPXX','EPYY','EPZZ','EPXY'),TYPE_CHAM='TENS_2D',), + ), + DEFI_REPERE=_F(REPERE='UTILISATEUR',ANGL_NAUT=angles),); + +# -- Recuperation des courbes + + __REP_VARI = POST_RELEVE_T(ACTION = ( + _F(INTITULE='VARI_INT',RESULTAT=__EVOL1,NOM_CHAM='VARI_ELNO_ELGA', + TOUT_CMP='OUI',OPERATION='EXTRACTION',NOEUD='P0'),)) + + + __REP_EPSI = POST_RELEVE_T(ACTION = ( + _F(INTITULE='EPSILON',RESULTAT=__EVOL,NOM_CHAM='EPSI_ELNO_DEPL', + TOUT_CMP='OUI',OPERATION='EXTRACTION',NOEUD = 'P0'),)) + + __REP_SIGM = POST_RELEVE_T(ACTION = ( + _F(INTITULE = 'SIGMA',RESULTAT = __EVOL,NOM_CHAM = 'SIEF_ELNO_ELGA', + TOUT_CMP = 'OUI',OPERATION = 'EXTRACTION',NOEUD = 'P0'),)) + + __REP_INV = POST_RELEVE_T(ACTION = ( + _F(INTITULE = 'INV',RESULTAT = __EVOL,NOM_CHAM = 'SIEF_ELNO_ELGA', + INVARIANT = 'OUI',OPERATION = 'EXTRACTION',NOEUD = 'P0'),)) + + __REP_INV=CALC_TABLE( TABLE=__REP_INV,reuse=__REP_INV, + ACTION=_F(OPERATION='EXTR',NOM_PARA=('INST','TRACE','VMIS'), ) ) + + self.DeclareOut('REPONSE',self.sd) + + REPONSE=CALC_TABLE( TABLE=__REP_EPSI,TITRE='TABLE ',ACTION=( + _F(OPERATION='COMB',TABLE=__REP_SIGM,NOM_PARA=('INST'), ), + _F(OPERATION='COMB',TABLE=__REP_INV ,NOM_PARA=('INST'), ), + _F(OPERATION='COMB',TABLE=__REP_VARI,NOM_PARA=('INST'), ),)) return ier diff --git a/Aster/Cata/cataSTA10/Macro/test_fonction_ops.py b/Aster/Cata/cataSTA10/Macro/test_fonction_ops.py index d1aed4fb..8c4318d5 100644 --- a/Aster/Cata/cataSTA10/Macro/test_fonction_ops.py +++ b/Aster/Cata/cataSTA10/Macro/test_fonction_ops.py @@ -1,4 +1,4 @@ -#@ MODIF test_fonction_ops Macro DATE 16/11/2009 AUTEUR COURTOIS M.COURTOIS +#@ MODIF test_fonction_ops Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS # -*- coding: iso-8859-1 -*- # CONFIGURATION MANAGEMENT OF EDF VERSION # ====================================================================== @@ -21,23 +21,35 @@ import os +from Noyau.N_types import is_complex, is_str, is_enum + epsi = 1e-15 # Format -ligne_separatrice = 80*'-' -ligne_nappe = """ ---- NAPPE: %(nom_nappe)s, NOM_PARA: %(nom_para)s, PARA: %(vale_para)16.14f """ -ligne_fct = """ ---- FONCTION: %(nom_fct)s %(titre)s """ -ligne_ref = """REFERENCE: %(typ_ref)s %(version)s """ -ligne_res1 = """%(testOk)s %(nomPara)s %(critere)s %(erreur)9.3f %(pourcent)s VALE:%(valeur)20.13E""" -ligne_res2 = """ %(para)7.5E TOLE %(epsilon)9.3f %(pourcent)s REFE:%(refere)20.13E""" +ligne_fct_1 = """ ---- FONCTION %(nom_para)s""" +ligne_fct_11= """ ---- FONCTION %(nom_para)s TITRE """ +ligne_fct_2 = """ %(nom_fct)s %(val_para)s """ +ligne_fct_22= """ %(nom_fct)s %(val_para)s %(titre)s """ +ligne_fct_3 = """ %(refe)s %(legende)s %(valref)s %(valcal)s %(erreur)s %(tole)s """ +ligne_fct_4 = """ %(testOk)s %(refe)s %(legende)s %(valref)s %(valcal)s %(erreur)s %(tole)s """ + +ligne_nap_1 = """ ---- NAPPE %(nom_para_0)s %(nom_para)s """ +ligne_nap_2 = """ %(nom_nap)s %(val_para_0)s %(val_para)s""" -ligne_res1C = """%(testOk)s %(nomPara)s %(critere)s %(erreur)9.3f %(pourcent)s VALE:%(valR)20.13E %(valI)20.13E""" -ligne_res2C = """ %(para)7.5E TOLE %(epsilon)9.3f %(pourcent)s REFE:%(refR)20.13E %(refI)20.13E""" +ligne_att_1 = """ ---- %(nom)s %(nom_attr)s %(nom_para)s %(vale)s """ +ligne_att_2 = """ ---- %(nom)s %(nom_attr)s %(vale)s """ +ligne_att_11= """ %(nom)s %(nom_attr)s %(nom_para)s %(vale)s """ +ligne_att_22= """ %(nom)s %(nom_attr)s %(vale)s """ +ligne_att_3 = """ %(testOk)s TEST_ATTRIBUTS """ + +ligne_separatrice = 80*'-' -ligne_res_attr = """%(testOk)s %(nomPara)s VALE:%(valPara)s""" -ligne_res_att2 = """ REFE:%(valeRefe)s""" +ligne_intspc = """ ---- INTERSPECTRE %(nom_para)s""" +ligne_intspc_1 = """ %(nom)s %(val_para)s""" -ligne_intspc = """ ---- INTERSPECTRE: %(nom_intspc)s""" +list_fct = ['REFERENCE','LEGENDE','VALE_REF','VALE_CAL','ERREUR','TOLE'] +list_attr = ['ATTR','PARA','VALE'] + def TesterValeur(nomPara,valPu,valRef,res,epsi,crit,sSigne): """ @@ -47,7 +59,7 @@ def TesterValeur(nomPara,valPu,valRef,res,epsi,crit,sSigne): isTestOk = 0 vtc = valRef[0] - if type(vtc) in (list, tuple): + if is_enum(vtc): assert( (vtc[0]=='RI')|(vtc[0]=='MP' ) ) if vtc[0]=='RI': vtc = vtc[1]+1j*vtc[2] @@ -55,7 +67,7 @@ def TesterValeur(nomPara,valPu,valRef,res,epsi,crit,sSigne): vtc = vtc[1]*cmath.exp(1j*math.pi*vtc[2]/180) if sSigne == 'OUI': res = abs(res) - if type(valRef[0]) == complex: + if is_complex(valRef[0]): vtc = abs(vtc) # Recherche de la valeur la plus proche de la valeur calculee @@ -64,13 +76,13 @@ def TesterValeur(nomPara,valPu,valRef,res,epsi,crit,sSigne): curI = 0 for i in range(len(valRef)): vtc = valRef[i] - if type(vtc) in (list, tuple): + if is_enum(vtc): assert( (vtc[0]=='RI')|(vtc[0]=='MP' ) ) if vtc[0]=='RI': vtc = vtc[1]+1j*vtc[2] else: vtc = vtc[1]*cmath.exp(1j*math.pi*vtc[2]/180) - if sSigne == 'OUI' and type(vtc) == complex: + if sSigne == 'OUI' and is_complex(vtc): vtc = abs(vtc) valTmp = abs(res-vtc) if valTmp < minTmp: @@ -78,13 +90,13 @@ def TesterValeur(nomPara,valPu,valRef,res,epsi,crit,sSigne): curI = i vtc = valRef[curI] - if type(vtc) in (list, tuple): + if is_enum(vtc): assert( (vtc[0]=='RI')|(vtc[0]=='MP' ) ) if vtc[0]=='RI': vtc = vtc[1]+1j*vtc[2] else: vtc = vtc[1]*cmath.exp(1j*math.pi*vtc[2]/180) - if sSigne == 'OUI' and type(vtc) == complex: + if sSigne == 'OUI' and is_complex(vtc): vtc = abs(vtc) testOk = 'NOOK' @@ -95,7 +107,7 @@ def TesterValeur(nomPara,valPu,valRef,res,epsi,crit,sSigne): if crit[0:4] == 'RELA': isTestOk = ( abs(res-vtc) <= epsi*abs(vtc) ) if vtc != 0: - if type(res) == complex or type(vtc) == complex: + if is_complex(res) or is_complex(vtc): err = abs(res - vtc)/abs(vtc)*100 else: err = (res - vtc)/vtc*100 @@ -106,7 +118,7 @@ def TesterValeur(nomPara,valPu,valRef,res,epsi,crit,sSigne): pourcent = '%' else: isTestOk = ( abs(res-vtc) <= epsi ) - if type(res) == complex or type(vtc) == complex: + if is_complex(res) or is_complex(vtc): err = abs(res - vtc) else: err = res - vtc @@ -115,7 +127,125 @@ def TesterValeur(nomPara,valPu,valRef,res,epsi,crit,sSigne): return {'testOk' : testOk, 'erreur' : err, 'epsilon' : curEps, 'valeurRef' :vtc} -def AfficherResultat(dicoValeur, nomPara, crit, res, valPu, txt): + +def RoundValues(type,res,vtc,err,curEps): + """ + Effectue des troncatures en fonctions des valeurs réelles fournies + et retourne eventuellement des valeurs sans exposant + """ + #valeur calculee, valeur de reference: + #------------------------------------ + if type=='R': + res2 = """%20.15E """%res + vtc2 = """%20.15E """%vtc + + # détermination du nombre de décimales à considérer : ndec + ndec=0 + ii=res2.find('E') + sgExpoRes=res2[ii+1:ii+2] + expoRes=int(res2[ii+2:ii+4]) + ii=vtc2.find('E') + sgExpoVtc=vtc2[ii+1:ii+2] + expoVtc=nexpo=int(res2[ii+2:ii+4]) + # si les signes des exposants diffèrent : ndec = 6 + if sgExpoRes != sgExpoVtc : ndec = 6 + # si les signes des valeurs diffèrent : ndec = 6 + if res*vtc<0 : ndec = 6 + #si les exposants diffèrent : ndec = 6 + if expoRes!=expoVtc : ndec = 6 + #position de la première décimale différente : posD + if ndec == 0 : + kk=0 + for k in range(len(res2)): + if res2[k]==' ':continue + if res2[k]==vtc2[k]: + kk=kk+1 + continue; + break; + if kk==0: + ndec=6 + else: + posD=kk-1 + ndec=min(14,posD+2) + #on supprime les zéros inutiles + if ndec==14: + i1=res2.find('E');i2=res2.find('.'); + kk=0 + for k in range(i1-1,i2,-1): + if res2[k]=='0' and res2[k]==vtc2[k]: + kk=kk+1 + continue + break + if kk>0: ndec=min(14,i1-kk-i2) + #troncatures + chndec="""%20."""+str(ndec)+"""E""" + rest=chndec%res + rest=rest.strip() + vtct=chndec%vtc + vtct=vtct.strip() + + #écriture éventuelle sans exposant +# if(sgExpoRes=='+'): +# if(ndec>=expoRes): +# chdiff="""%20."""+str(min(1,ndec-expoRes))+"""f""" +# resr=chdiff%res +# resr=resr.strip() +# vtcr=chdiff%vtc +# vtcr=vtcr.strip() +# else: +# resr=rest +# vtcr=vtct +# else: +# if(ndec+expoRes)<=12: +# chadd="""%20."""+str(ndec+expoRes-1)+"""f""" +# resr=chadd%res +# resr=resr.strip() +# vtcr=chadd%vtc +# vtcr=vtcr.strip() +# else: +# resr=rest +# vtcr=vtct + if(abs(res)>=0.01 and abs(res)<100000): + chdiff="""%20."""+str(ndec)+"""f""" + resr=chdiff%res + resr=resr.strip() + else: + resr=rest.strip() + + if(abs(vtc)>=0.01 and abs(vtc)<100000): + chdiff="""%20."""+str(ndec)+"""f""" + vtcr=chdiff%vtc + vtcr=vtcr.strip() + else: + vtcr=vtct.strip() + + + + + # erreur et tolerance: + #-------------------- + listEpsiOut=[]; + listEpsiIn=[err,curEps]; + for erin in listEpsiIn: + err2 = ("""%5.1E """%(abs(erin))).strip() + chdiff="""%5.1f""" + ii=err2.find('E') + expo=err2[ii+2:ii+4] + sg=err2[ii+1:ii+2] + nexpo=int(expo) + if(abs(erin)>0.01 and abs(erin)<100000): + #listEpsiOut.append((str(abs(erin)).strip())[:nexpo+2]) + listEpsiOut.append((chdiff%abs(erin)).strip()) + else: + listEpsiOut.append(err2) + + errr=listEpsiOut[0] + curEpsr=listEpsiOut[1] + + return (resr,vtcr,errr,curEpsr) + + +def AfficherResultat(dicoValeur, nomPara, ref, legende, crit, res, valPu, txt): """ Gestion de l'affichage par ajout de texte au tableau txt passe en parametre @@ -128,33 +258,72 @@ def AfficherResultat(dicoValeur, nomPara, crit, res, valPu, txt): pourcent = ' ' if crit[0:4] == 'RELA': pourcent = '%' - - # Ajout du texte en fonction du resultat - espace = (12 - len(nomPara))*' ' - current = { 'testOk' : testOk, - 'nomPara' : nomPara+espace, - 'critere' : crit[0:4], - 'erreur' : err, - 'pourcent': pourcent} - if type(res) != complex: - current['valeur'] = res - txt.append(ligne_res1 % current) + + if is_complex(res): + if not is_complex(vtc): + vtc0=complex(vtc,0) + else: + vtc0=vtc + resr,vtcr,errr,curEpsr=RoundValues('R',res.real,vtc0.real,err,curEps) + resc,vtcc,errr,curEpsr=RoundValues('R',res.imag,vtc0.imag,err,curEps) else: - current['valR'] = res.real - current['valI'] = res.imag - txt.append(ligne_res1C % current) - - current = { 'para' : valPu, - 'epsilon' : curEps, - 'pourcent': pourcent} - if type(vtc) != complex: - current['refere'] = vtc - txt.append(ligne_res2 % current) + vtc0=vtc + res2,vtc2,errr,curEpsr=RoundValues('R',res,vtc0,err,curEps) + + if is_complex(res): + if(res.imag<0): + val_cal=resr.upper()+resc.upper()+'j' + else: + val_cal=resr.upper()+'+'+resc.upper()+'j' + else: + val_cal=res2.upper() + + + if is_complex(vtc0): + if(vtc0.imag<0): + val_ref=vtcr.upper()+vtcc.upper()+'j' + else: + val_ref=vtcr.upper()+'+'+vtcc.upper()+'j' else: - current['refR'] = vtc.real - current['refI'] = vtc.imag - txt.append(ligne_res2C % current) + val_ref=vtc2.upper() + + espace = (len(val_ref)-8)*' ' + chvalref='VALE_REF'+espace + espace = (len(val_cal)-8)*' ' + chvalcal='VALE_CAL'+espace + if(len(val_ref)<=16):nvref=16 + elif(len(val_ref)<=24):nvref=24 + elif(len(val_ref)<=36):nvref=36 + else: nvref=48 + + if(len(val_cal)<=16):nvcal=16 + elif(len(val_cal)<=24):nvcal=24 + elif(len(val_cal)<=36):nvcal=36 + else: nvcal=48 + + # Ajout du texte en fonction du resultat: ligne 3 + current = { 'refe' : list_fct[0]+(16 - len(list_fct[0]))*' ', + 'legende' : list_fct[1]+(16 - len(list_fct[1]))*' ', + 'valref' : list_fct[2]+(nvref - len(list_fct[2]))*' ', + 'valcal' : list_fct[3]+(nvcal - len(list_fct[3]))*' ', + 'erreur' : list_fct[4]+(16 - len(list_fct[4]))*' ', + 'tole' : list_fct[5]+(16 - len(list_fct[5]))*' ', + } + txt.append(ligne_fct_3 % current) + + # Ajout du texte en fonction du resultat : ligne 4 + current = { 'testOk' : testOk, + 'refe' : ref+(16 - len(ref))*' ', + 'legende' : legende+(16 - len(legende))*' ', + 'valref' : val_ref+(nvref - len(val_ref))*' ', + 'valcal' : val_cal+(nvcal - len(val_cal))*' ', + 'erreur' : str(errr)+pourcent+(16 - len(str(errr)+pourcent))*' ', + 'tole' : str(curEpsr)+pourcent+(16 - len(str(curEpsr)+pourcent))*' ', + } + txt.append(ligne_fct_4 % current) + txt.append(' ') + # ----------------------------------------------------------------------------- def test_fonction_ops(self,TEST_NOOK,VALEUR,ATTRIBUT,TABL_INTSP,**args): """ @@ -201,10 +370,13 @@ def test_fonction_ops(self,TEST_NOOK,VALEUR,ATTRIBUT,TABL_INTSP,**args): ver = None if ref == 'NON_REGRESSION': ver = dres['VERSION'] + legende = dres['LEGENDE'] + if legende == None: + legende='XXXX' nomfct = fct.nomj.nomj # Transformation de nompara en liste - if (not type(nompara) in (list, tuple)) and nompara != None: + if (not is_enum(nompara)) and nompara != None: nompara = [nompara,] bcle = [] @@ -215,7 +387,7 @@ def test_fonction_ops(self,TEST_NOOK,VALEUR,ATTRIBUT,TABL_INTSP,**args): bcle = [fct,] else: pres_sensi = 1 - if not type(sensi) in (list, tuple): + if not is_enum(sensi): bcle = [sensi,] for ps in bcle: @@ -227,14 +399,14 @@ def test_fonction_ops(self,TEST_NOOK,VALEUR,ATTRIBUT,TABL_INTSP,**args): if pres_sensi == 1: ncomp = self.jdc.memo_sensi.get_nocomp(fct.nom, ps.nom) lafonc = self.jdc.memo_sensi.d_sd[ncomp] - titre = ' ... SENSIBILITE AU PARAMETRE '+ps.nomj.nomj + titre = 'SENSIBILITE AU PARAMETRE '+ps.nomj.nomj else: lafonc = ps res = 0. typeFct = '' valpu = dres['VALE_PARA'] - if not type(valpu) in (list, tuple): valpu = [valpu,] + if not is_enum(valpu): valpu = [valpu,] valref = None if (type(lafonc) == formule_c) or (type(lafonc) == fonction_c): @@ -242,9 +414,9 @@ def test_fonction_ops(self,TEST_NOOK,VALEUR,ATTRIBUT,TABL_INTSP,**args): else: valref = dres['VALE_REFE'] # L'enjeu est de transformer valref en tableau - if not type(valref) in (list, tuple): valref = [valref,] + if not is_enum(valref): valref = [valref,] else: - if type(valref[0]) == str: + if is_str(valref[0]): valref = [valref,] intervalle = dres['INTERVALLE'] @@ -254,7 +426,7 @@ def test_fonction_ops(self,TEST_NOOK,VALEUR,ATTRIBUT,TABL_INTSP,**args): # - "fonction" sur un intervalle # - "formule", # - "fonction" ou "nappe" - if (type(lafonc) == (fonction_sdaster)) and intervalle != None: + if (type(lafonc) == fonction_sdaster) and intervalle != None: fctProl = lafonc.PROL.get() prolG = 'rien' if fctProl[4][0:1] == 'C': @@ -293,7 +465,7 @@ def test_fonction_ops(self,TEST_NOOK,VALEUR,ATTRIBUT,TABL_INTSP,**args): # On cherche les valeurs de reference passees a TEST_FONCTION et # on les trie grace a ceux de la formule paramFormule = lafonc.Parametres()['NOM_PARA'] - if not type(paramFormule) in (list, tuple): + if not is_enum(paramFormule): paramFormule = [paramFormule,] if nompara[0] == '': nompara = paramFormule @@ -394,33 +566,61 @@ def test_fonction_ops(self,TEST_NOOK,VALEUR,ATTRIBUT,TABL_INTSP,**args): # Construction de l'affiche du resultat current = {} + + nomLastPara = nompara[len(nompara)-1] + valLastPara = valpu[len(valpu)-1] if (typeFct == 'nappe'): - current['nom_nappe'] = nomfct - current['nom_para'] = nompu - current['vale_para'] = valpu[0] - txt.append(ligne_nappe % current) + + #ligne 1 + nb_espace = 16-len(str(nompu)) + espace = nb_espace*' ' + current['nom_para_0'] = str(nompu)+espace + nb_espace = 16-len(str(nomLastPara)) + espace = nb_espace*' ' + current['nom_para'] = str(nomLastPara)+espace + txt.append(ligne_nap_1 % current) + + #ligne 2 + current = {} + nb_espace = 16-len(nomfct) + espace = nb_espace*' ' + current['nom_nap'] = nomfct+espace + nb_espace = 16-len(str(valpu[0])) + espace = nb_espace*' ' + current['val_para_0'] = str(valpu[0])+espace + nb_espace = 16-len(str(valLastPara)) + espace = nb_espace*' ' + current['val_para'] = str(valLastPara)+espace + txt.append(ligne_nap_2 % current) + + else: - nb_espace = 19-len(nomfct) + + #ligne 1 + nb_espace = 16-len(str(nomLastPara)) + espace = nb_espace*' ' + current['nom_para'] = str(nomLastPara)+espace + if(len(titre)>1):txt.append(ligne_fct_11% current) + else:txt.append(ligne_fct_1% current) + + #ligne 2 + current = {} + nb_espace = 16-len(nomfct) espace = nb_espace*' ' current['nom_fct'] = nomfct+espace - current['titre'] = titre - txt.append(ligne_fct % current) - - current = {} - if ref != None: - current['typ_ref'] = ref - if ver != None: - current['version'] = 'VERSION: '+ver + nb_espace = 16-len(str(valLastPara)) + espace = nb_espace*' ' + current['val_para'] = str(valLastPara)+espace + if(len(titre)>1): + nb_espace = 33-len(titre) + espace = nb_espace*' ' + current['titre'] = titre + txt.append(ligne_fct_22 % current) else: - current['version'] = '' - else: - a_ecrire = 'REFERENCE: NON_DEFINI' - current['typ_ref'] = 'NON_DEFINI' - current['version'] = '' - txt.append(ligne_ref % current) + txt.append(ligne_fct_2 % current) + + if ref == None: ref = 'NON_DEFINI' - nomLastPara = nompara[len(nompara)-1] - valLastPara = valpu[len(valpu)-1] # Test des valeurs calculees curDict=TesterValeur(nomLastPara,valLastPara,valref,res,epsi,crit,ssigne) @@ -430,7 +630,7 @@ def test_fonction_ops(self,TEST_NOOK,VALEUR,ATTRIBUT,TABL_INTSP,**args): if testOk == ' OK ': txt.append('NOOK PAS DE CHANCE LE TEST EST CORRECT !!!') else: - AfficherResultat(curDict, nomLastPara, crit, res, valLastPara, txt) + AfficherResultat(curDict, nomLastPara, ref, legende, crit, res, valLastPara, txt) elif ier == 120: txt.append(' OK PARAMETRE EN DOUBLE') elif ier == 130: @@ -443,9 +643,11 @@ def test_fonction_ops(self,TEST_NOOK,VALEUR,ATTRIBUT,TABL_INTSP,**args): if ier != 0: txt.append('NOOK PB INTERPOLATION. VOIR MESSAGE CI-DESSUS') else: - AfficherResultat(curDict,nomLastPara,crit,res,valLastPara,txt) + AfficherResultat(curDict,nomLastPara,ref,legende,crit,res,valLastPara,txt) if ATTRIBUT != None: + first_affiche_ligne1=True; + resu_test_attr=' OK ' # Boucle sur le mot-cle ATTRIBUT for attr in ATTRIBUT: dres = attr.cree_dict_valeurs(attr.mc_liste) @@ -542,47 +744,62 @@ def test_fonction_ops(self,TEST_NOOK,VALEUR,ATTRIBUT,TABL_INTSP,**args): if TEST_NOOK == 'OUI': if testOk == ' OK ': testOk = 'NOOK' else: testOk = ' OK ' - + if testOk=='NOOK':resu_test_attr='NOOK' + # Construction de l'affichage nomFct = fonction.nomj.nomj + + # ligne 1 (affichée qu'à la première occurrence) current = {} - if typeFct == 'NAPPE': - current['nom_nappe'] = nomFct - current['nom_para'] = nompu - current['vale_para'] = para - txt.append(ligne_nappe % current) - else: - nb_espace = 19-len(nomFct) - espace = nb_espace*' ' - current['nom_fct'] = nomFct+espace - current['titre'] = '' - txt.append(ligne_fct % current) - - current = {} - if ref != None: - current['typ_ref'] = ref - if ver != None: - current['version'] = 'VERSION: '+ver - else: - current['version'] = '' - else: - a_ecrire = 'REFERENCE: NON_DEFINI' - current['typ_ref'] = 'NON_DEFINI' - current['version'] = '' - txt.append(ligne_ref % current) + if first_affiche_ligne1 : + first_affiche_ligne1=False + if typeFct == 'NAPPE': + nb_espace = 16-len('NAPPE') + espace = nb_espace*' ' + current['nom'] = 'NAPPE'+espace + else: + nb_espace = 16-len('FONCTION') + espace = nb_espace*' ' + current['nom'] = 'FONCTION'+espace + + nb_espace = 16-len(list_attr[0]) + espace = nb_espace*' ' + current['nom_attr'] = list_attr[0]+espace + if typeFct == 'NAPPE': + nb_espace = 16-len(list_attr[1]) + espace = nb_espace*' ' + current['nom_para'] = list_attr[1]+espace + nb_espace = 16-len(list_attr[2]) + espace = nb_espace*' ' + current['vale'] = list_attr[2]+espace + if typeFct == 'NAPPE': + txt.append(ligne_att_1 % current) + else: + txt.append(ligne_att_2 % current) + # ligne 2 current = {} - nb_espace = 27-len(nomAttr) + nb_espace = 16-len(nomFct) espace = nb_espace*' ' - current['testOk'] = testOk - current['nomPara'] = nomAttr+espace - current['valPara'] = nompu - txt.append(ligne_res_attr % current) - - current = {} - current['valeRefe'] = valAttrRef - txt.append(ligne_res_att2 % current) - + current['nom'] = nomFct+espace + nb_espace = 16-len(nomAttr) + espace = nb_espace*' ' + current['nom_attr'] = nomAttr+espace + if typeFct == 'NAPPE': + nb_espace = 16-len(str(para)) + espace = nb_espace*' ' + current['nom_para'] = str(para)+espace + nb_espace = 16-len(nompu) + espace = nb_espace*' ' + current['vale'] = nompu+espace + if typeFct == 'NAPPE': + txt.append(ligne_att_11 % current) + else: + txt.append(ligne_att_22 % current) + current = {} + current['testOk'] = resu_test_attr + txt.append(ligne_att_3 % current) + if TABL_INTSP != None: # Boucle sur interspectres for intSpec in TABL_INTSP: @@ -593,7 +810,9 @@ def test_fonction_ops(self,TEST_NOOK,VALEUR,ATTRIBUT,TABL_INTSP,**args): ver = dres['VERSION'] crit = dres['CRITERE'] epsi = dres['PRECISION'] - + legende = dres['LEGENDE'] + if legende == None: + legende='XXXX' table = dres['INTE_SPEC'] dataTable = table.EXTR_TABLE().values() @@ -689,22 +908,25 @@ def test_fonction_ops(self,TEST_NOOK,VALEUR,ATTRIBUT,TABL_INTSP,**args): fctIntSp = t_fonction_c(lx, map(complex,lr,li),dico,nomFctC) # Affichage + + # ligne 1 current = {} - current['nom_intspc'] = nomFctC + nb_espace = 16-len(fctProl[2].strip()) + espace = nb_espace*' ' + current['nom_para'] = fctProl[2].strip()+espace txt.append(ligne_intspc % current) + # ligne 2 current = {} - if ref != None: - current['typ_ref'] = ref - if ver != None: - current['version'] = 'VERSION: '+ver - else: - current['version'] = '' - else: - a_ecrire = 'REFERENCE: NON_DEFINI' - current['typ_ref'] = 'NON_DEFINI' - current['version'] = '' - txt.append(ligne_ref % current) + nb_espace = 19-len(nomFctC.strip()) + espace = nb_espace*' ' + current['nom'] = nomFctC.strip()+espace + nb_espace = 16-len(str(valePara)) + espace = nb_espace*' ' + current['val_para'] = str(valePara)+espace + txt.append(ligne_intspc_1 % current) + + if ref == None : ref = 'NON_DEFINI' # Calcul de la valeur de l'interspectre x = valePara @@ -715,10 +937,9 @@ def test_fonction_ops(self,TEST_NOOK,VALEUR,ATTRIBUT,TABL_INTSP,**args): else: # Test et affichage de la valeur curDict=TesterValeur(fctProl[2],valePara,[valeRef,],res,epsi,crit,'NON') - AfficherResultat(curDict,fctProl[2].strip(),crit,res,valePara,txt) + AfficherResultat(curDict,fctProl[2].strip(),ref,legende,crit,res,valePara,txt) # On affiche txt dans le fichier RESULTAT aster.affiche('RESULTAT', os.linesep.join(txt)) return ier - -- 2.39.2