-#@ 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,
"""
Procedure de couplage Aster-Ecrevisse
- Recuperation du profil de la fissure , appel de MACR_ECRE_CALC,
+ Recuperation du profil de la fissure , appel de MACR_ECRE_CALC,
creation des tableaux de resultats et des chargements pour AsterGeneration par Aster
"""
import aster
from Accas import _F
from Noyau.N_utils import AsType
- from Utilitai.Utmess import UTMESS
+ from Utilitai.Utmess import UTMESS, MasquerAlarme, RetablirAlarme
from Utilitai.Table import Table, merge
- from math import atan, pi, sqrt
+ from copy import copy
+ from math import atan, pi, sqrt, atan2, degrees, sin, cos
ier=0
self.DeclareOut('__ECR_P',CHARGE_MECA)
self.DeclareOut('__DEB',DEBIT)
-
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
- # Parametres Developpeur
+ # Parametres debug
+ debug = False
+
+ # Fonctionnalitees cachees :
+ # 1- oldVersion : "=True" permet de retourner un chargement thermique defini selon l'ancien mode (flux thermique)
+ # ATTENTION!! L'ancienne version ne marche que avec la fissure orientee dans la direction Y,
+ # et avec le point initila en y=0!!
+ # 2- chargeLin : "=True" permet d'appliquer le chargement d'Ecrevisse avec interpolation lineaire sur le mailles,
+ # et non constant par maille, comme c'est par defaut
+ oldVersion = False
+ chargeLin = False
+
+
+ # Parametres developpeur
tmp_ecrevisse = "tmp_ecrevisse"
- fichier_data = "data.dat"
- defaut = '00'
- # Niveaux de debug
- debug1 = (INFO>1)
- debug2 = (INFO>2)
- #
+
+ # Info
+ info2 = (INFO==2)
InfoAster = 1
- #
- oldVersion = False # Permet de retourner un chargement thermique defini selon l'ancien mode (flux thermique)
+ if debug :
+ info2=True
# IMPORTATION DE COMMANDES ASTER
DEFI_GROUP = self.get_cmd("DEFI_GROUP")
IMPR_CO = self.get_cmd("IMPR_CO")
DEFI_FONCTION = self.get_cmd("DEFI_FONCTION")
CREA_TABLE = self.get_cmd("CREA_TABLE")
+ IMPR_TABLE = self.get_cmd("IMPR_TABLE")
CO = self.get_cmd("CO")
AFFE_CHAR_THER_F = self.get_cmd("AFFE_CHAR_THER_F")
AFFE_CHAR_MECA_F = self.get_cmd("AFFE_CHAR_MECA_F")
DEFI_FICHIER = self.get_cmd("DEFI_FICHIER")
+ DEFI_CONSTANTE = self.get_cmd("DEFI_CONSTANTE")
# RECUPERATION DES MOTS-CLES FACTEURS
dRESULTAT=RESULTAT[0].cree_dict_valeurs(RESULTAT[0].mc_liste)
for i in dCONVERGENCE.keys():
if dCONVERGENCE[i]==None : del dCONVERGENCE[i]
- # Instants
+
+ # INSTANTS
_l_inst = dRESULTAT['MECANIQUE'].LIST_VARI_ACCES()
if dRESULTAT.has_key('INST'):
Inst_Ecrevisse = dRESULTAT['INST']
else:
pass
- # ancienne version
- # liste des mots cles facteurs de FLUX_REP pour le flux F1 de chaque fissure (sur GROUP_MA[0])
- l_FLUX_REP_F1 = []
- # liste des mots cles facteurs de PRES_REP pour le flux F2 de chaque fissure (sur GROUP_MA[1])
- l_FLUX_REP_F2 = []
-
- # nouvelle version
- # liste des mots cles facteurs de ECHANGE pour le flux F1 de chaque fissure (sur GROUP_MA[0])
- l_ECHANGE_F1 = []
- # liste des mots cles facteurs de ECHANGE pour le flux F2 de chaque fissure (sur GROUP_MA[1])
- l_ECHANGE_F2 = []
-
- # Toutes versions
- # liste des mots cles facteurs de PRES_REP pour chaque fissure
+
+ # INITIATION DES CHARGEMENTS ECREVISSE --> ASTER :
+ # liste des mots cles facteurs de PRES_REP pour chaque fissure
l_PRES_REP = []
+ if oldVersion :
+ # liste des mots cles facteurs de FLUX_REP pour le flux F1/F2
+ # de chaque fissure (soit sur les deux levres :GROUP_MA[0], GROUP_MA[1])
+ l_FLUX_REP_F1 = []
+ l_FLUX_REP_F2 = []
+ else :
+ # liste des mots cles facteurs de ECHANGE pour le flux F1/F2
+ # de chaque fissure (soit sur les deux levres :GROUP_MA[0], GROUP_MA[1])
+ l_ECHANGE_F1 = []
+ l_ECHANGE_F2 = []
+
- # Liste des noms des groupes de noeuds du maillage
+ # ON CREE LES GROUP_NO ORDONNES DES LEVRES DE FISSURE
+ # Liste des noms des groupes de noeuds du maillage :
_lgno = map(lambda x: x[0], MODELE_MECA['MAILLAGE'].LIST_GROUP_NO() )
for k, fissure in enumerate(FISSURE):
CREA_GROUP_NO=_F(GROUP_MA=(dFISSURE['GROUP_MA'][1]),),);
# Test sur le nombre de caracteres du nom des group_ma
- if len(dFISSURE['GROUP_MA'][0]) >7:
- sys.exit(1)
-
- if len(dFISSURE['GROUP_MA'])>1 and len(dFISSURE['GROUP_MA'][1]) >7:
+ if (len(dFISSURE['GROUP_MA'][0]) >7 or len(dFISSURE['GROUP_MA'][1]) >7):
sys.exit(1)
# Creation des group_no ordonnes des levres des fissures
GROUP_NO=dFISSURE['GROUP_MA'][0],
GROUP_NO_ORIG=dFISSURE['GROUP_NO_ORIG'][0],
GROUP_NO_EXTR=dFISSURE['GROUP_NO_EXTR'][0],
- PRECISION=0.001,
- CRITERE='ABSOLU',),
+ PRECISION=0.01,
+ CRITERE='RELATIF',),
INFO=InfoAster,);
+ _nom_gno_2 = '_' + dFISSURE['GROUP_MA'][1]
+ if not _nom_gno_2 in _lgno:
+ DEFI_GROUP(reuse = MODELE_MECA['MAILLAGE'],
+ MAILLAGE=MODELE_MECA['MAILLAGE'],
+ CREA_GROUP_NO=_F(OPTION='SEGM_DROI_ORDO',
+ NOM=_nom_gno_2,
+ GROUP_NO=dFISSURE['GROUP_MA'][1],
+ GROUP_NO_ORIG=dFISSURE['GROUP_NO_ORIG'][1],
+ GROUP_NO_EXTR=dFISSURE['GROUP_NO_EXTR'][1],
+ PRECISION=0.01,
+ CRITERE='RELATIF',),
+ INFO=InfoAster,);
+
+
- if len(dFISSURE['GROUP_MA'])>1:
- _nom_gno_2 = '_' + dFISSURE['GROUP_MA'][1]
- if not _nom_gno_2 in _lgno:
- DEFI_GROUP(reuse = MODELE_MECA['MAILLAGE'],
- MAILLAGE=MODELE_MECA['MAILLAGE'],
- CREA_GROUP_NO=_F(OPTION='SEGM_DROI_ORDO',
- NOM=_nom_gno_2,
- GROUP_NO=dFISSURE['GROUP_MA'][1],
- GROUP_NO_ORIG=dFISSURE['GROUP_NO_ORIG'][1],
- GROUP_NO_EXTR=dFISSURE['GROUP_NO_EXTR'][1],
- PRECISION=0.001,
- CRITERE='ABSOLU',),
- INFO=InfoAster,);
-
- _T_DY=POST_RELEVE_T(ACTION=_F(INTITULE='DEPL_FIS',
+ # EXTRACTIONS DE QUANTITES NECESSAIRES DES RESULTATS THERMIQUE ET MECANIQUE
+ # On cree les chargements Aster --> Ecrevisse :
+ # ouverture de fissure et temperature sur le materiau
+
+ # premiere levre de fissure
+ _T_DPL=POST_RELEVE_T(ACTION=_F(INTITULE='DEP_FIS1',
GROUP_NO=_nom_gno_1,
RESULTAT=dRESULTAT['MECANIQUE'],
NOM_CHAM='DEPL',
OPERATION='EXTRACTION',),
);
- if len(dFISSURE['GROUP_MA'])>1:
- # signifie que l'on prend en compte la deuxieme levre de la fissure, different de l'essai sur tranche ou une fissure est
- # represente par une seule levre et l'autre est fixe
- _T_DY_B=POST_RELEVE_T(ACTION=_F(INTITULE='DX_FIS',
- GROUP_NO=_nom_gno_2,
- RESULTAT=dRESULTAT['MECANIQUE'],
- NOM_CHAM='DEPL',
- NOM_CMP=('DX','DY',),
- INST = Inst_Ecrevisse,
- OPERATION='EXTRACTION',),);
-
- _T_TEMP=POST_RELEVE_T(ACTION=_F(INTITULE='TEMP',
+ _T_TEMP=POST_RELEVE_T(ACTION=_F(INTITULE='TEMP_FI1',
GROUP_NO=_nom_gno_1,
RESULTAT=dRESULTAT['THERMIQUE'],
NOM_CHAM='TEMP',
INST = Inst_Ecrevisse,
OPERATION='EXTRACTION',),);
- if len(dFISSURE['GROUP_MA'])>1:
- _T_TEMPB=POST_RELEVE_T(ACTION=_F(INTITULE='TEMP',
- GROUP_NO=_nom_gno_2,
- RESULTAT=dRESULTAT['THERMIQUE'],
- NOM_CHAM='TEMP',
- TOUT_CMP='OUI',
- INST = Inst_Ecrevisse,
- OPERATION='EXTRACTION',),);
-
- if ( debug2 ) :
- print '_T_DY ==================================================='
- print _T_DY.EXTR_TABLE()
+ # deuxieme levre de la fissure
+ _T_DPL_B=POST_RELEVE_T(ACTION=_F(INTITULE='DEP_FIS2',
+ GROUP_NO=_nom_gno_2,
+ RESULTAT=dRESULTAT['MECANIQUE'],
+ NOM_CHAM='DEPL',
+ NOM_CMP=('DX','DY',),
+ INST = Inst_Ecrevisse,
+ OPERATION='EXTRACTION',),);
+
+ _T_TEMPB=POST_RELEVE_T(ACTION=_F(INTITULE='TEMP_FI2',
+ GROUP_NO=_nom_gno_2,
+ RESULTAT=dRESULTAT['THERMIQUE'],
+ NOM_CHAM='TEMP',
+ TOUT_CMP='OUI',
+ INST = Inst_Ecrevisse,
+ OPERATION='EXTRACTION',),);
+
+ if ( debug ) :
+ print '_T_DPL ==================================================='
+ print _T_DPL.EXTR_TABLE()
+ print '_T_DPL_B ================================================='
+ print _T_DPL_B.EXTR_TABLE()
print '_T_TEMP ================================================='
print _T_TEMP.EXTR_TABLE()
-
+ print '_T_TEMP_B ==============================================='
+ print _T_TEMPB.EXTR_TABLE()
# Extraction des tables Temperatures + deplacement levres fissure
_tbl_temp = _T_TEMP.EXTR_TABLE()
- _tbl_dy = _T_DY.EXTR_TABLE()
- DETRUIRE(CONCEPT=_F(NOM=(_T_DY,_T_TEMP,)),INFO=1,ALARME='NON')
-
- # Determination de la direction de la fissure : limitee aux cas horizontal ou vertical a cause
- # de la creation des chargement pour aster
-
- _xih = _tbl_dy.values()['COOR_X'][0]
- _yih = _tbl_dy.values()['COOR_Y'][0]
- _xeh = _tbl_dy.values()['COOR_X'][-1]
- _yeh = _tbl_dy.values()['COOR_Y'][-1]
-
- if abs(_xeh -_xih)<1.E-6 : # fissure verticale
-
- if (_yeh-_yih)<0 : # fluide du haut vers le bas
- alpha = 180.
- else :
- alpha =0. # fluide du bas vers le haut
- DIR_FISS='Y'
- NORM_FISS='X'
- elif abs(_yih - _yeh)<1.E-6 : # fissure horizontale
- alpha = 90.
- DIR_FISS ='X'
- NORM_FISS = 'Y'
- else:
- UTMESS('F','ECREVISSE0_23')
-
-# Determination de l'ouverture de la fissure
-
- _l_dy1 = _tbl_dy.values()['ABSC_CURV']
- _l_dy2 = [ x + y for (x,y) in zip(_tbl_dy.values()['D%s' % NORM_FISS], _tbl_dy.values()['COOR_%s' % NORM_FISS]) ]
-
- # Listes des cotes et ouvertures (deuxieme groupe)
- if len(dFISSURE['GROUP_MA'])>1:
- # signifie que l'on prend en compte la deuxieme levre de la fissure,
- _tbl_dy_b = _T_DY_B.EXTR_TABLE()
- _tbl_temp_b = _T_TEMPB.EXTR_TABLE()
- DETRUIRE(CONCEPT=_F(NOM=(_T_DY_B,_T_TEMPB,)),INFO=1,ALARME='NON')
-
- _l_dy1_b = _tbl_dy_b.values()['ABSC_CURV']
- _l_dy2_b = [ x + y for (x,y) in zip(_tbl_dy_b.values()['D%s' % NORM_FISS], _tbl_dy_b.values()['COOR_%s' % NORM_FISS]) ]
-
- # Listes des cotes et temperatures (premier groupe)
- _l_t1 = _tbl_temp.values()['ABSC_CURV']
+ _tbl_dpl = _T_DPL.EXTR_TABLE()
+ DETRUIRE(CONCEPT=_F(NOM=(_T_DPL,_T_TEMP,)),INFO=1,ALARME='NON')
+ _tbl_dpl_b = _T_DPL_B.EXTR_TABLE()
+ _tbl_temp_b = _T_TEMPB.EXTR_TABLE()
+ DETRUIRE(CONCEPT=_F(NOM=(_T_DPL_B,_T_TEMPB,)),INFO=1,ALARME='NON')
+
+
+ # --Determination des cotes a donner a ecrevisse--
+ # a partir des resultats mecanique et thermique :
+ _l_tang = _tbl_dpl.values()['ABSC_CURV']
+ _l_tang_b = _tbl_dpl_b.values()['ABSC_CURV']
+ try :
+ _l_absz_m = map(lambda x,y: 0.5*(x+y), _l_tang,_l_tang_b)
+ except TypeError :
+ UTMESS('F','ECREVISSE0_40')
+ #
+ _l_tang_t = _tbl_temp.values()['ABSC_CURV']
+ _l_tang_t_b = _tbl_temp_b.values()['ABSC_CURV']
+ _l_absz_t = map(lambda x,y: 0.5*(x+y), _l_tang_t,_l_tang_t_b)
+
+
+ # Coordonnees des points des levres (initiales et a l instant actuel
+ _X0 = _tbl_dpl.values()['COOR_X']
+ _Y0 = _tbl_dpl.values()['COOR_Y']
+ _X0_b = _tbl_dpl_b.values()['COOR_X']
+ _Y0_b = _tbl_dpl_b.values()['COOR_Y']
+ _X = [x + y for (x,y) in zip(_tbl_dpl.values()['DX'],_X0)]
+ _Y = [x + y for (x,y) in zip(_tbl_dpl.values()['DY'],_Y0)]
+ _X_b = [x + y for (x,y) in zip(_tbl_dpl_b.values()['DX'],_X0_b)]
+ _Y_b = [x + y for (x,y) in zip(_tbl_dpl_b.values()['DY'],_Y0_b)]
+
+
+ # Determination de la direction de la fissure
+ (DIR_FISS, DIR_PREV, beta, theta, _xi, _yi) = dirfiss(_X,_Y,_X_b,_Y_b)
+ if oldVersion :
+ (DIR_FISS, DIR_PREV, beta, theta, _xi, _yi) = dirfiss(_X0,_Y0,_X0_b,_Y0_b)
+
+ if (DIR_FISS == 'GEN') and oldVersion :
+ UTMESS('F','ECREVISSE0_23', valr=[theta])
+
+ # --Calcul de l ouverture de fissure--
+ # une fissure refermee a une ouverture
+ # egale a l'ouverture remanente
+ (_l_ouv0,_l_gli0) = ouvFiss(DIR_FISS,beta,_X0,_Y0,_X0_b,_Y0_b)
+ for i in range(len(_l_ouv0)) :
+ if _l_ouv0[i] < dFISSURE['OUVERT_REMANENTE'] :
+ UTMESS('A','ECREVISSE0_39')
+
+
+ (_l_ouv,_l_gli) = ouvFiss(DIR_FISS,beta,_X,_Y,_X_b,_Y_b)
+ if dFISSURE['OUVERT_REMANENTE'] :
+ _l_ouv = map(lambda x: max(dFISSURE['OUVERT_REMANENTE'],x), _l_ouv)
+ if info2 :
+ nbOuvRem = _l_ouv.count(dFISSURE['OUVERT_REMANENTE'])
+ if nbOuvRem != 0 :
+ UTMESS('I', 'ECREVISSE0_41',valr=[nbOuvRem])
+
+
+
+ # Controle sur l entite du glissement entre les levres
+ DeltaMaille = [abs(y-x) for (x,y) in zip(_l_absz_m[1:len(_l_absz_m)], _l_absz_m[0:len(_l_absz_m)-1])]
+ for i in range(len(DeltaMaille)) :
+ deltamai = DeltaMaille[i]
+ if (deltamai <= _l_gli[i]) or (deltamai <= _l_gli[i+1]) :
+ UTMESS('A', 'ECREVISSE0_38')
+ break
+
+
+ # -- Calcul de la temperature sur le materiau (levres de la fissure) --
+ # on fait la moyenne des temperatures des deux levres
_l_t2 = _tbl_temp.values()['TEMP']
-
- # Listes des cotes et temperatures (deuxieme groupe)
- if len(dFISSURE['GROUP_MA'])>1:
- # signifie que l'on prend en compte la deuxieme levre de la fissure, different de l'essai sur tranche ou une fissure est
- # represente par une seule levre et l'autre est fixe
-
- _l_t1_b = _tbl_temp_b.values()['ABSC_CURV']
- _l_t2_b = _tbl_temp_b.values()['TEMP']
-
-
- if ( debug2 ):
- print "Informations de debug:\n"
- print 'Inst_Ecrevisse=', Inst_Ecrevisse
- print '_l_t1=', len(_l_t1),_l_t1
- print '_l_t2=', len(_l_t2),_l_t2
- print '_l_dy1=', len(_l_dy1),_l_dy1
- print '_l_dy2=', len(_l_dy2),_l_dy2
-
- if len(dFISSURE['GROUP_MA'])>1:
- print '_l_t1_b=', len(_l_t1_b),_l_t1_b
- print '_l_t2_b=', len(_l_t2_b),_l_t2_b
- print '_l_dy1_b=', len(_l_dy1_b),_l_dy1_b
- print '_l_dy2_b=', len(_l_dy2_b),_l_dy2_b
+ _l_t2_b = _tbl_temp_b.values()['TEMP']
+ _l_temp_aster = map(lambda x,y: 0.5*(x+y), _l_t2_b,_l_t2)
- # Affichage d'informations que l'on peut voir sur le fichier .mess ou .resu
+ # Infos / Debug : fichier .mess ou .resu
+ if (info2) :
+ UTMESS('I', 'ECREVISSE0_1', valk=["Premiere levre"],
+ valr=[Inst_Ecrevisse, min(_l_tang_t), max(_l_tang_t), min(_l_t2), max(_l_t2), min(_l_tang), max(_l_tang)])
+ UTMESS('I', 'ECREVISSE0_1',valk=["Deuxieme levre"],
+ valr=[Inst_Ecrevisse,min(_l_tang_t_b), max(_l_tang_t_b), min(_l_t2_b), max(_l_t2_b), min(_l_tang_b), max(_l_tang_b)])
+ UTMESS('I', 'ECREVISSE0_2',
+ valr=[Inst_Ecrevisse, min(_l_absz_t), max(_l_absz_t), min(_l_temp_aster), max(_l_temp_aster), min(_l_absz_m), max(_l_absz_m), min(_l_ouv), max(_l_ouv), min(_l_gli),max(_l_gli)])
- if (debug1):
- UTMESS('I', 'ECREVISSE0_1', valk=["Premiere levre"],
- valr=[Inst_Ecrevisse, min(_l_t1), max(_l_t1), min(_l_t2), max(_l_t2), min(_l_dy1), max(_l_dy1), min(_l_dy2), max(_l_dy2)])
- if len(dFISSURE['GROUP_MA'])>1:
- UTMESS('I', 'ECREVISSE0_1',valk=["Deuxieme levre"],
- valr=[Inst_Ecrevisse,min(_l_t1_b), max(_l_t1_b), min(_l_t2_b), max(_l_t2_b), min(_l_dy1_b), max(_l_dy1_b), min(_l_dy2_b), max(_l_dy2_b)])
-
-
- # ----------------------------------------------------------------------------------
- # Partie concernant la prise en compte des deux levres
- if len(dFISSURE['GROUP_MA'])>1:
-
- # Calcul de l'ouverture entre les deux levres
- _l_dy2 = map(lambda x,y: abs(y-x), _l_dy2, _l_dy2_b)
-
- # Pour la temperature, on fait la moyenne des temperatures des deux levres (points a ameliorer peut etre par un autre modele)
- _l_t2 = map(lambda x,y: 0.5*(x+y), _l_t2_b,_l_t2)
-
- # ----------------------------------------------------------------------------------
-
- if dFISSURE['OUVERT_REMANENTE']:
- # une fissure refermee a une ouverture egale a l'ouverture remanente
- _l_dy2 = map(lambda x: max(dFISSURE['OUVERT_REMANENTE'],x), _l_dy2)
-
- UTMESS('I', 'ECREVISSE0_2',
- valr=[Inst_Ecrevisse, min(_l_t1), max(_l_t1), min(_l_t2), max(_l_t2), min(_l_dy1), max(_l_dy1), min(_l_dy2), max(_l_dy2)])
-
-
- if ( debug2 ):
- print "Informations de debug:\n"
+ if ( debug ) :
+ print "\n INFORMATIONS DE DEBUG: "
print 'Inst_Ecrevisse=', Inst_Ecrevisse
- print '_l_t1=', len(_l_t1),_l_t1
- print '_l_t2=', len(_l_t2),_l_t2
- print '_l_dy1=', len(_l_dy1),_l_dy1
- print '_l_dy2=', len(_l_dy2),_l_dy2
-
- # Test de non divergence, les messages sont assez explicites
-
+ print 'theta:', theta
+ print 'beta:', beta
+ print 'DIR_FISS:', DIR_FISS
+ print 'DIR_PREV:', DIR_PREV
+ print 'point initial de la fissure: (xi,yi) :', _xi,_yi
+ print len(_X0), '_X0 =', _X0
+ print len(_X0_b), '_X0_b=', _X0_b
+ print len(_Y0), '_Y0 =', _Y0
+ print len(_Y0_b), '_Y0_b=', _Y0_b
+ print len(_X), '_X =', _X
+ print len(_Y), '_Y =', _Y
+ print len(_X_b), '_X_b =', _X_b
+ print len(_Y_b), '_Y_b =', _Y_b
+ print 'Controle sur les abszisses curvilignes (mecaniques/thermiques) '
+ print '_l_absz_m==_l_absz_t?', _l_absz_m==_l_absz_t
+ print '_l_absz_m=', len(_l_absz_m),_l_absz_m
+ print '_l_absz_t=', len(_l_absz_t),_l_absz_t
+ print '_l_temp_aster=', len(_l_temp_aster),_l_temp_aster
+ print '_l_ouv=', len(_l_ouv),_l_ouv
+ print '_l_gli=', len(_l_gli),_l_gli
+ print '_l_tang=', _l_tang
+ print '_l_tang_b=', _l_tang
+
+
+# ----------------------------------------------------------------------------
+# PREPARATION ET LANCEMENT D ECREVISSE
+
+ # TESTS de non divergence, les messages sont assez explicites :
# Si toutes les listes sont bien definies
- if len(_l_dy1)*len(_l_dy2)*len(_l_t1)*len(_l_t2) == 0:
+ if len(_l_absz_m)*len(_l_ouv)*len(_l_absz_t)*len(_l_temp_aster) == 0:
UTMESS('F','ECREVISSE0_3', valr=[Inst_Ecrevisse])
__TAB = None
break
-
# Si les ouvertures ne sont pas trop faibles
- elif min(_l_dy2) < 1e-20:
- UTMESS('F','ECREVISSE0_4', valr=[Inst_Ecrevisse, min(_l_dy2)])
+ elif min(_l_ouv) < 1e-20:
+ UTMESS('F','ECREVISSE0_4', valr=[Inst_Ecrevisse, min(_l_ouv)])
__TAB = None
break
-
elif max(_l_t2) > 700:
- UTMESS('F','ECREVISSE0_5', valr=[Inst_Ecrevisse, max(_l_t2 )])
+ UTMESS('F','ECREVISSE0_5', valr=[Inst_Ecrevisse, max(_l_t2)])
__TAB = None
break
-
elif max(_l_t2_b) > 700:
UTMESS('F','ECREVISSE0_5', valr=[Inst_Ecrevisse, max(_l_t2_b )])
__TAB = None
break
-
elif min(_l_t2) < 0:
UTMESS('F','ECREVISSE0_6', valr=[Inst_Ecrevisse, min(_l_t2 )])
__TAB = None
break
-
elif min(_l_t2_b) < 0:
UTMESS('F','ECREVISSE0_6', valr=[Inst_Ecrevisse, min(_l_t2_b )])
__TAB = None
break
-
elif abs( float(dECOULEMENT['PRES_ENTREE']) - float(dECOULEMENT['PRES_SORTIE']) )< 5:
UTMESS('F','ECREVISSE0_7', valr=[Inst_Ecrevisse, abs( float(dECOULEMENT['PRES_ENTREE']) - float(dECOULEMENT['PRES_SORTIE']) ) ] )
__TAB = None
break
-
- # On lance Ecrevisse
+ # On lance Ecrevisse!
else:
UTMESS('I','ECREVISSE0_8', valr=[Inst_Ecrevisse])
except:
pass
+ # Recalcul des cotes par rapport a la tortuoiste
+ tort = dFISSURE['TORTUOSITE']
+ try :
+ _l_absz_m = [x/tort for x in _l_absz_m]
+ _l_absz_t = [x/tort for x in _l_absz_t]
+ except ZeroDivisionError :
+ UTMESS('F','ECREVISSE0_42')
+
+
if dFISSURE.has_key('LISTE_COTES_BL'):
__LISTE_COTES_BL = dFISSURE['LISTE_COTES_BL']
else:
- __LISTE_COTES_BL = (0., max(_l_dy1))
+ __LISTE_COTES_BL = (0., max(_l_absz_m))
# Mot-cle ECOULEMENT
- txt={}
+ txt = {}
txt = { 'PRES_ENTREE' : dECOULEMENT['PRES_ENTREE'],
'PRES_SORTIE' : dECOULEMENT['PRES_SORTIE'],
'FLUIDE_ENTREE' : dECOULEMENT['FLUIDE_ENTREE'],
__TAB_i = CO('_TAB2')
__DEB_i = CO('_DEB2')
- MACR_ECRE_CALC(TABLE = __TAB_i,
- DEBIT = __DEB_i,
- ENTETE=ENTETE,
- COURBES=COURBES,
- IMPRESSION=IMPRESSION,
- INFO=INFO,
- LOGICIEL=LOGICIEL,
- VERSION=VERSION,
- FISSURE=_F(LONGUEUR = max(_l_dy1)/dFISSURE['TORTUOSITE'],
- ANGLE = alpha,
- RUGOSITE = dFISSURE['RUGOSITE'],
- ZETA = dFISSURE['ZETA'],
- SECTION = dFISSURE['SECTION'],
- LISTE_COTES_AH = _l_dy1,
- LISTE_VAL_AH = _l_dy2,
- LISTE_COTES_BL = __LISTE_COTES_BL,
- LISTE_VAL_BL = dFISSURE['LISTE_VAL_BL'],
- ),
+ MACR_ECRE_CALC(TABLE = __TAB_i,
+ DEBIT = __DEB_i,
+ ENTETE = ENTETE,
+ COURBES = COURBES,
+ IMPRESSION = IMPRESSION,
+ INFO = INFO,
+ LOGICIEL = LOGICIEL,
+ VERSION = VERSION,
+ FISSURE = _F(LONGUEUR = max(_l_absz_m),
+ ANGLE = theta,
+ RUGOSITE = dFISSURE['RUGOSITE'],
+ ZETA = dFISSURE['ZETA'],
+ SECTION = dFISSURE['SECTION'],
+ LISTE_COTES_AH = _l_absz_m,
+ LISTE_VAL_AH = _l_ouv,
+ LISTE_COTES_BL = __LISTE_COTES_BL,
+ LISTE_VAL_BL = dFISSURE['LISTE_VAL_BL'],
+ ),
TEMPERATURE=_F(GRADIENT = 'FOURNI',
- LISTE_COTES_TEMP = _l_t1,
- LISTE_VAL_TEMP = _l_t2,
+ LISTE_COTES_TEMP = _l_absz_t,
+ LISTE_VAL_TEMP = _l_temp_aster,
),
CONVERGENCE=_F(KGTEST = dCONVERGENCE['KGTEST'],
- ITER_GLOB_MAXI = dCONVERGENCE['ITER_GLOB_MAXI'],
- CRIT_CONV_DEBI = dCONVERGENCE['CRIT_CONV_DEBI'],
+ ITER_GLOB_MAXI = dCONVERGENCE['ITER_GLOB_MAXI'],
+ CRIT_CONV_DEBI = dCONVERGENCE['CRIT_CONV_DEBI'],
),
**motscle2
);
-
- # Creation de la table resultat sur toutes les fissures:
- # Nom de la fissure
- nom_fiss = dFISSURE['GROUP_MA'][0] + "-" + dFISSURE['GROUP_MA'][1]
+
+#-------------------------------------------------------------
+# EXTRACTION DES RESULTATS D ECREVISSE
+
+
+
# Creation de la table
__TABFISS_i = __TAB_i.EXTR_TABLE()
- __DEBFISS_i = __DEB_i.EXTR_TABLE()
- # Taille de la table
+
nb_lignes_table = len(__TABFISS_i["COTES"])
- # Ajout d'une colonne supplementaire
- __TABFISS_i["FISSURE"] = [nom_fiss] * nb_lignes_table
- __DEBFISS_i["FISSURE"] = [nom_fiss]
- if k==0:
- __TABFISS_tot = __TABFISS_i
- __DEBFISS_tot = __DEBFISS_i
- else:
- __TABFISS_tot = merge(__TABFISS_tot, __TABFISS_i)
- __DEBFISS_tot = merge(__DEBFISS_tot, __DEBFISS_i)
-
-
+ # Re-definition des cotes utilisateur (on elimine l effet de la tortuosite)
+ _lst_c = __TABFISS_i.COTES.values()
+ _l_cotes = [x*tort for x in _lst_c]
+ dictTab = __TABFISS_i.dict_CREA_TABLE()['LISTE']
+
+ __TABFISS_i = CREA_TABLE(LISTE = (
+ _F(PARA = "COTES", LISTE_R = _l_cotes,),
+ _F(PARA = "FLUX", LISTE_R = dictTab[1]['LISTE_R'],),
+ _F(PARA = "PRESSION", LISTE_R = dictTab[2]['LISTE_R'],),
+ _F(PARA = "TEMP", LISTE_R = dictTab[3]['LISTE_R'],),
+ _F(PARA = "COEF_CONV", LISTE_R = dictTab[4]['LISTE_R'],),
+ ),)
+
DETRUIRE(OBJET=_F(CHAINE = '__TAB_i' ),INFO=1,ALARME='NON')
DETRUIRE(OBJET=_F(CHAINE = '__DEB_i' ),INFO=1,ALARME='NON')
- if ( debug2 ):
+ if ( debug ):
os.system('ls -al ' + os.path.join(os.getcwd(),tmp_ecrevisse) )
- pref_fic = dFISSURE['PREFIXE_FICHIER']
-
- # Ecriture du fichier debits en fonction du temps:
- try:
- # on lit le fichier debit produit par ecrevisse
- f_ast = open(os.path.join(tmp_ecrevisse, 'debits'),'r')
- _txt = f_ast.read()
- f_ast.close()
- nomfic = str(pref_fic) + '_debits'
- # on concatene
- fw = open( os.getcwd() + os.sep + 'REPE_OUT' + os.sep + nomfic, 'a')
- fw.write( str(Inst_Ecrevisse) + ' ' + _txt )
- fw.close()
- # On recopie le fichier debits pour reprise ulterieure
- nomfic2 = 'debits_dernier'
- fw = open( os.getcwd() + os.sep + 'REPE_OUT' + os.sep + nomfic2, 'w')
- fw.write( _txt )
- fw.close()
- except Exception, e:
- print e
-
-
+ if dFISSURE['PREFIXE_FICHIER'] :
+ pref_fic = dFISSURE['PREFIXE_FICHIER']
+ else :
+ pref_fic = 'FISSURE'+str(k+1)
+
+ ## Ecriture du fichier debits en fonction du temps:
+ #try:
+ ## on lit le fichier debit produit par ecrevisse
+ #f_ast = open(os.path.join(tmp_ecrevisse, 'debits'),'r')
+ #_txt = f_ast.read()
+ #f_ast.close()
+ #nomfic = str(pref_fic) + '_debits'
+ ## on concatene
+ #fw = open( os.getcwd() + os.sep + 'REPE_OUT' + os.sep + nomfic, 'a')
+ #fw.write( str(Inst_Ecrevisse) + ' ' + _txt )
+ #fw.close()
+ ## On recopie le fichier debits pour reprise ulterieure
+ #nomfic2 = 'debits_dernier'
+ #fw = open( os.getcwd() + os.sep + 'REPE_OUT' + os.sep + nomfic2, 'w')
+ #fw.write( _txt )
+ #fw.close()
+ #except Exception, e:
+ #print e
+
+ # CREATION DES COURBES:
if COURBES != "AUCUNE":
- # Pour masquer certaines alarmes
- from Utilitai.Utmess import MasquerAlarme, RetablirAlarme
- MasquerAlarme('TABLE0_6')
-
- nomfic = os.path.join( os.getcwd(), 'REPE_OUT', str(pref_fic) + '_flux')
- if not os.path.isfile(nomfic): acces='NEW'
- else: acces='APPEND'
-
- DEFI_FICHIER(ACTION='ASSOCIER', UNITE=55, TYPE='ASCII', ACCES=acces, FICHIER=nomfic)
- IMPR_TABLE(FORMAT='XMGRACE',
- TABLE=__TAB_i,
- UNITE=55,
- PILOTE=COURBES,
- NOM_PARA=('COTES','FLUX',),
- TITRE='Flux de chaleur a l\'instant %s' % Inst_Ecrevisse,
- LEGENDE_X='Abscisse curviligne (m)',
- LEGENDE_Y='Flux (W/m2)',
- );
- DEFI_FICHIER(ACTION='LIBERER', UNITE=55)
-
- nomfic = os.path.join( os.getcwd(), 'REPE_OUT', str(pref_fic) + '_temperature')
- if not os.path.isfile(nomfic): acces='NEW'
- else: acces='APPEND'
-
- DEFI_FICHIER(ACTION='ASSOCIER', UNITE=55, TYPE='ASCII', ACCES=acces, FICHIER=nomfic)
- IMPR_TABLE(FORMAT='XMGRACE',
- TABLE=__TAB_i,
- UNITE=55,
- PILOTE=COURBES,
- NOM_PARA=('COTES','TEMP',),
- TITRE='Temperature a l\'instant %s' % Inst_Ecrevisse,
- LEGENDE_X='Abscisse curviligne (m)',
- LEGENDE_Y='Temperature (degres C)',
- );
- DEFI_FICHIER(ACTION='LIBERER', UNITE=55)
-
- nomfic = os.path.join( os.getcwd(), 'REPE_OUT', str(pref_fic) + '_coeffconv')
- if not os.path.isfile(nomfic): acces='NEW'
- else: acces='APPEND'
-
- DEFI_FICHIER(ACTION='ASSOCIER', UNITE=55, TYPE='ASCII', ACCES=acces, FICHIER=nomfic)
- IMPR_TABLE(FORMAT='XMGRACE',
- TABLE=__TAB_i,
- UNITE=55,
- PILOTE=COURBES,
- NOM_PARA=('COTES','COEF_CONV',),
- TITRE='Coefficient de convection a l\'instant %s' % Inst_Ecrevisse,
- LEGENDE_X='Abscisse curviligne (m)',
- LEGENDE_Y='Coefficient de convection (W/m2/K)',
- );
- DEFI_FICHIER(ACTION='LIBERER', UNITE=55)
-
- nomfic = os.path.join( os.getcwd(), 'REPE_OUT', str(pref_fic) + '_pression')
- if not os.path.isfile(nomfic): acces='NEW'
- else: acces='APPEND'
-
- DEFI_FICHIER(ACTION='ASSOCIER', UNITE=55, TYPE='ASCII', ACCES=acces, FICHIER=nomfic)
- IMPR_TABLE(FORMAT='XMGRACE',
- TABLE=__TAB_i,
- UNITE=55,
- PILOTE=COURBES,
- NOM_PARA=('COTES','PRESSION',),
- TITRE='Pression a l\'instant %s' % Inst_Ecrevisse,
- LEGENDE_X='Abscisse curviligne (m)',
- LEGENDE_Y='Pression (Pa)',
- );
- DEFI_FICHIER(ACTION='LIBERER', UNITE=55)
-
- # Pour la gestion des alarmes
- RetablirAlarme('TABLE0_6')
+ # Pour masquer certaines alarmes
+
+ MasquerAlarme('TABLE0_6')
+
+ nomfic = os.path.join( os.getcwd(), 'REPE_OUT', str(pref_fic) + '_flux'+ '_' + str(Inst_Ecrevisse))
+ if not os.path.isfile(nomfic): acces='NEW'
+ else: acces='APPEND'
+
+ DEFI_FICHIER(ACTION='ASSOCIER', UNITE=55, TYPE='ASCII', ACCES=acces, FICHIER=nomfic)
+ IMPR_TABLE(FORMAT='XMGRACE',
+ TABLE=__TABFISS_i,
+ UNITE=55,
+ PILOTE=COURBES,
+ NOM_PARA=('COTES','FLUX',),
+ TITRE='Flux de chaleur a l\'instant %s' % Inst_Ecrevisse,
+ LEGENDE_X='Abscisse curviligne (m)',
+ LEGENDE_Y='Flux (W/m2)',
+ COULEUR = 1,
+ MARQUEUR = 1,
+ );
+ DEFI_FICHIER(ACTION='LIBERER', UNITE=55)
+
+ nomfic = os.path.join( os.getcwd(), 'REPE_OUT', str(pref_fic) + '_temperature'+ '_' + str(Inst_Ecrevisse))
+ if not os.path.isfile(nomfic): acces='NEW'
+ else: acces='APPEND'
+
+ DEFI_FICHIER(ACTION='ASSOCIER', UNITE=55, TYPE='ASCII', ACCES=acces, FICHIER=nomfic)
+ IMPR_TABLE(FORMAT='XMGRACE',
+ TABLE=__TABFISS_i,
+ UNITE=55,
+ PILOTE=COURBES,
+ NOM_PARA=('COTES','TEMP',),
+ TITRE='Temperature a l\'instant %s' % Inst_Ecrevisse,
+ LEGENDE_X='Abscisse curviligne (m)',
+ LEGENDE_Y='Temperature (degres C)',
+ COULEUR = 2,
+ MARQUEUR = 2,
+ );
+ DEFI_FICHIER(ACTION='LIBERER', UNITE=55)
+
+ nomfic = os.path.join( os.getcwd(), 'REPE_OUT', str(pref_fic) + '_coeffconv'+ '_' + str(Inst_Ecrevisse))
+ if not os.path.isfile(nomfic): acces='NEW'
+ else: acces='APPEND'
+
+ DEFI_FICHIER(ACTION='ASSOCIER', UNITE=55, TYPE='ASCII', ACCES=acces, FICHIER=nomfic)
+ IMPR_TABLE(FORMAT='XMGRACE',
+ TABLE=__TABFISS_i,
+ UNITE=55,
+ PILOTE=COURBES,
+ NOM_PARA=('COTES','COEF_CONV',),
+ TITRE='Coefficient de convection a l\'instant %s' % Inst_Ecrevisse,
+ LEGENDE_X='Abscisse curviligne (m)',
+ LEGENDE_Y='Coefficient de convection (W/m2/K)',
+ COULEUR = 3,
+ MARQUEUR = 3,
+ );
+ DEFI_FICHIER(ACTION='LIBERER', UNITE=55)
+
+
+ nomfic = os.path.join( os.getcwd(), 'REPE_OUT', str(pref_fic) + '_pression'+ '_' + str(Inst_Ecrevisse))
+ if not os.path.isfile(nomfic): acces='NEW'
+ else: acces='APPEND'
+
+ DEFI_FICHIER(ACTION='ASSOCIER', UNITE=55, TYPE='ASCII', ACCES=acces, FICHIER=nomfic)
+ IMPR_TABLE(FORMAT='XMGRACE',
+ TABLE=__TABFISS_i,
+ UNITE=55,
+ PILOTE=COURBES,
+ NOM_PARA=('COTES','PRESSION',),
+ TITRE='Pression a l\'instant %s' % Inst_Ecrevisse,
+ LEGENDE_X='Abscisse curviligne (m)',
+ LEGENDE_Y='Pression (Pa)',
+ COULEUR = 4,
+ MARQUEUR = 4,
+ );
+ DEFI_FICHIER(ACTION='LIBERER', UNITE=55)
+
+ # Pour la gestion des alarmes
+ RetablirAlarme('TABLE0_6')
+
# On recopie dans REPE_OUT les fichiers resultats d'Ecrevisse
new_file = os.path.join(repe_out_absolu, str(pref_fic) + '_' + file + '_' + str(Inst_Ecrevisse))
shutil.copy(old_file, new_file)
- if ( debug2 ):
- os.system('ls -al ' + os.path.join(os.getcwd(),tmp_ecrevisse) )
+ # Creation de la table resultat sur toutes les fissures :
+ # Nom de la fissure
+ nom_fiss = dFISSURE['GROUP_MA'][0] + "-" + dFISSURE['GROUP_MA'][1]
+ __TABFISS_i = __TABFISS_i.EXTR_TABLE()
+ __DEBFISS_i = __DEB_i.EXTR_TABLE()
+ __TABFISS_i["FISSURE"] = [nom_fiss]*nb_lignes_table
+ __DEBFISS_i["FISSURE"] = [nom_fiss]
+ if k==0 :
+ __TABFISS_tot = __TABFISS_i
+ __DEBFISS_tot = __DEBFISS_i
+ else :
+ __TABFISS_tot = merge(__TABFISS_tot, __TABFISS_i)
+ __DEBFISS_tot = merge(__DEBFISS_tot, __DEBFISS_i)
- # Creation des chargements Aster
- # ******************************
+
+ if ( debug ):
+ os.system('ls -al ' + os.path.join(os.getcwd(),tmp_ecrevisse) )
+
+#--------------------------------------------------------------
+# CREATIONS DES CHARGEMENTS ASTER
# Recuperation des valeurs dans la table (voir si il y a plus simple)
- _lst_c = __TABFISS_i.COTES.values()
- _lst_f = __TABFISS_i.FLUX.values()
- _lst_p = __TABFISS_i.PRESSION.values()
- _lst_t = __TABFISS_i.TEMP.values()
+ _lst_c = __TABFISS_i.COTES.values()
+ _lst_f = __TABFISS_i.FLUX.values()
+ _lst_p = __TABFISS_i.PRESSION.values()
+ _lst_t = __TABFISS_i.TEMP.values()
_lst_cc = __TABFISS_i.COEF_CONV.values()
- _lis_dtot = __TABFISS_i.DEBTOT.values()
- _lis_dair = __TABFISS_i.DEBAIR.values()
- _lis_dvap = __TABFISS_i.DEBVAP.values()
- _lis_dliq = __TABFISS_i.DEBLIQ.values()
- _lis_ecou = __TABFISS_i.ECOULEMENT.values()
-
- if ( debug2 ):
- print '_lst_c2=',_lst_c
- print '_lst_f2=',_lst_f
- print '_lst_p2=',_lst_p
- print '_lst_t2=',_lst_t
- print '_lst_cc2=',_lst_cc
try:
a=len(_lst_c)
pass
+
# ------------------------------------------------------
# Extraction des conditions limites du calcul Ecrevisse
#
if len(_lst_c)>=2:
- if ( debug2 ):
- print '_lst_c=',_lst_c
- print '_lst_f=',_lst_f
- print '_lst_p=',_lst_p
- print '_lst_t=',_lst_t
- print '_lst_cc=',_lst_cc
-
- _lst_f=list(_lst_f)
- _lst_p=list(_lst_p)
- _lst_t=list(_lst_t)
- _lst_cc=list(_lst_cc)
-
- # decalage par rapport a l'abscisse curviligne (a regler)
- _x0 = 0.001
+ if not chargeLin :
+ nbCotes = len(_l_absz_m)
+ nbCotesEcre = nbCotes-1
+
+ # epsilon pour le decalage :
+ # le chargement est uniforme par maille
+ if _X0[1]>=_X0[0] :
+ epsx = 1.e-8
+ else :
+ epsx = -1.e-8
+ if _Y0[1]>=_Y0[0] :
+ epsy = 1.e-8
+ else :
+ epsy = -1.e-8
+
+ _lst_x0 = []
+ _lst_y0 = []
+ _lst_x0_b = []
+ _lst_y0_b = []
+ ly = []
+ ly2 = []
+ ly3 = []
+ ly4 = []
+
+ _lst_x0.append(_X0[0])
+ _lst_y0.append(_Y0[0])
+ _lst_x0_b.append(_X0_b[0])
+ _lst_y0_b.append(_Y0_b[0])
+ ly.append( _lst_f[0] )
+ ly2.append( _lst_p[0] )
+ ly3.append( _lst_t[0] )
+ ly4.append( _lst_cc[0] )
+
+ for i in range(nbCotes-2):
+ x = _X0[i+1]
+ y = _Y0[i+1]
+ toto1 = x - epsx
+ toto2 = x + epsx
+
+ _lst_x0.append( x - epsx )
+ _lst_x0.append( x + epsx )
+ _lst_y0.append( y - epsy )
+ _lst_y0.append( y + epsy )
+ x = _X0_b[i+1]
+ y = _Y0_b[i+1]
+ _lst_x0_b.append( x - epsx )
+ _lst_x0_b.append( x + epsx )
+ _lst_y0_b.append( y - epsy )
+ _lst_y0_b.append( y + epsy )
+ ly.append( _lst_f[i] )
+ ly.append( _lst_f[i+1] )
+ ly2.append( _lst_p[i] )
+ ly2.append( _lst_p[i+1] )
+ ly3.append( _lst_t[i] )
+ ly3.append( _lst_t[i+1] )
+ ly4.append( _lst_cc[i] )
+ ly4.append( _lst_cc[i+1] )
+
+ _lst_x0.append( _X0[nbCotes-1] )
+ _lst_y0.append( _Y0[nbCotes-1] )
+ _lst_x0_b.append( _X0_b[nbCotes-1] )
+ _lst_y0_b.append( _Y0_b[nbCotes-1] )
+ ly.append( _lst_f[nbCotesEcre-1] )
+ ly2.append( _lst_p[nbCotesEcre-1] )
+ ly3.append( _lst_t[nbCotesEcre-1] )
+ ly4.append( _lst_cc[nbCotesEcre-1] )
+ _lst_f = ly
+ _lst_p = ly2
+ _lst_t = ly3
+ _lst_cc = ly4
+ else :
+ _lst_x0 = [(x1+x2)*0.5 for (x1,x2) in zip(_X0[0:len(_X0)-1],_X0[1:len(_X0)])]
+ _lst_y0 = [(x1+x2)*0.5 for (x1,x2) in zip(_Y0[0:len(_Y0)-1],_Y0[1:len(_Y0)])]
+ _lst_x0_b = [(x1+x2)*0.5 for (x1,x2) in zip(_X0_b[0:len(_X0_b)-1],_X0_b[1:len(_X0_b)])]
+ _lst_y0_b = [(x1+x2)*0.5 for (x1,x2) in zip(_Y0_b[0:len(_Y0_b)-1],_Y0_b[1:len(_Y0_b)])]
+ _lst_x0.append(_X0[-1])
+ _lst_x0_b.append(_X0_b[-1])
+ _lst_y0.append(_Y0[-1])
+ _lst_y0_b.append(_Y0_b[-1])
# ANCIENNE VERSION (TRANSMISSION DES FLUX THERMIQUES
if(oldVersion) :
- # Creation des deux listes (x1, y1, x2, y2, ...)
+ alpha = round(theta)
+ if DIR_FISS == 'X' :
+ levre1pos = ((_Y0[0]-_yi)>=0.)
+ if alpha == -90. :
+ _lst_x0.reverse()
+ _lst_p.reverse()
+ _lst_f.reverse()
+ _lst_dir = _lst_x0
+ else :
+ levre1pos = ((_X0[0]-_xi)>=0.)
+ if abs(alpha) == 180. :
+ _lst_y0.reverse()
+ _lst_p.reverse()
+ _lst_f.reverse()
+ _lst_dir = _lst_y0
+
+ # Creation des listes pour les chargements aster :
+ # (x1, y1, x2, y2, ...)
_tmp1=[]
_tmp2=[]
_tmp3=[]
- for i in range(len(_lst_c)):
- _tmp1.append( _x0 + _lst_c[i] )
- _tmp1.append( _lst_f[i] )
- _tmp3.append( _x0 + _lst_c[i] )
- _tmp3.append( -1*_lst_f[i] )
+ for i in range(len(_lst_p)) :
+ _tmp1.append( _lst_dir[i] )
+ _tmp2.append( _lst_dir[i] )
+ _tmp3.append( _lst_dir[i] )
- _tmp2.append( _x0 + _lst_c[i] )
_tmp2.append( _lst_p[i] )
+ if levre1pos :
+ #_tmp1.append( -1*_lst_f[i] )
+ #_tmp3.append( _lst_f[i] )
+ _tmp1.append( _lst_f[i] )
+ _tmp3.append( -1*_lst_f[i] )
+ else :
+ #_tmp1.append( _lst_f[i] )
+ #_tmp3.append( -1*_lst_f[i] )
+ _tmp1.append( -1*_lst_f[i] )
+ _tmp3.append( _lst_f[i] )
+
- # Flux en provenance d'Ecrevisse
+ # Flux en provenance d'Ecrevisse
_L_F1=DEFI_FONCTION(NOM_PARA=DIR_FISS,
VALE=_tmp1,
- PROL_GAUCHE='CONSTANT',
- PROL_DROITE='CONSTANT');
+ PROL_GAUCHE='LINEAIRE',
+ PROL_DROITE='LINEAIRE');
_L_F2=DEFI_FONCTION(NOM_PARA=DIR_FISS,
VALE=_tmp3,
- PROL_GAUCHE='CONSTANT',
- PROL_DROITE='CONSTANT' );
-
- l_FLUX_REP_F1.append(_F(GROUP_MA=dFISSURE['GROUP_MA'][0],
- FLUX_X=_L_F1,))
-
- l_FLUX_REP_F2.append(_F(GROUP_MA=dFISSURE['GROUP_MA'][1],
- FLUX_X=_L_F2,))
+ PROL_GAUCHE='LINEAIRE',
+ PROL_DROITE='LINEAIRE' );
+
+ if DIR_FISS == 'X':
+ l_FLUX_REP_F1.append(_F(GROUP_MA=dFISSURE['GROUP_MA'][0],
+ FLUX_Y=_L_F1,))
+ l_FLUX_REP_F2.append(_F(GROUP_MA=dFISSURE['GROUP_MA'][1],
+ FLUX_Y=_L_F2,))
+ else :
+ l_FLUX_REP_F1.append(_F(GROUP_MA=dFISSURE['GROUP_MA'][0],
+ FLUX_X=_L_F1,))
+ l_FLUX_REP_F2.append(_F(GROUP_MA=dFISSURE['GROUP_MA'][1],
+ FLUX_X=_L_F2,))
# Pressions en provenance d'Ecrevisse
- _L_P=DEFI_FONCTION(NOM_PARA=DIR_FISS,
- VALE=_tmp2,
- PROL_GAUCHE='CONSTANT',
- PROL_DROITE='CONSTANT');
+ _L_P=DEFI_FONCTION(NOM_PARA = DIR_FISS,
+ VALE = _tmp2,
+ PROL_GAUCHE = 'LINEAIRE',
+ PROL_DROITE = 'LINEAIRE');
l_PRES_REP.append(_F(GROUP_MA=(dFISSURE['GROUP_MA'][0],dFISSURE['GROUP_MA'][1]),
PRES=_L_P,))
+
+
# NOUVELLE VERSION
else :
-
# Creation des deux listes (x1, y1, x2, y2, ...)
+ # On cree trois/six listes :
+ # Les valeurs sont constant par maille sur les levres de la fissure,
+ # _tmp1/_tmp2 = temperature
+ # _tmp3/_tmp4 = coefficient d echange
+ # _tmp5/_tmp6 = pression
_tmp1=[]
_tmp2=[]
_tmp3=[]
-
- for i in range(len(_lst_c)):
- # On cree trois listes :
- # _tmp1=temperature en chaque point du maillage,
- # _tmp3=coefficient d echange en chaque point du maillage
- # _tmp2=pression en chaque point du maillage
- _tmp1.append( _x0 + _lst_c[i] )
- _tmp1.append( _lst_t[i] )
- _tmp3.append( _x0 + _lst_c[i] )
- _tmp3.append( _lst_cc[i] )
-
- _tmp2.append( _x0 + _lst_c[i] )
- _tmp2.append( _lst_p[i] )
-
- _L_F1=DEFI_FONCTION(NOM_PARA=DIR_FISS,
+ _tmp4=[]
+ _tmp5=[]
+ _tmp6=[]
+
+ for i in range(len(_lst_f)) :
+ ix = copy(i)
+ iy = copy(i)
+ if _X0[1]<_X0[0] :
+ ix = len(_lst_f)-1-i
+ if _Y0[1]<_Y0[0] :
+ iy = len(_lst_f)-1-i
+
+ if (DIR_PREV=='X'):
+ _tmp1.append( _lst_x0[ix] )
+ _tmp1.append( _lst_t[ix] )
+ _tmp3.append( _lst_x0[ix] )
+ _tmp3.append( _lst_cc[ix] )
+ _tmp5.append( _lst_x0[ix] )
+ _tmp5.append( _lst_p[ix] )
+ _tmp2.append( _lst_x0_b[ix] )
+ _tmp2.append( _lst_t[ix] )
+ _tmp4.append( _lst_x0_b[ix] )
+ _tmp4.append( _lst_cc[ix] )
+ _tmp6.append( _lst_x0_b[ix] )
+ _tmp6.append( _lst_p[ix] )
+ else :
+ _tmp1.append( _lst_y0[iy] )
+ _tmp1.append( _lst_t[iy] )
+ _tmp3.append( _lst_y0[iy] )
+ _tmp3.append( _lst_cc[iy] )
+ _tmp5.append( _lst_y0[iy] )
+ _tmp5.append( _lst_p[iy] )
+ _tmp2.append( _lst_y0_b[iy] )
+ _tmp2.append( _lst_t[iy] )
+ _tmp4.append( _lst_y0_b[iy] )
+ _tmp4.append( _lst_cc[iy] )
+ _tmp6.append( _lst_y0_b[iy] )
+ _tmp6.append( _lst_p[iy] )
+
+
+
+
+
+ # Couplage thermique : Temperature et coefficients d'echange en provenance d'Ecrevisse
+ _L_T1=DEFI_FONCTION(NOM_PARA=DIR_PREV,
VALE=_tmp1,
- PROL_GAUCHE='CONSTANT',
- PROL_DROITE='CONSTANT');
+ PROL_GAUCHE='LINEAIRE',
+ PROL_DROITE='LINEAIRE')
- _L_F2=DEFI_FONCTION(NOM_PARA=DIR_FISS,
+ _L_T2=DEFI_FONCTION(NOM_PARA=DIR_PREV,
+ VALE=_tmp2,
+ PROL_GAUCHE='LINEAIRE',
+ PROL_DROITE='LINEAIRE')
+
+ _L_CC1=DEFI_FONCTION(NOM_PARA=DIR_PREV,
VALE=_tmp3,
- PROL_GAUCHE='CONSTANT',
- PROL_DROITE='CONSTANT');
+ PROL_GAUCHE='LINEAIRE',
+ PROL_DROITE='LINEAIRE')
+
+ _L_CC2=DEFI_FONCTION(NOM_PARA=DIR_PREV,
+ VALE=_tmp4,
+ PROL_GAUCHE='LINEAIRE',
+ PROL_DROITE='LINEAIRE')
l_ECHANGE_F1.append(_F(GROUP_MA=dFISSURE['GROUP_MA'][0],
- TEMP_EXT=_L_F1,
- COEF_H=_L_F2))
+ TEMP_EXT=_L_T1,
+ COEF_H=_L_CC2))
l_ECHANGE_F2.append(_F(GROUP_MA=dFISSURE['GROUP_MA'][1],
- TEMP_EXT=_L_F1,
- COEF_H=_L_F2))
+ TEMP_EXT=_L_T2,
+ COEF_H=_L_CC2))
- # Pressions en provenance d'Ecrevisse
- _L_P=DEFI_FONCTION(NOM_PARA=DIR_FISS,
- VALE=_tmp2,
- PROL_GAUCHE='CONSTANT',
- PROL_DROITE='CONSTANT');
+ # Couplage mecanique : Pressions en provenance d'Ecrevisse
+ _L_P1=DEFI_FONCTION(NOM_PARA=DIR_PREV,
+ VALE=_tmp5,
+ PROL_GAUCHE='LINEAIRE',
+ PROL_DROITE='LINEAIRE')
- l_PRES_REP.append(_F(GROUP_MA=(dFISSURE['GROUP_MA'][0],dFISSURE['GROUP_MA'][1]),
- PRES=_L_P,))
+ _L_P2=DEFI_FONCTION(NOM_PARA=DIR_PREV,
+ VALE=_tmp6,
+ PROL_GAUCHE='LINEAIRE',
+ PROL_DROITE='LINEAIRE')
+
+ l_PRES_REP.append(_F(GROUP_MA=(dFISSURE['GROUP_MA'][0]),
+ PRES=_L_P1,))
+ l_PRES_REP.append(_F(GROUP_MA=(dFISSURE['GROUP_MA'][1]),
+ PRES=_L_P2,))
- #
# Fin extraction des conditions limites du calcul Ecrevisse
# ----------------------------------------------------------
- # Fin de la boucle sur les fissures
-
+ if debug :
+ print ('FISSURE-'+str(k+1))
+ print '_lst_c:', len(_lst_c), _lst_c
+ print '_lst_f:', len(_lst_f), _lst_f
+ print '_lst_p:', len(_lst_p), _lst_p
+ print '_lst_t:', len(_lst_t), _lst_t
+ print '_lst_cc:', len(_lst_cc), _lst_cc
+ print '_lst_x0:', len(_lst_x0), _lst_x0
+ print '_lst_x0_b :', len(_lst_x0_b), _lst_x0_b
+ print '_lst_y0:', len(_lst_y0), _lst_y0
+ print '_lst_y0_b :', len(_lst_y0_b), _lst_y0_b
+ print '_tmp1 :', len(_tmp1), _tmp1
+ print '_tmp2 :', len(_tmp2), _tmp2
+ print '_tmp3 :', len(_tmp3), _tmp3
+ if (not oldVersion) :
+ print '_tmp4 :', len(_tmp4), _tmp4
+ print '_tmp5 :', len(_tmp5), _tmp5
+ print '_tmp6 :', len(_tmp6), _tmp6
+
+ #Fin du boucle sur la fissure for k
# Assemblage des concepts sortants
-#@ MODIF calc_essai_ops Macro DATE 21/10/2008 AUTEUR NISTOR I.NISTOR
+#@ MODIF calc_essai_ops Macro DATE 28/01/2010 AUTEUR BODEL C.BODEL
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
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):
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 = {}
"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
# 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,
-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
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:
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
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
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()
-#@ 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
# ======================================================================
import types,string
import os
-import Numeric as N
+import numpy
import math
import copy
#-----------------------------------------------------------------------
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
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
#-----------------------------------------------------------------------
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)
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))
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))
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] )
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
-#@ 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
# ======================================================================
# 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,
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)
return ier
-# -----------------------------------------------------------------------------
+
class Context(object):
"""Permet de stocker des éléments de contexte pour aider au
diagnostic lors de l'émission de message.
-#@ 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
# ======================================================================
# ======================================================================
# RESPONSABLE Mohamed TORKHANI
-from Numeric import *
import aster
from Accas import _F
from types import ListType, TupleType
-#@ 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
# ======================================================================
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:
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,
-#@ 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
# ======================================================================
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'
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
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 :
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.;
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=[];
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]);
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)]
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])]
#-- 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
#-- 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,);
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
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;
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,);
-#@ 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
# ======================================================================
# 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):
"""
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
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:
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'])
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 = []
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'])
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')
#----------------------------------------------
# 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()
-#@ 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
# ======================================================================
# 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
# ======================================================================
# 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
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)
. 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 ) :
# 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
#
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
#
# ------------------------------------------------------------------------------
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
#
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
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 = {}
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) :
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" :
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"
#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 = {}
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 = {}
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 :
", 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 "
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
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"
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"
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"
#
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")
# 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
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
#
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") :
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") :
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
#
#
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
# ------------------------------------------------------------------------------
break
#
if message_erreur is not None :
- UTMESS("F",'HOMARD0_2',valk=message_erreur)
+ UTMESS("F", 'HOMARD0_2', valk=message_erreur)
#
return nomfic_global
--- /dev/null
+#@ 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]<TFIN :
+ fff[i]=fff[i]+FcontinuGR2(temps[i],I1,I2,TR,PHI1,PHI2,TAU1,TAU2,DIST)
+ if temps[i]>TINIR :
+ if temps[i]<TFINR :
+ fff[i]=fff[i]+FcontinuGR2R(temps[i],I1R,I2R,TRR,PHI1R,PHI2R,TAU1R,TAU2R,DIST)
+#
+ if SIGNAL=='COMPLET' :
+ for i in range(len(temps)) :
+ if temps[i]>TINI :
+ if temps[i]<TFIN :
+ fff[i]=fff[i]+FcompletGR2(temps[i],I1,I2,TR,PHI1,PHI2,TAU1,TAU2,DIST)
+ if temps[i]>TINIR :
+ if temps[i]<TFINR :
+ fff[i]=fff[i]+FcompletGR2R(temps[i],I1R,I2R,TRR,PHI1R,PHI2R,TAU1R,TAU2R,DIST)
+#
+ vale=[]
+ for i in range(len(temps)) :
+ vale.append(temps[i])
+ vale.append(fff[i])
+ vale.append(temps[-1]+2*pas_t)
+ vale.append(0.)
+#
+ C_out=DEFI_FONCTION(NOM_PARA='INST',NOM_RESU='ELEC',
+ VALE=vale,
+ PROL_DROITE='CONSTANT',
+ PROL_GAUCHE='CONSTANT',)
+ return ier
-#@ MODIF defi_inte_spec_ops Macro DATE 16/10/2007 AUTEUR REZETTE C.REZETTE
+#@ MODIF defi_inte_spec_ops Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
+import math
+
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]))
+ if arg[0]=='RI' : return complex(arg[1], arg[2])
+ if arg[0]=='MP' : return complex(arg[1]*math.cos(arg[2]), arg[1]*math.sin(arg[2]))
+
def defi_inte_spec_ops(self,DIMENSION,PAR_FONCTION,KANAI_TAJIMI,
CONSTANT,TITRE,INFO,**args):
EnumTypes = (ListType, TupleType)
from Accas import _F
from Utilitai.Utmess import UTMESS
- import Numeric
+ import numpy
commande='DEFI_INTE_SPEC'
else :
valr=1.
vali=0.
- x1=Numeric.arange(occ[1]['FREQ_MIN'],occ[1]['FREQ_MAX'],occ[1]['PAS'])
+ x1=numpy.arange(occ[1]['FREQ_MIN'],occ[1]['FREQ_MAX'],occ[1]['PAS'])
x1=x1.tolist()+[occ[1]['FREQ_MAX'],]
valc=[]
for absc in x1 : valc=valc+[absc,valr,vali]
if occ[0]=='KANAI_TAJIMI' :
amor = occ[1]['AMOR_REDUIT']
frqmoy = occ[1]['FREQ_MOY']
- x11 =Numeric.array([4*(amor**2)*(frqmoy**2)*FREQ**2 \
+ x11 =numpy.array([4*(amor**2)*(frqmoy**2)*FREQ**2 \
for FREQ in x1 ])
xnum =x11+frqmoy**4
- denom=Numeric.array([ (frqmoy**2-FREQ**2)**2 \
+ denom=numpy.array([ (frqmoy**2-FREQ**2)**2 \
for FREQ in x1 ])
denom=denom+x11
- g0=Numeric.array([valr]*len(denom))
+ g0=numpy.array([valr]*len(denom))
g0=g0*xnum/denom
valc=[]
for i in range(len(x1)): valc=valc+[x1[i],g0[i],0.]
-#@ MODIF dyna_iss_vari_ops Macro DATE 16/11/2009 AUTEUR COURTOIS M.COURTOIS
+#@ MODIF dyna_iss_vari_ops Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
-from Accas import _F
-import string
+import os
+
def dyna_iss_vari_ops(self, NOM_CMP, PRECISION, INTERF,MATR_COHE, FREQ_INIT,UNITE_RESU_FORC,
NB_FREQ, PAS, UNITE_RESU_IMPE, TYPE, MATR_GENE , OPTION,INFO,
Macro DYNA_ISS_VARI
"""
ier=0
- import Numeric as Num
- import LinearAlgebra as LinAl
- import MLab
- import os
+ import numpy as NP
+ from numpy import linalg
import aster
- diag = MLab.diag
- max = MLab.max
- min = MLab.min
- sum = Num.sum
- abs = Num.absolute
- conj = Num.conjugate
+ from Accas import _F
from Utilitai.Table import Table
from Utilitai.Utmess import UTMESS
def get_group_coord(group):
"""Retourne les coordonnees des noeuds du groupe 'group'
"""
- l_ind = Num.array(coll_grno.get('%-8s' % group, [])) - 1
- return Num.take(t_coordo, l_ind)
+ l_ind = NP.array(coll_grno.get('%-8s' % group, [])) - 1
+ return NP.take(t_coordo, l_ind, axis=0)
# On importe les definitions des commandes a utiliser dans la macro
# coordonnees des noeuds
l_coordo = maillage.COORDO.VALE.get()
- t_coordo = Num.array(l_coordo)
+ t_coordo = NP.array(l_coordo)
t_coordo.shape = nbnot, 3
# groupes de noeuds
coll_grno = maillage.GROUPENO.get()
GROUP_NO_INTER=INTERF['GROUP_NO_INTERF']
noe_interf = get_group_coord(GROUP_NO_INTER)
- # print noe_interf
nbno, nbval = noe_interf.shape
if INFO==2:
aster.affiche('MESSAGE','NBNO INTERFACE : '+str(nbno))
texte = 'NOMBRE DE MODES: '+str(nbmodt)+' MODES DYNAMIQUES: '+str(nbmodd)+' MODES STATIQUES: '+str(nbmods)
aster.affiche('MESSAGE',texte)
aster.affiche('MESSAGE','COMPOSANTE '+NOM_CMP)
- SPEC = Num.zeros((NB_FREQ,nbmodt,nbmodt), Num.Float)+1j
+ SPEC = NP.zeros((NB_FREQ,nbmodt,nbmodt)) + 1j
#
#---------------------------------------------------------------------
# BOUCLE SUR LES FREQUENCES
XX=noe_interf[:,0]
YY=noe_interf[:,1]
- XN=Num.repeat(XX,nbno)
- YN=Num.repeat(YY,nbno)
- XR=Num.reshape(XN,(nbno,nbno))
- YR=Num.reshape(YN,(nbno,nbno))
- XRT=Num.transpose(XR)
- YRT=Num.transpose(YR)
+ XN=NP.repeat(XX,nbno)
+ YN=NP.repeat(YY,nbno)
+ XR=NP.reshape(XN,(nbno,nbno))
+ YR=NP.reshape(YN,(nbno,nbno))
+ XRT=NP.transpose(XR)
+ YRT=NP.transpose(YR)
DX=XR-XRT
DY=YR-YRT
DIST=DX**2+DY**2
- COHE=Num.exp(-(DIST*(alpha*freqk/VITE_ONDE)**2.))
+ COHE=NP.exp(-(DIST*(alpha*freqk/VITE_ONDE)**2.))
# On desactive temporairement les FPE qui pourraient etre generees (a tord!) par blas
aster.matfpe(-1)
- eig, vec =LinAl.eigenvectors(COHE)
+ eig, vec =linalg.eig(COHE)
+ vec = NP.transpose(vec) # les vecteurs sont en colonne dans numpy
aster.matfpe(1)
eig=eig.real
vec=vec.real
# on rearrange selon un ordre decroissant
- eig = Num.where(eig < 1.E-10, 0.0, eig)
- order = (Num.argsort(eig)[::-1])
- eig = Num.take(eig, order)
- vec = Num.take(vec, order, 0)
+ eig = NP.where(eig < 1.E-10, 0.0, eig)
+ order = (NP.argsort(eig)[::-1])
+ eig = NP.take(eig, order)
+ vec = NP.take(vec, order, 0)
#-----------------------
# Nombre de modes POD a retenir
- etot=sum(diag(COHE))
+ etot=NP.sum(NP.diag(COHE))
ener=0.0
nbme=0
aster.affiche('MESSAGE','NOMBRE DE MODES POD RETENUS : '+str(nbme))
aster.affiche('MESSAGE','PRECISION (ENERGIE RETENUE) : '+str(prec))
- PVEC=Num.zeros((nbme,nbno), Num.Float)
+ PVEC=NP.zeros((nbme,nbno))
for k1 in range(0,nbme):
- PVEC[k1, 0:nbno]=Num.sqrt(eig[k1])*vec[k1]
+ PVEC[k1, 0:nbno]=NP.sqrt(eig[k1])*vec[k1]
# CALCUL DE FS variable-------------------------------
- XO=Num.zeros((nbme,nbmods), Num.Float)
+ XO=NP.zeros((nbme,nbmods))
if NOM_CMP=='DX':
COMP = 1
elif NOM_CMP=='DY':
NNO =__CHAM.EXTR_COMP(NOM_CMP,[GROUP_NO_INTER], topo=1).noeud
- som=sum(MCMP)
- max1=max(MCMP)
- min1=min(MCMP)
- maxm=max([abs(max1),abs(min1)])
+ som=NP.sum(MCMP)
+ max1=NP.max(MCMP)
+ min1=NP.min(MCMP)
+ maxm=NP.max([NP.abs(max1), NP.abs(min1)])
#CALCUL DE XO
# on recupere la composante COMP (dx,dy,dz) des modes et on projete
# CAS 1: MODES DE CORPS RIGIDE
for modp in range(0,nbme):
#modes de translation
if mods+1 <=3:
- if abs(som)<10.E-6:
+ if NP.abs(som)<10.E-6:
XO[modp,mods]=0.0
else :
fact=1./som
- XO[modp,mods]=fact*Num.innerproduct(MCMP,PVEC[modp])
+ XO[modp,mods]=fact*NP.inner(MCMP,PVEC[modp])
#modes de rotation
else:
if maxm<10.E-6:
UTMESS('F','ALGORITH6_86')
else :
fact = 1./(nbno)
- XO[modp,mods]=1./(maxm**2.)*fact*Num.innerproduct(MCMP,PVEC[modp])
+ XO[modp,mods]=1./(maxm**2.)*fact*NP.inner(MCMP,PVEC[modp])
# CAS 2: MODES EF
if INTERF['MODE_INTERF'] =='TOUT':
for modp in range(0,nbme):
- if abs(som)<10.E-6:
+ if NP.abs(som)<10.E-6:
if maxm<10.E-6:
XO[modp,mods]=0.0
else:
UTMESS('F','UTILITAI5_89')
else:
fact=1./som
- XO[modp,mods]=fact*Num.innerproduct(MCMP,PVEC[modp])
+ XO[modp,mods]=fact*NP.inner(MCMP,PVEC[modp])
DETRUIRE(CONCEPT=_F(NOM=(__CHAM)),INFO=1)
# force sismique pour verif
# FS0=__fosi.EXTR_VECT_GENE_C()
# FSE=FS0[nbmodd:nbmodt][:]
- SP=Num.zeros((nbmodt,nbmodt),Num.Float)
+ SP=NP.zeros((nbmodt,nbmodt))
for k1 in range(0,nbme):
# calcul de la force sismique mode POD par mode POD
- FS = Num.matrixmultiply(KRS,XO[k1])
- Fzero=Num.zeros((1,nbmodd),Num.Float)
- FS2=Num.concatenate((Fzero,Num.reshape(FS,(1,nbmods))),1)
+ FS = NP.dot(KRS,XO[k1])
+ Fzero=NP.zeros((1,nbmodd))
+ FS2=NP.concatenate((Fzero,NP.reshape(FS,(1,nbmods))),1)
# Calcul harmonique
__fosi.RECU_VECT_GENE_C(FS2[0])
__dyge = DYNA_LINE_HARM(MODELE=modele,
assert desc[0].strip() == 'DEPL', 'Champ DEPL non trouvé'
nomcham = __dyge.TACH.get()[1][0].strip()
cham = sd_cham_gene(nomcham)
- RS = Num.array(cham.VALE.get())
- SP=SP+RS*conj(RS[:,Num.NewAxis])
+ RS = NP.array(cham.VALE.get())
+ SP=SP+RS*NP.conj(RS[:,NP.newaxis])
DETRUIRE(CONCEPT=_F(NOM=(__dyge)),INFO=1)
-
SPEC[k]=SP
abscisse[k]= freqk
-#@ MODIF exec_logiciel_ops Macro DATE 16/11/2009 AUTEUR ASSIRE A.ASSIRE
+#@ MODIF exec_logiciel_ops Macro DATE 15/03/2010 AUTEUR COURTOIS M.COURTOIS
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# RESPONSABLE COURTOIS M.COURTOIS
-import os.path
+import os
+import os.path as osp
import traceback
import shutil
from types import ListType, TupleType
dMCF = mcf.cree_dict_valeurs(mcf.mc_liste)
d_para['fichIN'] = 'fort.%d' % dMCF['UNITE_GEOM']
d_para['fichOUT'] = 'fort.%d' % dMCF['UNITE']
+ if osp.exists(d_para['fichOUT']):
+ os.remove(d_para['fichOUT'])
if dMCF['FORMAT'] == 'GMSH':
mode_lancement = CMD_EXTERNE
cmd = '%(prog)s %(options)s -o %(fichOUT)s %(fichIN)s'
- d_para['prog'] = os.path.join(aster.repout(), 'gmsh')
+ d_para['prog'] = osp.join(aster.repout(), 'gmsh')
d_para['options'] = ('-3',)
elif dMCF['FORMAT'] == 'GIBI':
mode_lancement = CMD_EXTERNE
cmd = '%(prog)s %(options)s %(fichIN)s %(fichOUT)s'
- d_para['prog'] = os.path.join(aster.repout(), 'gibi')
+ d_para['prog'] = osp.join(aster.repout(), 'gibi')
elif dMCF['FORMAT'] == 'SALOME':
mode_lancement = EXECFILE
txt = open(d_para['fichIN'], 'r').read()
UTMESS('F', 'EXECLOGICIEL0_5', valk=txt)
- if not os.path.exists(d_para['fichMED']):
+ if not osp.exists(d_para['fichMED']):
UTMESS('F', 'EXECLOGICIEL0_6', valk=d_para['fichMED'])
else:
# copie fichMED vers fichOUT pour pouvoir le récupérer
umail = UL.Libre(action='ASSOCIER',
nom='exec_logiciel.%s2mail' % dMCF['FORMAT'].lower())
+ if not osp.exists(d_para['fichOUT']):
+ UTMESS('F', 'EXECLOGICIEL0_13', valk=dMCF['FORMAT'])
+
# déclaration du concept maillage en sortie
self.DeclareOut('mail', dMCF['MAILLAGE'])
-#@ MODIF fiabilite_mefisto Macro DATE 16/10/2007 AUTEUR REZETTE C.REZETTE
+#@ MODIF fiabilite_mefisto Macro DATE 11/05/2010 AUTEUR COURTOIS M.COURTOIS
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
+# RESPONSABLE GNICOLAS G.NICOLAS
+
+import os
-# RESPONSABLE GNICOLAS G.NICOLAS
-#
def fiabilite_mefisto ( self, Rep_Calc_LOGICIEL_global,
INFO, VERSION,
SEUIL, SEUIL_TYPE,
#
""" Ecriture des données spécifiques à MEFISTO. """
#
+ import numpy
from Macro import fiabilite_fichier
- import os
- import string
- import Numeric
from Utilitai.Utmess import UTMESS
#
#____________________________________________________________________
# 4.3 ==> 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" ]
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 )
#
-#@ 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
# ======================================================================
# ======================================================================
# 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])<EPSI:
- AMO_f[jj][ii]=0.0;
- DETRUIRE(CONCEPT=_F(NOM=(tabfr_f)),INFO=1)
-
- if NFREQ_t>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
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
#-------------------------------------------------------------------------
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;
# ------------------------------------------------------------------
# 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
#-----------------------
#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]
# 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;
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;
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;
# 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'
# 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)
# 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)
# 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
# ------------------------------------------------------------------
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];
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
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];
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,)
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];
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
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
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]);
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];
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];
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;
SOUS_TITRE = TITRE2,
GRILLE_X = pasV,
GRILLE_Y = pasF,
- LEGENDE_X = 'Vitesse (tr/mn)',
+ LEGENDE_X = legende_x,
LEGENDE_Y = 'FREQ (Hz)',
**mfac1);
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)
SOUS_TITRE = TITRE2,
GRILLE_X = pasV,
GRILLE_Y = pasF,
- LEGENDE_X = 'Vitesse (tr/mn)',
+ LEGENDE_X = legende_x,
LEGENDE_Y = 'FREQ (Hz)',
**mfac1);
TITRE = TITRE1,
GRILLE_X = pasV,
GRILLE_Y = pasF,
- LEGENDE_X = 'Vitesse (tr/mn)',
+ LEGENDE_X = legende_x,
LEGENDE_Y = 'FREQ (Hz)',
**mfac1);
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(
TITRE = TITRE1,
GRILLE_X = pasV,
GRILLE_Y = pasF,
- LEGENDE_X = 'Vitesse (tr/mn)',
+ LEGENDE_X = legende_x,
LEGENDE_Y = 'FREQ (Hz)',
**mfac1);
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)
#------------------------------------------------------------------------------------
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);
SOUS_TITRE = TITRE2,
GRILLE_X = pasV,
GRILLE_Y = pasF,
- LEGENDE_X = 'Vitesse (tr/mn)',
+ LEGENDE_X = legende_x,
LEGENDE_Y = 'FREQ (Hz)',
**mfac1);
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:
SOUS_TITRE = TITRE2,
GRILLE_X = pasV,
GRILLE_Y = pasF,
- LEGENDE_X = 'Vitesse (tr/mn)',
+ LEGENDE_X = legende_x,
LEGENDE_Y = 'FREQ (Hz)',
**mfac1);
TITRE = TITRE1,
GRILLE_X = pasV,
GRILLE_Y = pasF,
- LEGENDE_X = 'Vitesse (tr/mn)',
+ LEGENDE_X = legende_x,
LEGENDE_Y = 'FREQ (Hz)',
**mfac1);
# 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 =[];
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
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')
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
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
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()
-
-#------------------------------------------------------------------------------------
-
--- /dev/null
+#@ 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])<EPSI:
+ AMO_f[jj][ii]=0.0;
+ DETRUIRE(CONCEPT=_F(NOM=(tabfr_f)),INFO=1)
+
+ if NFREQ_t>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=' '
+
-#@ 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
# ======================================================================
# 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
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
# 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
-#@ 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
# ======================================================================
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
-#@ 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
# ======================================================================
# 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
"""
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,
# 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]
# 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
import aster
import string
import os
- import shutil
+ from types import ListType, TupleType
+ EnumTypes = (ListType, TupleType)
+#gn import shutil
#
global Liste_Passages
#
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"
liste_maillages = []
liste_champs = []
liste_zones = []
+ liste_front_analytiques = []
dico_indi = {}
#
LISTE_ADAPTATION_LIBRE = ("RAFF_DERA" , "RAFFINEMENT" , "DERAFFINEMENT")
#
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"
#
#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."
#
#
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 ) :
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
#
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
#
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 ) :
#
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
#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
#====================================================================
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
#
#
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 ) :
#
# 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
#
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
### 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",
**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
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 = []
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]
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 = {}
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 :
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
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]
#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 ) :
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)
#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)
# ==> 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
#
#====================================================================
# 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 !
#
### if ( mode_homard == "ADAP" and niter == 3 ) :
### if ( niter == 2 ) :
-### import time
-### time.sleep(3600)
+#gn import time
+#gn time.sleep(3600)
#
return
-#@ 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
# ======================================================================
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' )
# 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 ---
#
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
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 ---
#
-#@ 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
# ======================================================================
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' )
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 ---
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
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 ,
-#@ 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
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
-
+
# Appel à CREA_MAILLAGE :
motscles={}
if TOUT : motscles['TOUT'] =TOUT
if GROUP_MA : motscles['GROUP_MA'] =GROUP_MA
if MAILLE : motscles['MAILLE'] =MAILLE
-
+
self.DeclareOut('ma2',MAILLAGE)
ma2=CREA_MAILLAGE(ECLA_PG=_F( MODELE = MODELE_INIT, NOM_CHAM=NOM_CHAM,
SHRINK = SHRINK, TAILLE_MIN=TAILLE_MIN, **motscles ));
-
-
+
+
# Appel à CREA_RESU :
- typ2=AsType(RESU_INIT).__name__
- if TOUT_ORDRE : motscles['TOUT_ORDRE'] =TOUT_ORDRE
- if NUME_ORDRE : motscles['NUME_ORDRE'] =NUME_ORDRE
- if LIST_ORDRE : motscles['LIST_ORDRE'] =LIST_ORDRE
- if LIST_INST : motscles['LIST_INST'] =LIST_INST
- if INST : motscles['INST'] =INST
- if TOUT_ORDRE : motscles['TOUT_ORDRE'] =TOUT_ORDRE
+ typ2=AsType(RESU_INIT).__name__
+ if TOUT_ORDRE : motscles['TOUT_ORDRE'] =TOUT_ORDRE
+ if NUME_ORDRE != None : motscles['NUME_ORDRE'] =NUME_ORDRE
+ if LIST_ORDRE : motscles['LIST_ORDRE'] =LIST_ORDRE
+ if LIST_INST : motscles['LIST_INST'] =LIST_INST
+ if INST != None : motscles['INST'] =INST
self.DeclareOut('resu2',RESULTAT)
resu2=CREA_RESU( OPERATION='ECLA_PG', TYPE_RESU=string.upper(typ2),
ECLA_PG=_F( MODELE_INIT= MODELE_INIT, RESU_INIT=RESU_INIT, NOM_CHAM=NOM_CHAM,
MAILLAGE= ma2, **motscles ));
- return ier
+ return ier
############################################################################################
-#@ MODIF macr_ecre_calc_ops Macro DATE 05/10/2009 AUTEUR ASSIRE A.ASSIRE
+#@ MODIF macr_ecre_calc_ops Macro DATE 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.
# ======================================================================
LOGICIEL,
VERSION,
ENTETE,
- COURBES,
+ #COURBES,
IMPRESSION,
INFO,
**args):
import os, string, types, shutil
import aster
from Accas import _F
- from Noyau.N_utils import AsType
+ #from Noyau.N_utils import AsType
from Utilitai.Utmess import UTMESS
from Utilitai.System import ExecCommand
ier=0
+
+ # PARAMETRES DEBUG
+ debug = True
+
+
+
# Concept sortant
self.DeclareOut('__TAB',TABLE)
self.DeclareOut('__DEB',DEBIT)
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
- # Parametres
- # Niveaux de debug
- debug1 = (INFO>1)
- debug2 = (INFO>2)
-
+ # Info
+ info2 = (INFO==2)
+ if debug :
+ info2=True
# Parametres Developpeur
tmp_ecrevisse = "tmp_ecrevisse"
- fichier_data = "data.dat"
- defaut = '00'
+ fichier_data = "data.dat"
+ defaut = '00'
# IMPORTATION DE COMMANDES ASTER
EXEC_LOGICIEL = self.get_cmd("EXEC_LOGICIEL")
for i in dCONVERGENCE.keys():
if dCONVERGENCE[i]==None : del dCONVERGENCE[i]
- if debug2:
- print 'dFISSURE = ', dFISSURE
- print 'dECOULEMENT = ', dECOULEMENT
- print 'dTEMPERATURE = ', dTEMPERATURE
- print 'dMODELE_ECRE = ', dMODELE_ECRE
- print 'dCONVERGENCE = ', dCONVERGENCE
- print 'ENTETE = ', ENTETE
- print 'IMPRESSION = ', IMPRESSION
- print 'INFO = ', INFO
+ if debug:
+ print 'dFISSURE = ', dFISSURE
+ print 'dECOULEMENT = ', dECOULEMENT
+ print 'dTEMPERATURE = ', dTEMPERATURE
+ print 'dMODELE_ECRE = ', dMODELE_ECRE
+ print 'dCONVERGENCE = ', dCONVERGENCE
+ print 'ENTETE = ', ENTETE
+ print 'IMPRESSION = ', IMPRESSION
+ print 'INFO = ', INFO
+
-# ---------------------------------------------------------------------
- # CONSTRUCTION DU JEU DE PARAMETRES
+
+# ---------------------------------------------------------------------
+# CONSTRUCTION DU JEU DE PARAMETRES
d = {}
d[ 0 ] = ENTETE,
d[ 89 ] = dCONVERGENCE['ITER_GLOB_MAXI'],
d[ 90 ] = dCONVERGENCE['CRIT_CONV_DEBI'],
- if debug2: print d
+ if debug: print d
+
+
+
# ---------------------------------------------------------------------
+# GENERATION DU FICHIER DATA.DAT
- # GENERATION DU FICHIER DATA.DAT
txt = fichier_data_ecrevisse()
for num_param in d.keys():
# On remplace la variable dans le fichier par sa valeur
txt = txt.replace( '$V['+str(num_param)+']', txt0 )
- if debug1: print txt
+ if debug : print txt
+
+
# ---------------------------------------------------------------------
+# CREATION DE L'ENVIRONNEMENT D'ETUDE POUR ECREVISSE
- # CREATION DE L'ENVIRONNEMENT D'ETUDE POUR ECREVISSE
# Repertoire temporaire d'execution d'Ecrevisse
tmp_ecrevisse = os.path.join(os.getcwd(),tmp_ecrevisse)
- if not os.path.isdir(tmp_ecrevisse):
+ if not os.path.isdir(tmp_ecrevisse) :
try :
os.mkdir(tmp_ecrevisse)
except os.error,erreur :
- print "Code d'erreur de mkdir : " + str(erreur[0]) + " : " + str(erreur[1])
+ if debug :
+ print "Code d'erreur de mkdir : " + str(erreur[0]) + " : " + str(erreur[1])
UTMESS('F','ECREVISSE0_12',valk=[tmp_ecrevisse])
# On recopie eventuellement l'ancien fichier debits
try:
shutil.copyfile(src, dst)
except Exception, e:
- print "ERREUR : copyfile %s -> %s" % (src, dst)
+ UTMESS('F','ECREVISSE0_24',valk=[src, dst])
+ #print "ERREUR : copyfile %s -> %s" % (src, dst)
# Executable Ecrevisse
- if LOGICIEL:
+ if LOGICIEL :
if not os.path.isfile(str(LOGICIEL)):
UTMESS('F','ECREVISSE0_13')
else:
chemin_executable = str(LOGICIEL)
- else:
+ else :
chemin_executable = os.path.join(aster.repout(), 'ecrevisse')
+ #chemin_executable = os.path.join(aster.repout(),version,'ecrevisse')
+ if debug :
+ print 'chemin_executable:',chemin_executable
# Soit on fait un lien symbolique (incompatible avec certaines plate-formes) soit on recopie l'executable
if not os.path.isfile(os.path.join(tmp_ecrevisse, 'ecrevisse')):
# ---------------------------------------------------------------------
-
- # EXECUTION D'ECREVISSE
+# EXECUTION D'ECREVISSE
# Choix du shell
cmd = '#!sh'
# cmd = cmd + '\nexport LD_LIBRARY_PATH=/logiciels/aster/Linux/GF4/public/gcc-4.1.1/lib:$LD_LIBRARY_PATH'
# Creation du contenu du script de lancement ecrevisse.sh
- cmd = cmd + '\ncd ' + tmp_ecrevisse + '\n' + os.path.join(tmp_ecrevisse, 'ecrevisse') + '\nset iret=$?\ncd ..\nexit $iret'
+ cmd = cmd + '\ncd ' + tmp_ecrevisse + '\n' + os.path.join(tmp_ecrevisse, 'ecrevisse') + ' ' + str(VERSION) + '\nset iret=$?\ncd ..\nexit $iret'
fw = open(os.path.join(tmp_ecrevisse, 'ecrevisse.sh'),'w')
fw.write(cmd)
fw.close()
UTMESS('I','ECREVISSE0_17')
- if debug1: os.system('ls -al ' + tmp_ecrevisse)
+ if info2: os.system('ls -al ' + tmp_ecrevisse)
+
-# ---------------------------------------------------------------------
- # RECUPERATION DU RESULTAT DEPUIS ECREVISSE
+# ---------------------------------------------------------------------
+# RECUPERATION DES RESULTATS DEPUIS ECREVISSE
+ # 1) 5 COLONNES (a partir de ECREVISSE 3.1.e)
+ # COTE z (m), FLUX THERMIQUE (W/m2), PRESSION TOTALE ABSOLUE (Pa),
+ # TEMPERATURE FLUIDE (degres C), COEFFICIENT DE CONVECTION (W/m2/K)
try:
- f_ast = open(os.path.join(tmp_ecrevisse, 'pour_aster'),'r')
- _txt = f_ast.read()
- f_ast.close()
- # transforme le texte en liste
- _lst = _txt.split()
- # transforme la liste de textes en liste de float
- _lst = map( float, _lst )
-
- # 5 colonnes (a partir de ECREVISSE 3.1.e)
- # cote z (m), flux thermique (W/m2), pression totale absolue (Pa), temperature fluide (degres C), coefficient de convection (W/m2/K)
- _ecr_c = _lst[1:len(_lst):5]
- _ecr_f = _lst[2:len(_lst):5]
- _ecr_p = _lst[3:len(_lst):5]
- _ecr_t = _lst[4:len(_lst):5]
- _ecr_cc = _lst[5:len(_lst):5]
-
+ f_ast = open(os.path.join(tmp_ecrevisse, 'pour_aster'),'r')
+ _txt = f_ast.read()
+ f_ast.close()
+ # transforme le texte en liste
+ _lst = _txt.split()
+ # transforme la liste de textes en liste de float
+ _lst = map( float, _lst )
+
+ # ATTENTION : les cotes _ecr_c sont celles des resultats ecrevisse,
+ # c'est a dire les points de milieu du maillage aster,
+ # eventuellement multiplies par 1/TORTUOSITE!
+ _ecr_c = _lst[1:len(_lst):5]
+ _ecr_f = _lst[2:len(_lst):5]
+ _ecr_p = _lst[3:len(_lst):5]
+ _ecr_t = _lst[4:len(_lst):5]
+ _ecr_cc = _lst[5:len(_lst):5]
except:
UTMESS('F','ECREVISSE0_18')
- _ecr_c = [-1]
- _ecr_f = [-1]
- _ecr_p = [-1]
- _ecr_t = [-1]
+ _ecr_c = [-1]
+ _ecr_f = [-1]
+ _ecr_p = [-1]
+ _ecr_t = [-1]
_ecr_cc = [-1]
else:
- # Generation de la table resultat
- if debug1: print "Chargement donne par Ecrevisse"
- if debug1: print len(_ecr_c), len(_ecr_f), len(_ecr_p)
- if debug1:
- print '_ecr_c : min=', min(_ecr_c), ' / max=', max(_ecr_c), ' / ', _ecr_c
- print '_ecr_f : min=', min(_ecr_f), ' / max=', max(_ecr_f), ' / ', _ecr_f
- print '_ecr_p : min=', min(_ecr_p), ' / max=', max(_ecr_p), ' / ', _ecr_p
- print '_ecr_t : min=', min(_ecr_t), ' / max=', max(_ecr_t), ' / ', _ecr_t
- print '_ecr_cc : min=', min(_ecr_cc), ' / max=', max(_ecr_cc), ' / ', _ecr_cc
-
-
- # Formule permettant de redefinir les chargements par mailles
+ # On elimine les eventuels points en plus
+ # (cela arrive si la longueur de la fissure est plus grande de la derniere cotes)
+ # mais on considere quand meme la derniere cote du maillage aster
lx_ast = dFISSURE['LISTE_COTES_AH']
+ nbCotesEcre = len(lx_ast)
+ _ecr_c = _ecr_c[0:nbCotesEcre]
+ _ecr_f = _ecr_f[0:nbCotesEcre]
+ _ecr_p = _ecr_p[0:nbCotesEcre]
+ _ecr_t = _ecr_t[0:nbCotesEcre]
+ _ecr_cc = _ecr_cc[0:nbCotesEcre]
- # epsilon pour le decalage
- eps = 1.e-8
-
- lx = []
- ly = []
- ly2 = []
- ly3 = []
- ly4 = []
-
- lx.append( lx_ast[0] )
- ly.append( _ecr_f[0] )
- ly2.append( _ecr_p[0] )
- ly3.append( _ecr_t[0] )
- ly4.append( _ecr_cc[0] )
-
- for i in range(len(lx_ast)-2):
- x = lx_ast[i+1]
- lx.append( x - eps )
- lx.append( x + eps )
- ly.append( _ecr_f[i] )
- ly.append( _ecr_f[i+1] )
- ly2.append( _ecr_p[i] )
- ly2.append( _ecr_p[i+1] )
- ly3.append( _ecr_t[i] )
- ly3.append( _ecr_t[i+1] )
- ly4.append( _ecr_cc[i] )
- ly4.append( _ecr_cc[i+1] )
- #
- lx.append( lx_ast[-1] )
- ly.append( _ecr_f[-1] )
- ly2.append( _ecr_p[-1] )
- ly3.append( _ecr_t[-1] )
- ly4.append( _ecr_cc[-1] )
-
- _ecr_c = lx
- _ecr_f = ly
- _ecr_p = ly2
- _ecr_t = ly3
- _ecr_cc = ly4
-
-
- # Generation de la table resultat
- if debug1: print "Chargement par mailles pour Aster"
- if debug1: print len(_ecr_c), len(_ecr_f), len(_ecr_p)
- if debug1:
- print '_ecr_c : min=', min(_ecr_c), ' / max=', max(_ecr_c), ' / ', _ecr_c
- print '_ecr_f : min=', min(_ecr_f), ' / max=', max(_ecr_f), ' / ', _ecr_f
- print '_ecr_p : min=', min(_ecr_p), ' / max=', max(_ecr_p), ' / ', _ecr_p
- print '_ecr_t : min=', min(_ecr_t), ' / max=', max(_ecr_t), ' / ', _ecr_t
- print '_ecr_cc : min=', min(_ecr_cc), ' / max=', max(_ecr_cc), ' / ', _ecr_cc
-
- # Creation de la SD table (resultat de CALC_ECREVISSE)
- __TAB=CREA_TABLE(LISTE=(_F(LISTE_R=_ecr_c,
- PARA='COTES'),
- _F(LISTE_R=_ecr_f,
- PARA='FLUX'),
- _F(LISTE_R=_ecr_p,
- PARA='PRESSION'),
- _F(LISTE_R=_ecr_t,
- PARA='TEMP'),
- _F(LISTE_R=_ecr_cc,
- PARA='COEF_CONV'),
- ));
-
-
-# if debug: IMPR_TABLE(TABLE=__TAB, FORMAT='TABLEAU',);
-
-# ---------------------------------------------------------------------
- # RECUPERATION DU DEBIT DEPUIS ECREVISSE
+ # 2) DEBIT - 5 COLONNES (a partir de ECREVISSE 3.1.e)
+ # DEBIT TOTAL (kg/s), DEBIT AIR (kg/s), DEBIT VAPEUR (kg/s),
+ # DEBIT LIQUIDE (kg/s), TYPE ECOULEMENT
try:
- f_deb = open(os.path.join(tmp_ecrevisse, 'debits'),'r')
- _tex = f_deb.read()
- f_deb.close()
- # transforme le texte en liste
- _lis = _tex.split()
- # transforme la liste de textes en liste de float
- _lis = map( float, _lis )
-
- # 5 colonnes (a partir de ECREVISSE 3.1.e)
- # debit total (kg/s), debit d'air (kg/s), debit de vapeur (kg/s), debit de liquide (kg/s), type d'ecoulement
- _dtot = _lis[0:len(_lis):5]
- _dair = _lis[1:len(_lis):5]
- _dvap = _lis[2:len(_lis):5]
- _dliq = _lis[3:len(_lis):5]
- _ecou = _lis[4:len(_lis):5]
-
+ f_deb = open(os.path.join(tmp_ecrevisse, 'debits'),'r')
+ _tex = f_deb.read()
+ f_deb.close()
+ _lis = _tex.split()
+ _lis = map( float, _lis )
+
+ _dtot = _lis[0:len(_lis):5]
+ _dair = _lis[1:len(_lis):5]
+ _dvap = _lis[2:len(_lis):5]
+ _dliq = _lis[3:len(_lis):5]
+ _ecou = _lis[4:len(_lis):5]
except:
UTMESS('A','ECREVISSE0_18')
_ecou = [-1]
- # Formule permettant de redefinir les chargements par mailles
- ly_deb = LIST_INST
-
-
- # epsilon pour le decalage
- eps = 1.e-8
-
- ly = []
- ly1 = []
- ly2 = []
- ly3 = []
- ly4 = []
-
- ly.append( _dtot[0] )
- ly1.append( _dair[0] )
- ly2.append( _dvap[0] )
- ly3.append( _dliq[0] )
- ly4.append( _ecou[0] )
-
- for i in range(len(ly_deb)-2):
- ly.append( _dtot[i] )
- ly.append( _dtot[i+1] )
- ly1.append( _dair[i] )
- ly1.append( _dair[i+1] )
- ly2.append( _dvap[i] )
- ly2.append( _dvap[i+1] )
- ly3.append( _dliq[i] )
- ly3.append( _dliq[i+1] )
- ly4.append( _ecou[i] )
- ly4.append( _ecou[i+1] )
- #
- ly.append( _dtot[-1] )
- ly1.append( _dair[-1] )
- ly2.append( _dvap[-1] )
- ly3.append( _dliq[-1] )
- ly4.append( _ecou[-1] )
-
- _dtot = ly
- _dair = ly1
- _dvap = ly2
- _dliq = ly3
- _ecou = ly4
-
- # Creation de la SD table (resultat de CALC_ECREVISSE)
+
+# ---------------------------------------------------------------------
+# CREATION DES SD-TABLE DE RESULTATS
+
+ __TAB=CREA_TABLE(LISTE=(_F(LISTE_R=_ecr_c,
+ PARA='COTES'),
+ _F(LISTE_R=_ecr_f,
+ PARA='FLUX'),
+ _F(LISTE_R=_ecr_p,
+ PARA='PRESSION'),
+ _F(LISTE_R=_ecr_t,
+ PARA='TEMP'),
+ _F(LISTE_R=_ecr_cc,
+ PARA='COEF_CONV'),
+ ))
+
__DEB=CREA_TABLE(LISTE=(_F(LISTE_R=_dtot,
PARA='DEBTOT'),
_F(LISTE_R=_dair,
PARA='DEBLIQ'),
_F(LISTE_I=_ecou,
PARA='ECOULEMENT'),
- ));
+ ))
+
-# if debug: IMPR_TABLE(TABLE=__DEB, FORMAT='TABLEAU',);
# ---------------------------------------------------------------------
+# DEBUG
+ if debug :
+ print 'DEBUT DEBUG MACR_ECRE_CALC'
+ print 'Chargements donnes par Ecrevisse'
+ print 'cotes aster :', lx_ast
+ print '_ecr_c : min=', min(_ecr_c), ' / max=', max(_ecr_c), ' / ', _ecr_c
+ print '_ecr_f : min=', min(_ecr_f), ' / max=', max(_ecr_f), ' / ', _ecr_f
+ print '_ecr_p : min=', min(_ecr_p), ' / max=', max(_ecr_p), ' / ', _ecr_p
+ print '_ecr_t : min=', min(_ecr_t), ' / max=', max(_ecr_t), ' / ', _ecr_t
+ print '_ecr_cc : min=', min(_ecr_cc), ' / max=', max(_ecr_cc), ' / ', _ecr_cc
+ print '_dtot=', _dtot
+ print '_dair=', _dair
+ print '_dvap=', _dvap
+ print '_dliq=', _dliq
+ print '_ecou=', _ecou
+ print __DEB.EXTR_TABLE()
+ print __TAB.EXTR_TABLE()
+ print 'FIN DEBUG MACR_ECRE_CALC'
- # RECUPERATION DES RESULTATS OPTIONNELS DEPUIS ECREVISSE
-# A finir
+# ---------------------------------------------------------------------
+# RECUPERATION DES RESULTATS OPTIONNELS DEPUIS ECREVISSE
+# A finir
# lst_fic = os.listdir(tmp_ecrevisse)
-# ---------------------------------------------------------------------
- # FIN MACR_ECRE_CALC
+# ---------------------------------------------------------------------
+# FIN MACR_ECRE_CALC
return ier
-# ---------------------------------------------------------------------
+
+
+# ---------------------------------------------------------------------
def fichier_data_ecrevisse():
"""
-#@ MODIF macr_ecrevisse_ops Macro DATE 05/10/2009 AUTEUR ASSIRE A.ASSIRE
+#@ MODIF macr_ecrevisse_ops Macro DATE 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,
IMPRESSION,
CHAM_MATER,
CARA_ELEM,
+ CONTACT,
EXCIT_MECA,
EXCIT_THER,
COMP_INCR,
**args):
"""
Procedure de couplage Aster-Ecrevisse
- Execution pour tous les pas de temps des calculs thermiques, mécaniques puis hydraulique
+ Execution pour tous les pas de temps des calculs thermiques, mecaniques puis hydraulique
DecoupageGeneration par Aster du fichier de donnees d'Ecrevisse et lancement d'Ecrevisse
"""
import os, aster, copy
ier=0
- # Niveaux de debug
- debug1 = (INFO>1)
- debug2 = (INFO>2)
-
- #
- InfoAster = 1
#
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
+ # Parametres debug
+ debug = False
+
+ # Info
+ InfoAster = 1
+ info2 = (INFO==2)
+ if debug :
+ info2=True
+
# IMPORTATION DE COMMANDES ASTER
DEFI_LIST_REEL = self.get_cmd("DEFI_LIST_REEL")
THER_LINEAIRE = self.get_cmd("THER_LINEAIRE")
# Concepts sortant: les resultats de STAT_NON_LINE et de THER_LINEAIRE valides vis-a-vis du calcul ecrevisse
self.DeclareOut('RTHERM',TEMPER)
self.DeclareOut('MECANIC', self.sd)
-
+
IsPoursuite = False
IsInit = True
# Traitement de l'etat initial en cas de poursuite
IsPoursuite= True
else :
dEtatInit=None
-
- # Valeur par defaut du mot cle LOGICIEL
- if not LOGICIEL: LOGICIEL = os.path.join(aster.repout(), 'ecrevisse')
+
+ ## Valeur par defaut du mot cle LOGICIEL
+ #if not LOGICIEL: LOGICIEL = os.path.join(aster.repout(), 'ecrevisse')
# RECUPERATION DES MOTS-CLES FACTEURS
motclefsCALC_ECREVISSE = {}
motclefsCALC_ECREVISSE['COURBES'] = COURBES,
+
+
+
+
# -----------------------------------------------------------------------------------------------------
# Debut de la macro
# Si LIST_INST est un DEFI_LIST_REEL :
_liste_inst = LIST_INST.Valeurs()
- if ( debug1 ):
+ if (debug):
print 'liste des instants liste_inst = ', _liste_inst
# Drapeaux pour les 1ers calculs et les 1eres definitions
_nume_ordre = 0
else :
# Dans le cas d'une poursuite :
- # n reconstruit une nouvelle liste d'instant composee de l'ancienne liste jusqu'a l'instant recherche,
+ # n reconstruit une nouvelle liste d'instant composee de l'ancienne liste jusqu'a l'instant recherche,
# puis de la nouvelle a partir de cet instant
# ainsi le _nume_ordre de la nouvelle liste correspond au nume_ordre de l'ancienne
__dico1 = __THINIT.LIST_VARI_ACCES()
break
idx += 1
new_list = _list_precedente[0:_nume_ordre] # liste precedent jusqu'a l'instant a recalculer (inclu, ca permet de gerer le cas ou l'instant a recalculer n'est pas dans la nouvelle liste : il sera ajoute)
- new_list.extend( _liste_inst[_idx+1:] ) # on lui ajoute la nouvelle liste a partir du l'instant a recalculer
+ new_list.extend( _liste_inst[_idx+1:] ) # on lui ajoute la nouvelle liste a partir du l'instant a recalculer
_liste_inst = copy.copy(new_list)
-
- ########################################################################################
+
+ ########################################################################################
# Debut boucle sur la liste d'instant
########################################################################################
FinBoucle = False
while ( not FinBoucle ):
_inst = _liste_inst[_nume_ordre]
- if (debug1):
- print 'instant debut boucle', _inst
-
+ if ( debug ):
+ print 'Instant debut boucle', _inst
# On boucle jusqu'a convergence
NbIter = 0
while True:
- if ( (not IsPoursuite) or EcrevisseExe) :
+ if ( (not IsPoursuite) or EcrevisseExe) :
# Le temps que l'on traite
_inst_p_un = _liste_inst[_nume_ordre+1]
IsInitEcre= False
# Construction de la liste des pas
LES_PAS = DEFI_LIST_REEL( VALE=_liste_inst, )
- if ( debug1 ):
+ if (debug):
print '=====> ===== ===== ===== <===='
print 'Iteration numero : ', NbIter
print 'Instant : ', _inst
if ( EcrevisseExe ):
_dEXCIT_THER.append( _F(CHARGE=FLU1ECR0) )
_dEXCIT_THER.append( _F(CHARGE=FLU2ECR0) )
-
- # Definition de l'etat initial
+
+ # Definition de l'etat initial
motclefs = {}
if (_nume_ordre == 0) :
- # On verifie que temp_ref est bien renseigne dans AFFE_MATERIAU
+ # On verifie que temp_ref est bien renseigne dans AFFE_MATERIAU
try:
tref = CHAM_MATER['AFFE_VARC']['VALE_REF']
except:
UTMESS('F','ECREVISSE0_22',)
-
+
motclefs['ETAT_INIT']=[_F(VALE=tref, NUME_ORDRE=_nume_ordre)]
- if ( debug2 ):
+ if ( debug ):
print 'thermique initialise avec tref'
else:
if (IsInit) :
- motclefs['reuse']=__THINIT
+ motclefs['reuse']=__THINIT
motclefs['ETAT_INIT']=[_F(EVOL_THER=__THINIT, NUME_ORDRE=_nume_ordre)]
- if (debug2):
+ if (debug):
print 'thermique initialise avec etat_initial'
else :
motclefs['reuse']=RTHERM
motclefs['ETAT_INIT']=[_F(EVOL_THER=RTHERM, NUME_ORDRE=_nume_ordre)]
- if (debug2):
+ if (debug):
print 'thermique initialise avec instant precedent'
- if ( debug1 ):
+
+ if (debug):
print '====> THER_LINEAIRE <===='
- if ( debug2 ):
print ' Les charges thermiques'
print EXCIT_THER
#
ARCHIVAGE = _F(NUME_INIT=_nume_ordre+1,DETR_NUME_SUIV='OUI'),
INFO = InfoAster,
**motclefs )
-
+
RTHERMPJ=PROJ_CHAMP(RESULTAT=__THINIT, MODELE_1=MODELE_THER, MODELE_2=MODELE_MECA,
VIS_A_VIS=_F(TOUT_1='OUI', TOUT_2='OUI',),
INFO=2,
)
RTHERM=__THINIT
- else :
+ else :
RTHERM=THER_LINEAIRE(
MODELE = MODELE_THER,
CHAM_MATER = CHAM_MATER,
**motclefs
)
- # Projection du champ thermique, à tous les instants sinon pas de deformations thermiques
+ # Projection du champ thermique, a tous les instants sinon pas de deformations thermiques
RTHERMPJ=PROJ_CHAMP(RESULTAT=RTHERM, MODELE_1=MODELE_THER, MODELE_2=MODELE_MECA,
VIS_A_VIS=_F(TOUT_1='OUI', TOUT_2='OUI',),
INFO=2,
for j in dEXCIT_MECA_i.keys():
if dEXCIT_MECA_i[j]==None : del dEXCIT_MECA_i[j]
_dEXCIT_MECA.append(dEXCIT_MECA_i)
-
-
+
+
# Definition des chargements venant d'Ecrevisse
if ( EcrevisseExe ):
_dEXCIT_MECA.append( _F(CHARGE=MECAECR0) )
if (_nume_ordre != 0):
motclefs['reuse'] = MECANIC
motclefs['ETAT_INIT']=[_F(EVOL_NOLI=MECANIC, NUME_ORDRE=_nume_ordre)]
- if (debug2):
+ if (debug):
print 'etat meca initial = pas precedent'
else:
- if (debug2):
- print 'etat meca initial : vierge'
- else:
+ if (debug):
+ print 'etat meca initial : vierge'
+ else:
motclefs['reuse']=__EVINIT
motclefs['ETAT_INIT']=[_F(EVOL_NOLI=__EVINIT, NUME_ORDRE=_nume_ordre)]
- if (debug2):
+ if (debug):
print 'etat meca initial dReuseM', motclefs
-
-
- if ( debug1 ):
+
+ if (debug):
print '====> STAT_NON_LINE <===='
- if ( debug2 ):
+ if (debug):
print ' Les charges mecaniques'
print _dEXCIT_MECA
-
-
+
+
MECANIC=STAT_NON_LINE(
MODELE = MODELE_MECA,
CHAM_MATER = __MATMEC,
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,),
# Thermique projete
# Liste des pas
DETRUIRE( CONCEPT=(_F(NOM=RTHERMPJ),_F(NOM=LES_PAS),),INFO=1,ALARME='NON',)
-
+
else :
- # CAS OU LA MACRO EST REENTRANTE : ON RELANCE ECREVISSE POUR CONNAITRE
+ # CAS OU LA MACRO EST REENTRANTE : ON RELANCE ECREVISSE POUR CONNAITRE
# LES CHARGEMENT A UTILISER POUR LES PROBLEMES THERMIQUES ET MECANIQUES
_inst_p_un=_inst
IsInitEcre = True
-
+
# -----------------------------------------------------------------------
# ECREVISSE : ATTENTION SI REPRISE CALCUL, ON RECALCULE LE DERNIER INSTANT
# -------------------------------------------------------------------------
TABLECR1=CO('TABLECR1')
DEBIECR1=CO('DEBIECR1')
- if ( debug1 ):
+ if (debug):
print '====> ECREVISSE entree dans CALC_ECREVISSE <===='
-
- if (not IsPoursuite) :
-
+
+ if (not IsPoursuite) :
+
CALC_ECREVISSE(
CHARGE_MECA = MECAECR1,
CHARGE_THER1 = FLU1ECR1,
# assurer la coherence des donnees en fonction de FLUIDE_ENTREE = iflow (voir doc Ecrevisse)
# activation eventuelle de TITR_VA et P_AIR
- FISSURE=l_dFISSURE, # TODO a verifier
+ FISSURE=l_dFISSURE,
ECOULEMENT=_F( **dECOULEMENT_ecrevisse ),
MODELE_ECRE=_F( **dMODELE_ECRE),
# assurer la coherence des donnees en fonction de FLUIDE_ENTREE = iflow (voir doc Ecrevisse)
# activation eventuelle de TITR_VA et P_AIR
- FISSURE=l_dFISSURE, # TODO a verifier
+ FISSURE=l_dFISSURE,
ECOULEMENT=_F( **dECOULEMENT_ecrevisse ),
MODELE_ECRE=_F( **dMODELE_ECRE),
CONVERGENCE=_F( **dCONVERGENCE_ECREVISSE ),
**motclefsCALC_ECREVISSE
);
-
- if ( debug1 ):
+
+ if (debug):
print '====> ECREVISSE sortie de CALC_ECREVISSE <===='
# Recuperation des infos de la table resultat Ecrevisse
T_TABL_TMP1 = TABLECR1.EXTR_TABLE()
T_DEB_TMP1 = DEBIECR1.EXTR_TABLE()
-# # Ajout de deux colonnes supplementaires
+# # On ajoute deux colonnes supplementaires
# _nb_ligne = len(T_DEB_TMP1["DEBTOT"])
# T_DEB_TMP1["NUME_ORDRE"] = [_nume_ordre+1]*_nb_ligne
# T_DEB_TMP1["INST"] = [_inst_p_un]*_nb_ligne
-
+
# Le calcul Ecrevisse c'est bien passe ?
EcrevisseExe = ( T_TABL_TMP1.values()['COTES'][0] != -1 )
#
# TABLECR0 table Ecrevisse a _inst
# TABLECR1 table Ecrevisse a _inst_p_un
# --------------------
-
+
if ( not IsInit ):
# On recupere la liste des temperatures a t et t+1
lst_T_0 = T_TABL_TMP0.values()['TEMP']
Erreur = ErreurP
else:
Erreur = ErreurG
- #
- print 'CONVERGENCE_MACR_ECREVISSE. Instant de calcul : %.3f .' % (_inst_p_un)
- print ' Erreur en Temperature : %f . Ecart en Temperature : %.3f' % (ErreurT,max_T_diff_01)
- print ' Erreur en Pression : %f . Ecart en Pression : %.3f' % (ErreurP,max_P_diff_01)
- print ' Erreur Temp-Press : %f' % (ErreurG)
+
if ( MacrCritere != 'EXPLICITE' ):
Convergence = ( Erreur <= MacrPrecisCritere )
- print 'CONVERGENCE_MACR_ECREVISSE . Nature du Critere %s . Valeur du critere %s . Convergence %s ' % (MacrCritere,MacrPrecisCritere,Convergence,)
+ #
+ if info2 :
+ # Info Critere
+ UTMESS('I', 'ECREVISSE0_35', valr=[_inst_p_un], valk=[MacrCritere,MacrPrecisCritere,Convergence])
+ # Info Convergence
+ UTMESS('I', 'ECREVISSE0_34', valr=[_inst_p_un,ErreurT,max_T_diff_01,ErreurP,max_P_diff_01,ErreurG])
else:
Convergence = True
- print 'CONVERGENCE_MACR_ECREVISSE. 1er Instant de calcul : %f . Pas de calcul de critere.' % (_inst_p_un)
+ if info2 :
+ UTMESS('I', 'ECREVISSE0_36', valr=[_inst_p_un])
# --------------------
-
#
+
if ( MacrCritere == 'EXPLICITE' ):
Convergence = True
else:
T_TABL_TMP1["NUME_ORDRE"] = [_nume_ordre+1]*nb_lignes_t1
T_TABL_TMP1["INST"] = [_inst_p_un]*nb_lignes_t1
- # POUR LA TABLE DES DEBITS
+ # POUR LA TABLE DES DEBITS
nb_ligne_t2 = len(T_DEB_TMP1["DEBTOT"])
T_DEB_TMP1["NUME_ORDRE"] = [_nume_ordre+1]*nb_ligne_t2
T_DEB_TMP1["INST"] = [_inst_p_un]*nb_ligne_t2
T_TABL_TMP0 = T_TABL_TMP1
if (not IsInitEcre) :
IsInit = False
- if ( debug1 ):
- print 'Convergence atteinte, on passe au pas de temps suivant'
+ if (info2):
+ UTMESS('I','ECREVISSE0_37', valr=[_inst_p_un])
break
-
+
else:
NbIter += 1
# A t'on le droit de decouper, par rapport au nombre de division
UTMESS('A','ECREVISSE0_31', valr=[_inst,_inst_p_un,tmp,MacrPasMini])
break
#
- if ( debug1 ):
+ if ( info2 ):
UTMESS('A','ECREVISSE0_32', valr=[_inst,_inst_p_un,tmp],vali=[NbIter])
# on insere le nouveau temps dans la liste des instants avant "_inst_p_un"
_liste_inst.insert(_nume_ordre+1,tmp)
),
INFO=1,ALARME='NON',
)
-
+
if (_nume_ordre != 0 ):
DETRUIRE(
CONCEPT=( _F(NOM=MECAECR0),
-#@ MODIF macr_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
# ======================================================================
# 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,
from Accas import _F
from Macro import fiabilite_mefisto
import aster
- import os
- import string
- import sys
- import Numeric
+ import numpy
#
#____________________________________________________________________
#
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.
#____________________________________________________________________
#
#
- 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é
-#@ 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
# ======================================================================
########################################################################
# script PYTHON de creation du résultat local
+########################################################################
+
+########################################################################
+# verification que les points de la ligne de coupe sont dans la matiere
+def crea_grp_matiere(self,groupe,newgrp,iocc,m,__remodr,NOM_CHAM,LIGN_COUPE,__macou):
+
+ import aster
+ import os,string,types
+ from Accas import _F
+ from Noyau.N_utils import AsType
+ from Utilitai.Utmess import UTMESS
+ import os
+ POST_RELEVE_T = self.get_cmd('POST_RELEVE_T')
+ DEFI_GROUP = self.get_cmd('DEFI_GROUP')
+
+ motscles={}
+ if m['NOM_CMP']!=None:
+ motscles['NOM_CMP']=m['NOM_CMP']
+ else:
+ motscles['TOUT_CMP']='OUI'
+ motscles['OPERATION']='EXTRACTION'
+
+ __tab=POST_RELEVE_T(ACTION=_F( INTITULE=newgrp,
+ RESULTAT = __remodr,
+ NOM_CHAM=NOM_CHAM,
+ GROUP_NO = groupe,**motscles ))
+
+ # dictb=table initiale (contenant éventuellement des noeuds hors matière)
+ dictb=__tab.EXTR_TABLE()
+ # listenoe_b=liste ordonnee des noeuds de la ligne de coupe (avec doublons)
+ listenoe_b = dictb.NOEUD.values()
+ # lno_b2=liste des noeuds de la ligne de coupe après élimination des doublons
+ # (attention, on perd l'ordre des noeuds)
+ lno_b2 = set(listenoe_b)
+
+ # dictc=table (extraite de dictb) contenant uniquement des noeuds dans la matière
+ if m['NOM_CMP']!=None:
+ dictc=getattr(dictb,m['NOM_CMP'][0]).NON_VIDE()
+ lno_c2 = set(dictc.NOEUD.values())
+ else:# TOUT_CMP='OUI'
+ # on garde uniquement les composantes pour conserver les noeuds où il y a des valeurs
+ a_suppr = set(['INTITULE', 'RESU', 'NOM_CHAM', 'NUME_ORDRE', 'INST', 'ABSC_CURV', 'COOR_X', 'COOR_Y', 'COOR_Z'])
+ new_para = set(dictb.para)
+ new_para.difference_update(a_suppr)
+
+ lno_c2 = set()
+ for comp in new_para.difference(['NOEUD']):
+ dictc = getattr(dictb, comp).NON_VIDE()
+ lno_c2.update(dictc.NOEUD.values())
+
+ # on réordonne la liste des noeuds de lno_c2 (selon leur position dans listenoe_b) => l_matiere
+ # l_horsmat=liste des noeuds hors matière
+ l_matiere = [j for j in listenoe_b if j in lno_c2]
+ nderm=l_matiere.index(l_matiere[len(l_matiere)-1])
+ l_horsmat = [j for j in listenoe_b if j not in lno_c2]
+
+ # si on est en présence de noeuds hors matière,
+ # on emet une alarme pour informer l'utilisateur
+ nbpoin=m['NB_POINTS']
+ reste=nbpoin-len(l_matiere)
+ if len(l_horsmat) > 0:
+
+ nderh=l_horsmat.index(l_horsmat[len(l_horsmat)-1])
+ cnom = list(__macou.NOMNOE.get())
+ l_coor = __macou.COORDO.VALE.get()
+ indent=os.linesep+' '*12
+ l_surlig = []
+ l_horslig = []
+ for j in l_matiere[:nderm+1]:
+ nuno=cnom.index(j.ljust(8))
+ text_coordo = '(%f, %f, %f)' % tuple(l_coor[3*nuno:3*nuno+3])
+ l_surlig.append(text_coordo)
+ for j in l_horsmat[:nderh+1]:
+ nuno=cnom.index(j.ljust(8))
+ text_coordo = '(%f, %f, %f)' % tuple(l_coor[3*nuno:3*nuno+3])
+ l_horslig.append(text_coordo)
+ UTMESS('A','POST0_8',valk=[indent.join(l_surlig),indent.join(l_horslig)])
+
+ elif reste > 0:
+
+ cnom = list(__macou.NOMNOE.get())
+ l_coor = __macou.COORDO.VALE.get()
+ indent=os.linesep+' '*12
+ l_surlig = []
+ for j in l_matiere[:nderm+1]:
+ nuno=cnom.index(j.ljust(8))
+ text_coordo = '(%f, %f, %f)' % tuple(l_coor[3*nuno:3*nuno+3])
+ l_surlig.append(text_coordo)
+ UTMESS('A','POST0_24',vali=[iocc,reste],valk=[indent.join(l_surlig)])
+
+ __macou=DEFI_GROUP( reuse =__macou , MAILLAGE=__macou ,
+ CREA_GROUP_NO=_F(NOM=newgrp,NOEUD=l_matiere[:nderm+1]),)
+
+ return
def crea_resu_local(self,dime,NOM_CHAM,m,resin,mail,nomgrma):
return dist
########################################################################
-# verification que les points de la ligne de coupe sont dans la matiere
-def crea_grp_matiere(self,groupe,newgrp,m,__remodr,NOM_CHAM,__macou):
-
- import aster
- from Accas import _F
- from Utilitai.Utmess import UTMESS
- import os
- 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):
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'
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')
if AsType(RESULTAT).__name__ in ('evol_elas','evol_noli') :
if NOM_CHAM in ('DEPL','SIEF_ELNO_ELGA','SIGM_NOEU_DEPL','SIGM_NOEU_SIEF','SIGM_NOEU_ELGA','SIGM_NOEU_COQU','SIGM_ELNO_DEPL'):icham=1
-
+ iocc=0
for m in LIGN_COUPE :
+ iocc=iocc+1
motscles={}
motscles['OPERATION']=m['OPERATION']
if m['NOM_CMP']!=None:
groupe='LICOU'+str(ioc2)
nomgrma=' '
newgrp='LICOF'+str(ioc2)
- crea_grp_matiere(self,groupe,newgrp,m,__remodr,NOM_CHAM,__macou)
+ crea_grp_matiere(self,groupe,newgrp,iocc,m,__remodr,NOM_CHAM,LIGN_COUPE,__macou)
groupe=newgrp
# on definit l'intitulé
elif AsType(RESULTAT).__name__ in ('evol_ther',) :
-
+ iocc=0
for m in LIGN_COUPE :
+ iocc=iocc+1
motscles={}
motscles['OPERATION']=m['OPERATION']
if m['NOM_CMP']!=None:
ioc2=ioc2+1
groupe='LICOU'+str(ioc2)
newgrp='LICOF'+str(ioc2)
- crea_grp_matiere(self,groupe,newgrp,m,__remodr,NOM_CHAM,__macou)
+ crea_grp_matiere(self,groupe,newgrp,iocc,m,__remodr,NOM_CHAM,LIGN_COUPE,__macou)
groupe=newgrp
if m['INTITULE'] !=None : intitl=m['INTITULE']
else : intitl='l.coupe'+str(ioc2)
self.DeclareOut('nomres',self.sd)
dictab=__tabitm.EXTR_TABLE()
-
### Ajout de la colonne theta
if len(arcgma)>0:
coltab=[]
-#@ 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
# ======================================================================
# ======================================================================
# 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):
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()
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'.
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
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
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 ) )
#_____________________________________________
# 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)
#_____________________________________________
# 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
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
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<ITER_MAXI)):
+ while(iter<ITER_MAXI):
iter = iter +1
- new_val, s, l, Act = reca_algo.Levenberg_bornes(val,Dim,val_init,borne_inf,borne_sup,A,erreur,l,UNITE_RESU)
+ new_val, s, l, Act = reca_algo.Levenberg_bornes(val, Dim, val_init, borne_inf, borne_sup, A, erreur, l, UNITE_RESU)
+
+ # On teste la variation sur les parametres
+ ecart_para = reca_algo.calcul_norme2( NP.array(new_val) - NP.array(val) )
+ if debug: print "AA0/ecart para=%s\nAA0/oldpara/newpara=%s %s" % (ecart_para, val, new_val)
+ if ecart_para < TOLE_PARA:
+ UTMESS('I','RECAL0_51', valr=ecart_para, cc=Mess.get_filename())
+ break
- # Calcul de F, ici L_deriv_sensible ne contient que les termes calculés par la sensibilité, les autres termes sont nuls
- L_F, L_deriv_sensible = CALCUL_ASTER.calcul_Aster(new_val, INFO)
+ # Calculs au point courant val et toutes les perturbations par differences finies (N+1 calculs distribues ou inclus)
+ CALCUL_ASTER.calcul_FG(new_val)
+
+ # Calcul de l'erreur et de la matrice des sensibilites
+ old_J = copy.copy(J)
+ E.CalcError(CALCUL_ASTER.Lcalc)
+ new_J = E.J
- new_L_J,new_erreur = Simul.multi_interpole(L_F, RESU_CALC)
- new_J = Simul.norme_J(L_J_init,new_L_J,UNITE_RESU)
l = reca_algo.actualise_lambda(l,Dim.adim(val),Dim.adim(new_val),A,erreur,new_J,J)
+ E.CalcSensibilityMatrix(CALCUL_ASTER.Lcalc, new_val, dX=None, pas=PARA_DIFF_FINI)
+
+ L_F = CALCUL_ASTER.Lcalc[0]
+ A = E.A_nodim
+ val = copy.copy(new_val)
+ erreur = copy.copy(E.erreur)
+ J = E.J
- val = copy.copy(new_val)
- erreur = copy.copy(new_erreur)
- J = new_J
+ if debug:
+ print "AA0/L_F=", L_F
+ print "AA0/l=", l
+ print "AA0/erreur=", erreur
+ print "AA0/J=", J
+ print "AA0/A_nodim=", A
# Calcul de la matrice des sensibilites
- A = Simul.sensibilite(CALCUL_ASTER, L_F, L_deriv_sensible, val, PARA_DIFF_FINI)
A = Dim.adim_sensi(A)
# Calcul du residu
residu = reca_algo.test_convergence(gradient_init,erreur,A,s)
+ if debug:
+ print "AA0/residu=", residu
+ print "AA0/new_val=", new_val
+ print "AA0/A=", A
+
+ # On calcule la variation sur la fonctionnelle
+ ecart_fonc = abs( new_J - old_J )
+
# Affichage iteration
- Mess.affiche_result_iter(iter,J,val,residu,Act)
- if INFO>=1: UTMESS('I','RECAL0_16',vali=iter, valr=(J, residu))
+ Mess.affiche_result_iter(iter,J,val,residu,Act, ecart_para, ecart_fonc)
+
+ # On teste la variation sur la fonctionnelle
+ if ecart_fonc < TOLE_FONC:
+ UTMESS('I','RECAL0_52', valr=ecart_fonc, cc=Mess.get_filename())
+ break
if (GRAPHIQUE):
- if GRAPHIQUE['AFFICHAGE']=='TOUTE_ITERATION':
- GRAPHE_UL_OUT=GRAPHIQUE['UNITE']
- pilote=GRAPHIQUE['PILOTE']
- reca_utilitaires.graphique(GRAPHIQUE['FORMAT'],L_F,RESU_EXP,RESU_CALC,iter,GRAPHE_UL_OUT,pilote)
+ if GRAPHIQUE['AFFICHAGE']=='TOUTE_ITERATION':
+ GRAPHE_UL_OUT=GRAPHIQUE['UNITE']
+ pilote=GRAPHIQUE['PILOTE']
+ reca_utilitaires.graphique(GRAPHIQUE['FORMAT'], L_F, RESU_EXP, RESU_CALC, iter, GRAPHE_UL_OUT, pilote)
+
+ # On teste le residu
+ if residu <= RESI_GLOB_RELA:
+ UTMESS('I','RECAL0_50', valr=residu, cc=Mess.get_filename())
+ break
# On teste un manque de temps CPU
- restant,temps_iter,err=reca_utilitaires.temps_CPU(restant,temps_iter)
+ restant, temps_iter, err = reca_utilitaires.temps_CPU(restant, temps_iter)
if (err==1):
- ier=ier+1
- return ier
-
+ UTMESS('I','RECAL0_53', cc=Mess.get_filename())
+ break
#_____________________________________________
#
# CONVERGENCE OU ECHEC
#_____________________________________________
iter_fonc = CALCUL_ASTER.evaluation_fonction
- Mess.affiche_etat_final_convergence(iter,ITER_MAXI,iter_fonc,ITER_FONC_MAXI, RESI_GLOB_RELA,residu,Act)
- reca_algo.calcul_etat_final(para,A,iter,ITER_MAXI,RESI_GLOB_RELA,residu,Mess)
+ Mess.affiche_etat_final_convergence(iter, ITER_MAXI, iter_fonc, ITER_FONC_MAXI, RESI_GLOB_RELA, residu, Act)
+ reca_algo.calcul_etat_final(para, A, iter, ITER_MAXI, RESI_GLOB_RELA, residu, Mess)
#-------------------------------------------------------------------------------
#
# FIN DES ITERATIONS POUR TOUS LES ALGOS
#_____________________________________________
-
+
if (GRAPHIQUE):
- trace = False
fichier = None
# Pour les algorithmes d'optimize.py, on ne peut tracer qu'a la derniere iteration
- if (GRAPHIQUE['AFFICHAGE']=='ITERATION_FINALE') or (METHODE in ['FMIN', 'FMINBFGS', 'FMINNCG']):
- trace = True
- if (METHODE=='EXTERNE' and GRAPHIQUE['AFFICHAGE']=='TOUTE_ITERATION'):
- trace = True
- if not args.has_key('prefix_graph'): fichier='graph'
- else: fichier = args['prefix_graph']
- if trace:
- if INFO>=1: UTMESS('I','RECAL0_17')
- GRAPHE_UL_OUT=GRAPHIQUE['UNITE']
- pilote=GRAPHIQUE['PILOTE']
+ if (GRAPHIQUE['AFFICHAGE']=='ITERATION_FINALE') or (METHODE in ['FMIN', 'FMINBFGS', 'FMINNCG']) or (ITER_MAXI<=0):
+ UTMESS('I','RECAL0_17')
+ GRAPHE_UL_OUT = GRAPHIQUE['UNITE']
+ pilote = GRAPHIQUE['PILOTE']
reca_utilitaires.graphique(GRAPHIQUE['FORMAT'],L_F,RESU_EXP,RESU_CALC,iter,GRAPHE_UL_OUT,pilote,fichier)
- if( METHODE == 'EXTERNE'):
-# if mode_python: return fonctionnelle, gradient
- return fonctionnelle, gradient
-
# Si pas de convergence alors diagnostic NOOK_TEST_RESU
- if residu > RESI_GLOB_RELA:
+ if (residu > RESI_GLOB_RELA) and (ecart_fonc > TOLE_FONC) and (ecart_para < TOLE_PARA):
from Cata.cata import CREA_TABLE, TEST_TABLE
_tmp = []
_tmp.append( { 'PARA': 'ITER_MAXI', 'LISTE_R': 0.0, } )
- motscle= {'LISTE': _tmp }
+ motscle = {'LISTE': _tmp }
+
+ TBL = CREA_TABLE(**motscle);
- TBL=CREA_TABLE(**motscle);
-
TEST_TABLE(TABLE=TBL,
TYPE_TEST='SOMM',
NOM_PARA='ITER_MAXI',
# LES VALEURS DES PARAMETRES A CONVERGENCE
#_____________________________________________
-
nomres = Sortie(LIST_NOM_PARA, LIST_PARA, val, CALCUL_ASTER, Mess)
return
-
-
-
-
-
-
-
-
-
-
-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 __name__ == '__main__':
-
- mode_python = True
-
- from optparse import OptionParser, OptionGroup
- # récupère "bibpyt" à partir de "bibpyt/Macro/macr_recal_ops.py"
- sys.path.append(get_absolute_path(os.path.join(sys.argv[0], '..', '..')))
- from Utilitai.Utmess import UTMESS
-
- p = OptionParser(usage='usage: %s fichier_export [options]' % sys.argv[0])
- p.add_option('-i', '--input', action='store', dest='input', type='string', default='input.txt', help='fichier contenant les parametres')
- p.add_option('-o', '--output', action='store', dest='output', type='string', default='output.txt', help='fichier contenant la fonctionnelle')
- p.add_option('-g', '--output_grad', action='store', dest='output_grad', type='string', default='grad.txt', help='fichier contenant le gradient')
- p.add_option('-p', '--prefix_graph', action='store', dest='prefix_graph', type='string', default='graph', help='prefixe des fichiers contenant les courbes')
- p.add_option('-v', '--info', action='store', dest='INFO', type='int', help='niveau de message (-1, 0, 1, 2)')
- p.add_option('-f', '--follow', action='store', dest='follow_output', type='string', help="affiche ou non l'output du fichier Aster (True/False)")
- p.add_option('-F', '--objective', action='store', dest='objective', type='string', help="type de la fonctionnelle (float/vector)")
- p.add_option('-G', '--gradient', action='store', dest='gradient' , type='string', default='no', help="calcul du gradient par Aster (no/normal/adim)")
- p.add_option('-d', '--display', action='store', dest='display' , type='string', help="renvoi du DISPLAY (pour que la creation des courbes soit moins genante)")
-
-# p.add_option('-n', '--name', action='store', dest='name', type='string', default='optim', help="prefixe du fichier de bilan")
-
- opts, args = p.parse_args()
-
- # renvoi du DISPLAY (pour que la creation des courbes soit moins genante)
- if opts.display: os.environ['DISPLAY'] = opts.display
-
-
- # Options par defaut
- optparse_input = optparse_output = optparse_output_grad = optparse_prefix_graph = optparse_INFO = optparse_follow_output = optparse_objective = optparse_gradient = optparse_name = None
-
- if opts.INFO==None: opts.INFO=0
-
- if opts.input: optparse_input = True
- if opts.output: optparse_output = True
- if opts.output_grad: optparse_output_grad = True
- if opts.prefix_graph: optparse_prefix_graph = True
- if opts.INFO in [-1, 0, 1, 2]: optparse_INFO = True
- if opts.follow_output in ['True', 'False']: optparse_follow_output = True
- if opts.objective in ['float', 'vector']: optparse_objective = True
- if opts.gradient in ['no', 'normal', 'adim']: optparse_gradient = True
-# if opts.name: optparse_name = True
-
- if opts.follow_output=='True': opts.follow_output=True
- if opts.follow_output=='False': opts.follow_output=False
-
-
- # Fichier .export
- if args:
- fichier_export = args[0]
- if not os.path.isfile(fichier_export): fichier_export = None
-
- INFO = opts.INFO
- input_file = opts.input
- output_file = opts.output
- output_grad = opts.output_grad
- type_fonctionnelle = opts.objective
-
- # 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'))
- try:
- from as_profil import ASTER_PROFIL
- except:
- UTMESS('F','RECAL0_99')
-
- # Efface les fichiers resultats
- try: os.remove(output)
- except: pass
- try: os.remove(output_grad)
- except: pass
-
-
- # Si le fichier export n'est pas en argument on prend l'export qui est dans le rep courant
- if not fichier_export:
- # Lecture du fichier .export
- list_export = glob('*.export')
- if len(list_export) != 1:
- UTMESS('F','RECAL0_98')
- else:
- fichier_export = list_export[0]
- prof = ASTER_PROFIL(fichier_export)
-
- # Execution du fichier .comm
- nom_comm = None
- # fichier/répertoire
- for lab in ('data', 'resu'):
- l_fr = getattr(prof, lab)
- l_tmp = l_fr[:]
-
- for dico in l_tmp:
- # fichiers
- if not dico['isrep']:
- # Ancien .comm a executer
- if dico['type'] == 'comm' and dico['ul'] == '1':
- nom_comm = dico['path']
-
- # parametres
- for lab in ('param',):
- l_fr = getattr(prof, lab)
-# print l_fr
-# print l_fr['version']
- try: os.environ['ASTER_VERSION'] = l_fr['version'][0]
- except: pass
-
-
- if not nom_comm:
- UTMESS('F','RECAL0_97')
- if not os.path.isfile(nom_comm):
- UTMESS('F','RECAL0_96', valk=nom_comm)
-
-
-
- # -------------------------------------------------------------------
- # Lecture des valeurs d'entree
- if INFO==2: UTMESS('I','RECAL0_95',valk=input_file)
- try:
- f = open(input_file, 'r')
- txt = f.read()
- f.close()
- txt = txt.replace(',', ' ')
- val_externe = [ float(x) for x in txt.strip().split() ]
- except:
- UTMESS('F','RECAL0_94',valk=input_file)
- if INFO>=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
-
-
-#@ 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
# Le concept sortant (de type mult_elas ou fourier_elas) est nommé
# 'nomres' dans le contexte de la macro
-
+
self.DeclareOut('nomres',self.sd)
ielas = 0
if ielas==1 :
motscles={}
if CHAR_MECA_GLOBAL: motscles['CHARGE'] =CHAR_MECA_GLOBAL
- elif CHAR_CINE_GLOBAL: motscles['CHARGE'] =CHAR_CINE_GLOBAL
if CHAM_MATER : motscles['CHAM_MATER']=CHAM_MATER
if CARA_ELEM : motscles['CARA_ELEM'] =CARA_ELEM
__nomrig=CALC_MATR_ELEM(OPTION='RIGI_MECA',MODELE=MODELE,**motscles)
-
+
if lnume:
# On peut passer des mots cles egaux a None. Ils sont ignores
motscles={}
# boucle sur les items de CAS_CHARGE
nomchn=[]
+ lcharg=[]
iocc=0
for m in CAS_CHARGE:
iocc=iocc+1
+ # calcul de lcharg : liste des listes de char_meca (mots clé CHAR_MECA et CHAR_MECA_GLOBAL)
+ xx1=m['CHAR_MECA']
+ if type(xx1) != type((1,)) : xx1=(xx1,)
+ xx2=CHAR_MECA_GLOBAL
+ if type(xx2) != type((1,)) : xx2=(xx2,)
+ lchar1=[]
+ for chargt in (xx1+xx2) :
+ if chargt : lchar1.append(chargt)
+ lcharg.append(lchar1)
+ 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']
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 :
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:
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
#####################################################################
-#@ 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
# ======================================================================
# ======================================================================
-# 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,
# 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
# 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']})
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']})
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
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,
),
# 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);
# 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:
-#@ 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
# ======================================================================
if CHARGE != None:
if option[0:9] not in ('MASS_THER','RIGI_GEOM'):
motscles['CHARGE'] =CHARGE
- if CHAM_MATER != None: motscles['CHAM_MATER'] =CHAM_MATER
+ if CHAM_MATER != None and option != 'RIGI_GEOM' : motscles['CHAM_MATER'] =CHAM_MATER
if CARA_ELEM != None: motscles['CARA_ELEM'] =CARA_ELEM
if INST != None: motscles['INST'] =INST
self.DeclareOut('mm',m['MATRICE'])
motscles={'OPTION':option}
- if CHAR_CINE != None:
+ if CHAR_CINE != None:
mm=ASSE_MATRICE(MATR_ELEM=_a,NUME_DDL=num,CHAR_CINE=CHAR_CINE)
else:
mm=ASSE_MATRICE(MATR_ELEM=_a,NUME_DDL=num)
-#@ MODIF 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
# ======================================================================
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
MODUL2='MISS_PTAS'
elif OPTION['MODULE']=='PRE_MISS':
MODUL2='GTASTER'
+
ETUDE = PROJET
BASE = REPERTOIRE
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',
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])
pndio,
dpara['DIRE_ONDE'],
),
- )
+ INFO=1,)
return ier
-#@ 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
# ======================================================================
MODI_REPERE = None,
NOM_CHAM = None,
FILTRE = None,
+ EPSI_MOYENNE = None,
**args):
"""
# 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,
**mcfact
);
- else :
- __proj = RESULTAT
+ modele = MODELE_2
+ else:
+ modele = MODELE_1
#***********************************************
# )
- # 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
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]})
__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]})
'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:
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
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 <peau> (facettes)
"""
- import Numeric
PROJ_CHAMP = self.get_cmd('PROJ_CHAMP')
CREA_CHAMP = self.get_cmd('CREA_CHAMP')
CREA_RESU = self.get_cmd('CREA_RESU')
return __norm5
-
#**********************************************************************
# Calcul des angles nautiques pour le repere local associe a la normale
#**********************************************************************
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])
# (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
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'
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']]
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):
"""
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]
# 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
--- /dev/null
+#@ 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
+
-#@ 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
# ======================================================================
# ======================================================================
import random
-import Numeric
from types import ListType, TupleType
from math import pi,sqrt,log,exp
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
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
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]))
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]))
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
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)
--- /dev/null
+#@ 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
+
-#@ 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
# ======================================================================
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]
# 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]:
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
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' :
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)]
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
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
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)]
# ---------- 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)])
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
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 abss<rmprec :
NBTRLS = NBTRLS +1
Tmpsup.append(dicoS[Lnf1[i]][k])
if dicoI[Lnf1[i]][k] !='':
itoti = itoti +1
Ninf = dicoI[Lnf1[i]][k]
- Pinf = array([d_coor[Ninf][0],d_coor[Ninf][1],d_coor[Ninf][2]])
- absi = sqrt(dot(transpose(Pfon-Pinf),Pfon-Pinf))
+ Pinf = NP.array([d_coor[Ninf][0],d_coor[Ninf][1],d_coor[Ninf][2]])
+ absi = NP.sqrt(NP.dot(NP.transpose(Pfon-Pinf),Pfon-Pinf))
# On verifie que les noeuds sont en vis a vis
if abss<rmprec :
- dist = sqrt(dot(transpose(Psup-Pinf),Psup-Pinf))
+ dist = NP.sqrt(NP.dot(NP.transpose(Psup-Pinf),Psup-Pinf))
if dist>precn :
UTMESS('A','RUPTURE0_21',valk=Lnf1[i])
else :
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',
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
tabsup=TlibS[ino].EXTR_TABLE()
DETRUIRE(CONCEPT=_F(NOM=TlibS[ino]),INFO=1)
elif RESULTAT :
- __TSUP=POST_RELEVE_T(ACTION=_F(INTITULE='Deplacement SUP',
- NOEUD=Lnosup[ino],
- RESULTAT=RESULTAT,
- NOM_CHAM='DEPL',
- TOUT_ORDRE='OUI',
- NOM_CMP=('DX','DY','DZ',),
- OPERATION='EXTRACTION',),);
+ if MODELISATION=='AXIS' or MODELISATION=='C_PLAN' or MODELISATION=='D_PLAN':
+ __TSUP=POST_RELEVE_T(ACTION=_F(INTITULE='Deplacement SUP',
+ NOEUD=Lnosup[ino],
+ RESULTAT=RESULTAT,
+ NOM_CHAM='DEPL',
+ TOUT_ORDRE='OUI',
+ NOM_CMP=('DX','DY',),
+ OPERATION='EXTRACTION',),);
+ else :
+ __TSUP=POST_RELEVE_T(ACTION=_F(INTITULE='Deplacement SUP',
+ NOEUD=Lnosup[ino],
+ RESULTAT=RESULTAT,
+ NOM_CHAM='DEPL',
+ TOUT_ORDRE='OUI',
+ NOM_CMP=('DX','DY','DZ',),
+ OPERATION='EXTRACTION',),);
tabsup=__TSUP.EXTR_TABLE()
DETRUIRE(CONCEPT=_F(NOM=__TSUP),INFO=1)
else :
tabinf=TlibI[ino].EXTR_TABLE()
DETRUIRE(CONCEPT=_F(NOM=TlibI[ino]),INFO=1)
elif RESULTAT :
- __TINF=POST_RELEVE_T(ACTION=_F(INTITULE='Deplacement INF',
- NOEUD=Lnoinf[ino],
- RESULTAT=RESULTAT,
- NOM_CHAM='DEPL',
- TOUT_ORDRE='OUI',
- NOM_CMP=('DX','DY','DZ',),
- OPERATION='EXTRACTION',),);
+ if MODELISATION=='AXIS' or MODELISATION=='C_PLAN' or MODELISATION=='D_PLAN':
+ __TINF=POST_RELEVE_T(ACTION=_F(INTITULE='Deplacement INF',
+ NOEUD=Lnoinf[ino],
+ RESULTAT=RESULTAT,
+ NOM_CHAM='DEPL',
+ TOUT_ORDRE='OUI',
+ NOM_CMP=('DX','DY'),
+ OPERATION='EXTRACTION',),);
+ else :
+ __TINF=POST_RELEVE_T(ACTION=_F(INTITULE='Deplacement INF',
+ NOEUD=Lnoinf[ino],
+ RESULTAT=RESULTAT,
+ NOM_CHAM='DEPL',
+ TOUT_ORDRE='OUI',
+ NOM_CMP=('DX','DY','DZ',),
+ OPERATION='EXTRACTION',),);
tabinf=__TINF.EXTR_TABLE()
DETRUIRE(CONCEPT=_F(NOM=__TINF),INFO=1)
else :
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 :
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) :
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 :
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
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=[]
# ------------------------------------------------------------------
# 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 ---
# ------------------------------------------------------------------
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() ))
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() ))
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] ))
# ------------------------------------------------------------------
# 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
-#@ 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
# ======================================================================
# 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) :
"""
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):
"""
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
# 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' )
# 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'
#
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
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
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)) :
#------------------------------------------------------------------
# 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 )
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
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__()
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)
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 = []
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"
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')
-#@ 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
# ======================================================================
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
-#@ 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
# 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
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]
# ------------------------------------------------------------------------------
-
- 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]
# ------------------------------------------------------------------------------
-
- 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
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
-
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):
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
-
-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
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]):
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)
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
-
-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:
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
-
-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
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
-
-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
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)
+
+
-#@ 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
# 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', '<A>_ALARM', '<F>_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'):
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:
# 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':
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)
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 ----------------------------------------------------------------------------
-
-
-
-#@ 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
# 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
#_____________________________________________
#_____________________________________________
# ------------------------------------------------------------------------------
-
def erreur_de_type(code_erreur,X):
"""
code_erreur ==0 --> X est une liste
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
# ------------------------------------------------------------------------------
-
def compare__dim_rep__dim_RESU_EXP(REPONSES,RESU_EXP):
"""
X et Y sont deux arguments qui doivent avoir la meme dimension
# ------------------------------------------------------------------------------
-
def compare__dim_poids__dim_RESU_EXP(POIDS,RESU_EXP):
"""
POIDS et Y sont deux arguments qui doivent avoir la meme dimension
# ------------------------------------------------------------------------------
-
def verif_fichier(UL,PARAMETRES,REPONSES):
"""
On verifie les occurences des noms des PARAMETRES et REPONSES
# ------------------------------------------------------------------------------
-
def verif_valeurs_des_PARAMETRES(PARAMETRES):
"""
On verifie que pour chaque PARAMETRES de l'optimisation
# ------------------------------------------------------------------------------
-
def verif_UNITE(GRAPHIQUE,UNITE_RESU):
"""
On vérifie que les unités de résultat et
# ------------------------------------------------------------------------------
-
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
--- /dev/null
+#@ 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
+
-#@ 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
# ======================================================================
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:
-#@ 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
# 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 :
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
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]:
-# ------------------------------------------------------------------------------
-
+ # ------------------------------------------------------------------------------
def DistVertAdimPointLigneBrisee (self, M, points) :
"""
Distance verticale d'un point M à une ligne brisée composée de n points
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.
"""
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é.
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
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
--- /dev/null
+#@ 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
+
+
+
-#@ 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
# 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 = ' <INFO> 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())
-#@ 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
# 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
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])
# ------------------------------------------------------------------------------
-
-
-
-
+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
#_____________________________________________
-#def temps_CPU(self,restant_old,temps_iter_old):
def temps_CPU(restant_old,temps_iter_old):
"""
Fonction controlant le temps CPU restant
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
-#@ 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
# ======================================================================
# ======================================================================
+#___________________________________________________________________________
+#
+# 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', '<A']:
+ if not diag in ['<F>_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_inf<val_sup
-# val_init appartient à [borne_inf, borne_sup]
-# val_init!=0
-# borne_sup!=0
-# borne_inf!=0
- txt=""
- #verification des bornes
- for i in range(len(PARAMETRES)):
- if( PARAMETRES[i][2] >PARAMETRES[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)
-#@ 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
# ======================================================================
# 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
-#@ 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
# ======================================================================
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):
"""
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]
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
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:
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'
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
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
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
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):
"""
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 = []
bcle = [fct,]
else:
pres_sensi = 1
- if not type(sensi) in (list, tuple):
+ if not is_enum(sensi):
bcle = [sensi,]
for ps in bcle:
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):
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']
# - "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':
# 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
# 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)
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:
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)
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:
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()
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
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
-
