def __evol_et_eval(self,pas,etat,gradient):
print "__evol_et_eval",pas
if type(pas)==list:pas=pas[0]
if (pas==0.):
return self.obji
tempetat={}
tempetat["i"]=0.
self.fn_evol(etat=etat,newetat=tempetat,gradient=gradient,alpha=pas)
#ajouter un teste ici en cas d echec de l evolution
b=[]
for a in range(0,len(self.tab_fn_contrainte)):
b.append(1.)
obji=0
for k in range(0,len(self.tab_fn_contrainte)):
if (k==0):
objtemp=CO('objtemp')
self.tab_fn_contrainte[k][0](etat=tempetat,valeur=objtemp,fn_para=self.tab_fn_contrainte[k][1])
obji=objtemp['R',1]
self.fn_detruire_table(table=objtemp)
else:
objk=CO('objk')
self.tab_fn_contrainte[k][0](etat=tempetat,valeur=objk,fn_para=self.tab_fn_contrainte[k][1])
if (self.class_barriere!=None):
b[k]=self.class_barriere.valeur(objk['R',1])
else:
b[k]=objk['R',1]
obji=obji+b[k]*self.adapt_coef[k]
self.fn_detruire_table(table=objk)
aster.affiche('RESULTAT'," evol et eval alpha=%f retour%f etat:"%(pas,obji))
self.fn_detruire_etat(etat=tempetat)
return obji
def descente_gradient(self,tab_fn_contrainte,etat_init,nb_pas,pas_init,
adaptative_penality=False,adaptative_penality_beta1=1.6,
adaptative_penality_beta2=1.4,adaptative_penality_nb_iter=3,adaptative_penality_coef=[],
residu=10-3,pas_mini=0.01,normalise=False,normalise_iteration=False,
pas_optimal=None,pas_optimal_nb_brent_iter=5):
self.tab_fn_contrainte=tab_fn_contrainte
"""
la premiere fn_contrainte est l'objectif
chaque fn contrainte est une class qui possede la proprietes suivantes
(etat,gradient=CO(out),fn_para)
on ne peut utiliser les propriete de classe que par l'ajout de .opti_vale=[]
qui retourne la valeur de la fonction et le gradient si (out) est fournis
gradient est toujours un objet aster (table ou champ)
etat est toujours un dictionnaire
a la fin toute les fonction contrainte doivent etre <=0
"""
i=0
alpha=pas_init
etat_courrant=etat_init
#coefficient de la fonction barriere
b=[]
derb=[]
for a in range(0,len(self.tab_fn_contrainte)):
b.append(1.)
derb.append(1.)
#coefficient pour l adaptation
self.adapt_coef=adaptative_penality_coef
self.adapt_historique=[]
if (len(self.adapt_coef)==0):
for a in range(0,len(self.tab_fn_contrainte)):
self.adapt_coef.append(1.)
self.adapt_historique.append(0)
else:
for a in range(0,len(self.tab_fn_contrainte)):
self.adapt_historique.append(0)
historique_convergence=[]
convergence=False
while (i<nb_pas and convergence!=True):
aster.affiche('RESULTAT', "\n\ndescente de gradient iteration %d pas %f"%(i,alpha))
gradi=0
self.obji=0
objectif=[]
#print "construction du gradient avec les fonctions criteres"
for k in range(0,len(self.tab_fn_contrainte)):
objtemp=objtemp=CO('objtemp')
objkval=0.
if (k==0):
gradi=CO('gradi')
self.tab_fn_contrainte[k][0](etat=etat_courrant,valeur=objtemp,gradient=gradi,fn_para=self.tab_fn_contrainte[k][1])
objkval=objtemp['R',1]
self.fn_detruire_table(table=objtemp)
self.obji=objkval
objectif.append(objkval)
#Si le gradient doit etre normalise
if (normalise):
gradinor=CO('gradin')
#print "gradi",gradi['R',1]
self.__normalise_grad(etat=etat_courrant,retour=gradinor,gradient=gradi)
gradi=gradinor
#on vas dans la direction oppose a celle indique par le gradient
gradineg=CO('gradineg')
self.fn_mult_grad(etat=etat_courrant,retour=gradineg,gradient=gradi,alpha=-1.)
gradi=gradineg
#gradi=self.__normalise_grad(etat=etat_courrant,gradient=gradi)
else:
gradk=CO('gradk')
self.tab_fn_contrainte[k][0](etat=etat_courrant,valeur=objtemp,gradient=gradk,fn_para=self.tab_fn_contrainte[k][1])
objkval=objtemp['R',1]
self.fn_detruire_table(table=objtemp)
objectif.append(objkval)
if (normalise):
gradkn=CO('gradkn')
self.__normalise_grad(etat=etat_courrant,retour=gradkn,gradient=gradk)
gradk=gradkn
if (self.class_barriere!=None):
derb[k]=self.class_barriere.derive(objkval)
b[k]=self.class_barriere.valeur(objkval)
else:
b[k]=objkval
if (adaptative_penality):
print "adaptative penality",self.adapt_historique
if (objkval>0):
self.adapt_historique[k]+=1
else:
self.adapt_historique[k]-=1
if ((i+1)%(adaptative_penality_nb_iter)==0):
print "adaptative penality i",i," self.adapt_historique[k]",self.adapt_historique[k]
if (self.adapt_historique[k]==adaptative_penality_nb_iter):
print "increase"
self.adapt_coef[k]=self.adapt_coef[k]*adaptative_penality_beta1
if (self.adapt_historique[k]==-adaptative_penality_nb_iter):
print "decrease"
self.adapt_coef[k]=self.adapt_coef[k]/adaptative_penality_beta2
self.adapt_historique[k]=0
print self.adapt_coef[k]
print "bk",b[k],"derbk",derb[k]
self.obji=self.obji+self.adapt_coef[k]*b[k]
gikn=CO('gik%d'%k)
#analytique
self.fn_sauv_etat(etat=etat_courrant,text=self.chemin_de_sauvegarde+"etati.%d"%i)
self.fn_sauv_grad(etat=etat_courrant,gradient=gradi,text=self.chemin_de_sauvegarde+"gradi%davantk%d"%(i,k))
aster.affiche('RESULTAT'," "*10+"sauvegarde gradk adapt:%f, derb:%f"%(self.adapt_coef[k],derb[k]))
self.fn_update_grad(etat=etat_courrant,retour=gikn,grad1=gradi,grad2=gradk,alpha=-self.adapt_coef[k]*derb[k])
gradi=gikn
#analytique
self.fn_sauv_grad(etat=etat_courrant,gradient=gradi,text=self.chemin_de_sauvegarde+"gradi%dapresk%d"%(i,k))
self.fn_detruire_gradient(gradient=gradk)
out=" "*5+"tab_fn_contrainte i:"+str(k)+" objk:"+str(objkval)+" barriere"+str(b[k])+" derbarriere"+str(derb[k]);
aster.affiche('RESULTAT', out)
#if (self.fn_smoothgrad!=None):
# gradi=self.fn_smoothgrad(gradi)
#si on normalise le gradien a chaque iteration
if (normalise_iteration):
gradifn=CO('gradifn')
self.__normalise_grad(etat=etat_courrant,retour=gradifn,gradient=gradi)
gradi=gradifn
#determination du pas optimal
if (pas_optimal!=None):
if (pas_optimal=="brent"):
aster.affiche('RESULTAT', "Calcul du pas optimal avec brent")
if (alpha==0.):
alpha=pas_init
rbrent=scalarsearch.brent(self.__evol_et_eval,func0=self.obji,args=(etat_courrant,gradi),brack=[0.,alpha],maxiter=pas_optimal_nb_brent_iter,full_output=True);
out= "retour brent"+str(rbrent)
aster.affiche('RESULTAT', out)
alpha=rbrent[0]
if (pas_optimal=="armijo"):
aster.affiche('RESULTAT', "Calcul du pas optimal avec armijo")
if (alpha<pas_mini):
alpha=pas_init
a=CO('a')
self.fn_prod_scalaire_grad(etat=etat_courrant,retour=a,grad1=gradi,grad2=gradi)
normgrad=a['R',1]
self.fn_detruire_table(table=a)
retourls=scalarsearch.scalar_search_armijo(phi=self.__evol_et_eval,phi0=self.obji,derphi0=normgrad,alpha0=alpha,args=(etat_courrant,gradi),);
out= "retour arjimo"+str(retourls)
aster.affiche('RESULTAT', out)
alpha=retourls[0]
#scalar_search_wolfe1
if (pas_optimal=="wolfe1"):
aster.affiche('RESULTAT', "Calcul du pas optimal avec wolfe1")
#alpha=pas_init
if (alpha==0.):
alpha=pas_init
a=CO('a')
self.fn_prod_scalaire_grad(etat=etat_courrant,retour=a,grad1=gradi,grad2=gradi)
normgrad=a['R',1]
self.fn_detruire_table(table=a)
retourls=scalarsearch.scalar_search_wolfe1(phi=self.__evol_et_eval_avec_der,phi0=self.obji,derphi0=normgrad,alpha0=alpha,args=(etat_courrant,gradi),);
out= "retour wolfe1"+str(retourls)
aster.affiche('RESULTAT', out)
alpha=retourls[0]
if (alpha==0.):
if(adaptative_penality):
for k in range(1,len(self.tab_fn_contrainte)):
if (objectif[k]>0):
print "increase"
self.adapt_coef[k]=self.adapt_coef[k]*adaptative_penality_beta1
if (objectif[k]<0):
print "decrease"
self.adapt_coef[k]=self.adapt_coef[k]/adaptative_penality_beta2
self.adapt_historique[k]=0
else:
convergence=True
#analytique
aster.affiche('RESULTAT',"sauvegarde iter %d, self.obji:%f"%(i,self.obji))
self.fn_sauv_grad(etat=etat_courrant,gradient=gradi,text=self.chemin_de_sauvegarde+"gradi%d"%i)
self.fn_sauv_etat(etat=etat_courrant,text=self.chemin_de_sauvegarde+"sauvegardeavanti.%d"%i)
if (len(historique_convergence)>=1):
self.variation_absolue=self.obji-historique_convergence[len(historique_convergence)-1][1][0]
if (self.obji!=0):
self.variation_relative=self.variation_absolue/self.obji
else:
self.variation_relative=self.variation_absolue
else:
self.variation_absolue=self.variation_relative=self.obji
tempetat={}
tempetat["i"]=0.
self.fn_evol(etat=etat_courrant,newetat=tempetat,gradient=gradi,alpha=alpha)
self.fn_detruire_etat(etat=etat_courrant)
etat_courrant=tempetat
self.fn_sauv_etat(etat=etat_courrant,text=self.chemin_de_sauvegarde+"sauvegardefini.%d"%i)
historique_convergence.append((i,(self.obji,self.variation_absolue,self.variation_relative),alpha,list(self.adapt_coef),objectif))
out= "historique_convergence (num_ iteration, [objectif,variation_absolue,variation_relative], pas ,[coeficient de lagrange],[objectif])"
for aa in historique_convergence:
out=out+"\n"+" "*5+str(aa)
aster.affiche('RESULTAT', out)
self.fn_detruire_gradient(gradient=gradi)
i+=1
print "fin de descente de grad"
return etat_courrant
def __evol_et_eval_avec_der(self,pas,etat,gradient):
print "__evol_et_eval_avec_der",pas
if type(pas)==list:pas=pas[0]
if (pas==0.):
return self.obji
tempetat={}
tempetat["i"]=0.
self.fn_evol(etat=etat,newetat=tempetat,gradient=gradient,alpha=pas)
#ajouter un teste ici en cas d echec de l evolution
b=[]
for a in range(0,len(self.tab_fn_contrainte)):
b.append(1.)
obji=0
for k in range(0,len(self.tab_fn_contrainte)):
objtemp=objtemp=CO('objtemp')
objkval=0.
if (k==0):
gradj=CO('gradj')
self.tab_fn_contrainte[k][0](etat=etat_courrant,valeur=objtemp,gradient=gradj,fn_para=self.tab_fn_contrainte[k][1])
objkval=objtemp['R',1]
self.fn_detruire_table(table=objtemp)
obji=objkval
#on vas dans la direction oppose a celle indique par le gradient
gradineg=CO('gradjneg')
self.fn_mult_grad(etat=etat_courrant,retour=gradjneg,gradient=gradj,alpha=-1.)
gradj=gradjneg
#gradi=self.__normalise_grad(etat=etat_courrant,gradient=gradi)
else:
gradjk=CO('gradjk')
self.tab_fn_contrainte[k][0](etat=etat_courrant,valeur=objtemp,gradient=gradjk,fn_para=self.tab_fn_contrainte[k][1])
objkval=objtemp['R',1]
self.fn_detruire_table(table=objtemp)
if (self.class_barriere!=None):
derb[k]=self.class_barriere.derive(objkval)
b[k]=self.class_barriere.valeur(objkval)
else:
b[k]=objkval
obji=obji+self.adapt_coef[k]*b[k]
gijkn=CO('gijk%d'%k)
#self.fn_sauv_etat(etat=etat_courrant,text=" "*10+"sauvegarde etat")
#self.fn_sauv_grad(etat=etat_courrant,gradient=gradj,text=" "*10+"sauvegarde gradi avant mise a jour")
out=" "*10+"sauvegarde gradk adapt:%f, derb:%f"%(self.adapt_coef[k],derb[k])
aster.affiche('RESULTAT',out)
self.fn_update_grad(etat=etat_courrant,retour=gijkn,grad1=gradj,grad2=gradjk,alpha=-self.adapt_coef[k]*derb[k])
gradj=gijkn
#self.fn_sauv_grad(etat=etat_courrant,gradient=gradj,text=" "*10+"sauvegarde gradi")
self.fn_detruire_gradient(gradient=gradjk)
a=CO('a')
#print "gradi=gradient",gradient['R',1]
self.fn_prod_scalaire_grad(etat=tempetat,retour=a,grad1=gradient,grad2=gradi)
der=a['R',1]
self.fn_detruire_table(table=a)
aster.affiche('RESULTAT'," sauvegarde evol et eval et der alpha=%f retour(%f,%f) etat:"%(pas,obji,der))
self.fn_detruire_etat(etat=tempetat)
return obji,der
nbVide += sum([1 for i in col if i is None])
# be care to extract the statistics before changing `tab`!
tab['STAT_VALE'] = [len(tab), len(tab.para), nbVide]
tab['STAT_NOM'] = ['NB_LIGNES', 'NB_COLONNES', 'NB_VIDE']
# 99. Création de la table_sdaster résultat
# cas réentrant : il faut détruire l'ancienne table_sdaster
if self.reuse is not None:
DETRUIRE(CONCEPT=_F(NOM=TABLE), INFO=1)
dprod = tab.dict_CREA_TABLE()
if INFO == 2:
echo_mess = ['']
echo_mess.append(repr(tab))
from pprint import pformat
echo_mess.append(pformat(dprod))
echo_mess.append('')
texte_final = os.linesep.join(echo_mess)
aster.affiche('MESSAGE', texte_final)
# surcharge par le titre fourni
tit = args['TITRE']
if tit != None:
if type(tit) not in (list, tuple):
tit = [tit]
dprod['TITRE'] = tuple(['%-80s' % lig for lig in tit])
# type de la table de sortie à passer à CREA_TABLE
tabout = CREA_TABLE(TYPE_TABLE=typ_tabout, **dprod)
return ier
def gestion_sous_bande(solveur_lineaire, __nbmodi, nnfreq, nbproc, lborne,
stop):
nbsb_nonvide = None
proc_sb_nvide = []
# Recuperation du nbre de modes total theorique
nbmodeth = 0
modemin = 1000000
imin = 0
modemax = -1
imax = 0
for i in range(0, nnfreq - 1):
modei = __nbmodi['NB_MODE', i + 1]
nbmodeth = nbmodeth + modei
if (modei > modemax):
modemax = modei
imax = i + 1
if (modei < modemin):
modemin = modei
imin = i + 1
if ((modemax > 3 * modemin) & (modemax > 50)):
UTMESS(
'I',
'MODAL_19',
vali=(imin, modemin, imax, modemax),
)
if (modemin < 10):
UTMESS(
'I',
'MODAL_20',
vali=(imin, modemin),
)
if (modemax > 100):
UTMESS(
'I',
'MODAL_21',
vali=(imax, modemax),
)
# Recuperation du nbre de sous-bandes non vides
nbsb_nonvide = 0
for i in range(0, nnfreq - 1):
if (__nbmodi['NB_MODE', i + 1] != 0):
nbsb_nonvide = nbsb_nonvide + 1
if ((nbmodeth == 0) | (nbsb_nonvide == 0)):
aster.affiche('MESSAGE', 72 * '-')
if stop:
UTMESS('F', 'MODAL_8', valr=(lborne[0], lborne[nnfreq - 1]))
else:
UTMESS('A', 'MODAL_8', valr=(lborne[0], lborne[nnfreq - 1]))
aster.affiche('MESSAGE', 72 * '-')
if (nbproc > 1):
if ((nbproc < nbsb_nonvide) | ((nbproc > nbsb_nonvide) &
(solveur_lineaire != 'MUMPS'))):
aster.affiche('MESSAGE', 72 * '-')
UTMESS('F',
'MODAL_9',
vali=(nbproc, nbsb_nonvide),
valk=solveur_lineaire)
aster.affiche('MESSAGE', 72 * '-')
div = None
reste = None
div = nbproc // nbsb_nonvide
reste = nbproc - nbsb_nonvide * div
if ((nbproc > nbsb_nonvide) & (reste != 0)):
aster.affiche('MESSAGE', 72 * '-')
UTMESS(
'I',
'MODAL_12',
vali=(nbsb_nonvide, div, div + 1),
)
aster.affiche('MESSAGE', 72 * '-')
l1 = nbproc // nbsb_nonvide
l11 = l1 + 1
l2 = nbproc - (l1 * nbsb_nonvide)
num_sb = 0
for i in range(0, l2):
num_sb = num_sb + 1
for j in range(0, l11):
proc_sb_nvide.append(num_sb)
for i in range(l2, nbsb_nonvide):
num_sb = num_sb + 1
for j in range(0, l1):
proc_sb_nvide.append(num_sb)
else:
proc_sb_nvide.append(-999)
return nbmodeth, nbsb_nonvide, proc_sb_nvide
def post_dyna_alea_ops(self, INFO, **args):
# On importe les définitions des commandes a utiliser dans la macro
# Le nom de la variable doit être obligatoirement le nom de la commande
# ------------------------------------------------------------------
#---------algorithme d'optimisation pour le maximum de vraisemblance
def vrais(x):
am = x[0]
beta = x[1]
# assert am >0.000, 'optimize.py: beta negatif'
# assert am >0.000, 'optimize.py: am negatif'
if am <= 0.000:
am = 0.01
if beta <= 0.000:
beta = 0.001
res = 1.0
for k in range(Nbval):
ai = liste_indic[k]
xi = float(liste_def[k])
val = log(ai / am)
pfa = normcdf(val / beta)
f0 = pfa**xi * (1. - pfa)**(1 - xi)
res = res * f0
return -res
def boot_vrais(x):
am = x[0]
beta = x[1]
res = 1.0
for k in range(Nbval):
ai = liste_indic[list_rand[k]]
xi = float(liste_def[list_rand[k]])
val = log(ai / am)
pfa = normcdf(val / beta)
f0 = pfa**xi * (1. - pfa)**(1 - xi)
res = res * f0
return -res
def fonc_def(vale, seuil):
if vale >= seuil:
resu = 1
else:
resu = 0
return resu
# ------------------------------------------------------------------
# OPTION FRAGILITE
# ------------------------------------------------------------------
if 'FRAGILITE' in args:
FRAGILITE = args['FRAGILITE'][0]
if FRAGILITE['LIST_PARA'] is not None:
liste_a = FRAGILITE['LIST_PARA'].sdj.VALE.get()
elif FRAGILITE['VALE'] is not None:
liste_a = FRAGILITE['VALE']
Nba = len(liste_a)
lpfa = []
tab2 = FRAGILITE['TABL_RESU'].EXTR_TABLE()
dicta = tab2.values()
if 'DEFA' in dicta:
liste_def = dicta['DEFA']
test2 = NP.equal(None, liste_def)
elif 'DEMANDE' in dicta:
liste_dem = dicta['DEMANDE']
test2 = NP.equal(None, liste_dem)
else:
UTMESS('F', 'TABLE0_1', valk=('DEFA,DEMANDE'))
if 'PARA_NOCI' in dicta:
liste_indic = dicta['PARA_NOCI']
else:
UTMESS('F', 'TABLE0_1', valk=('PARA_NOCI'))
Nbval = len(liste_indic)
test1 = NP.equal(None, liste_indic)
if test1.any() or test2.any():
if 'DEFA' in dicta:
UTMESS('F', 'TABLE0_14', valk=('DEFA', 'PARA_NOCI'))
elif 'DEMANDE' in dicta:
UTMESS('F', 'TABLE0_14', valk=('DEMANDE', 'PARA_NOCI'))
if FRAGILITE['METHODE'] == "EMV":
# 1) estimation paramètres maximum de vraisemblance
if 'DEFA' not in dicta:
if FRAGILITE['SEUIL'] is not None:
liste_def = [
fonc_def(vale, FRAGILITE['SEUIL'])
for vale in liste_dem
]
else:
UTMESS('F', 'FONCT0_16', valk=('SEUIL'))
x0 = [FRAGILITE['AM_INI'], FRAGILITE['BETA_INI']]
xopt = fmin(vrais, x0)
elif FRAGILITE['METHODE'] == "REGRESSION":
# 2) estimation paramètres REGRESSION
para_b, para_a, sigma, = linregress(NP.log(NP.array(liste_indic)),
NP.log(NP.array(liste_dem)))
if INFO == 2:
texte = 'PARAMETRES REGRESSION : ' + str(para_b) + ' ' + str(
exp(para_a)) + '\n'
aster.affiche('MESSAGE', texte)
Am = exp((log(FRAGILITE['SEUIL']) - para_a) / para_b)
beta = sigma / para_b
xopt = [Am, beta]
texte = 'PARAMETRES Am, beta ESTIMES : ' + str(xopt) + '\n'
aster.affiche('MESSAGE', texte)
#print 'parametres Am, beta estimes: ', xopt
# courbe de fragilité
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]))
# table sortie
mcfact = []
if 'TITRE' in args:
mcfact.append(_F(PARA='TITRE', LISTE_K=args['TITRE']))
mcfact.append(_F(PARA='AM', LISTE_R=xopt[0]))
mcfact.append(_F(PARA='BETA', LISTE_R=xopt[1]))
mcfact.append(_F(PARA='PARA_NOCI', LISTE_R=liste_a))
mcfact.append(_F(PARA='PFA', LISTE_R=lpfa))
# si calcul de fractiles (intervalles de confiance) par bootstrap
x0 = xopt
if FRAGILITE['METHODE'] == "EMV":
if FRAGILITE['FRACTILE'] is not None:
if INFO == 2:
texte = 'FRACTILES A CALCULER PAR BOOTSTRAP ' + \
str(FRAGILITE['FRACTILE']) + '\n'
aster.affiche('MESSAGE', texte)
if FRAGILITE['NB_TIRAGE'] is not None:
Nboot = FRAGILITE['NB_TIRAGE']
if Nboot > Nbval:
UTMESS('F', 'PROBA0_11')
# assert Nboot <= Nbval , 'ERREUR: nombre de
# tirages demandes trop grand'
else:
Nboot = Nbval
list_fonc = []
lfract = FRAGILITE['FRACTILE']
__F1 = [None] * Nbval
__ABS = [None] * Nbval
__ORDO = [None] * Nbval
for kb in range(Nboot): # in range(Nbval)
lpfa = []
list_rand = []
for kb2 in range(Nbval):
list_rand.append(random.randint(0, Nbval - 1))
xopt = fmin(boot_vrais, x0)
if INFO == 2:
texte1 = 'BOOTSTRAP TIRAGE ' + str(kb + 1)
texte2 = ' PARAMETRES Am, beta ESTIMES : ' + \
str(xopt) + '\n'
aster.affiche('MESSAGE', texte1)
aster.affiche('MESSAGE', texte2)
vecval = (NP.log(vec_a / xopt[0])) / xopt[1]
for m in range(Nba):
lpfa.append(normcdf(vecval[m]))
__ABS[kb] = DEFI_LIST_REEL(VALE=liste_a)
__ORDO[kb] = DEFI_LIST_REEL(VALE=lpfa)
__F1[kb] = DEFI_FONCTION(
NOM_PARA='PGAZ',
NOM_RESU='PFA',
VALE_PARA=__ABS[kb],
VALE_FONC=__ORDO[kb],
)
list_fonc.append(__F1[kb], )
#__FRACTILE = [None]*len(lfract)
liste = [None] * len(lfract)
for kb in range(len(lfract)):
__FRACTILE = CALC_FONCTION(FRACTILE=_F(
FONCTION=(list_fonc), FRACT=lfract[kb]), )
liste[kb] = __FRACTILE.Ordo()
mcfact.append(_F(PARA=str(lfract[kb]), LISTE_R=liste[kb]))
# fin FRAGILITE
tabout = CREA_TABLE(LISTE=mcfact, TITRE='POST_DYNA_ALEA - Fragilite')
# ------------------------------------------------------------------
# ------------------------------------------------------------------
# OPTION INTESPEC
# ------------------------------------------------------------------
if 'INTERSPECTRE' in args:
INTERSPECTRE = args['INTERSPECTRE']
INTE_SPEC = INTERSPECTRE['INTE_SPEC']
NUME_ORDRE_I = INTERSPECTRE['NUME_ORDRE_I']
NOEUD_I = INTERSPECTRE['NOEUD_I']
OPTION = INTERSPECTRE['OPTION']
MOMENT = INTERSPECTRE['MOMENT']
DUREE = INTERSPECTRE['DUREE']
FRACTILE = INTERSPECTRE['FRACTILE']
# table résultat
tabres = Table(titr='POST_DYNA_ALEA - Interspectre')
# ------------------------------------------------------------------
# Liste des moments spectraux
# repérer le type de l'interspectre et son nom
# 1- concept interspectre
# 2- table de table d interspectre
intespec = INTE_SPEC.getName().ljust(8)
# ------------------------------------------------------------------
# Repérer les couples d'indices selectionnés
# vérification de l'égalité du nombre d indices en i et j
if NUME_ORDRE_I is not None:
l_ind_i = NUME_ORDRE_I
if type(l_ind_i) not in EnumTypes:
l_ind_i = [l_ind_i]
l_ind_j = INTERSPECTRE['NUME_ORDRE_J']
if l_ind_j:
if type(l_ind_j) not in EnumTypes:
l_ind_j = [l_ind_j]
if len(l_ind_i) != len(l_ind_j):
UTMESS('F', 'PROBA0_8')
else:
l_ind_j = NUME_ORDRE_I
if type(l_ind_j) not in EnumTypes:
l_ind_j = [l_ind_j]
# paramètres fixes de la table
tabres.add_para(['NUME_ORDRE_I', 'NUME_ORDRE_J'], 'I')
elif NOEUD_I is not None:
l_ind_i = NOEUD_I
l_cmp_i = INTERSPECTRE['NOM_CMP_I']
if type(l_ind_i) not in EnumTypes:
l_ind_i = [l_ind_i]
if type(l_cmp_i) not in EnumTypes:
l_cmp_i = [l_cmp_i]
l_ind_j = INTERSPECTRE['NOEUD_J']
if l_ind_j:
l_cmp_j = INTERSPECTRE['NOM_CMP_J']
if type(l_ind_j) not in EnumTypes:
l_ind_j = [l_ind_j]
if type(l_cmp_j) not in EnumTypes:
l_cmp_j = [l_cmp_j]
if len(l_ind_i) != len(l_ind_j):
UTMESS('F', 'PROBA0_8')
if len(l_cmp_i) != len(l_cmp_j):
UTMESS('F', 'PROBA0_9')
if len(l_ind_i) != len(l_cmp_i):
UTMESS('F', 'PROBA0_10')
else:
l_ind_j = NOEUD_I
l_cmp_j = INTERSPECTRE['NOM_CMP_I']
if type(l_ind_j) not in EnumTypes:
l_ind_j = [l_ind_j]
if type(l_cmp_j) not in EnumTypes:
l_cmp_j = [l_cmp_j]
# paramètres fixes de la table
tabres.add_para(['NOEUD_I', 'NOEUD_J', 'NOM_CMP_I', 'NOM_CMP_J'],
'K8')
# ------------------------------------------------------------------
# Cas de tous les indices
elif OPTION == 'TOUT':
if aster.getvectjev(intespec + '.NUMI'):
l_ind_i = aster.getvectjev(intespec + '.NUMI')
l_ind_j = aster.getvectjev(intespec + '.NUMJ')
tabres.add_para(['NUME_ORDRE_I', 'NUME_ORDRE_J'], 'I')
if aster.getvectjev(intespec + '.NOEI'):
l_ind_i = aster.getvectjev(intespec + '.NOEI')
l_ind_j = aster.getvectjev(intespec + '.NOEJ')
l_cmp_i = aster.getvectjev(intespec + '.CMPI')
l_cmp_j = aster.getvectjev(intespec + '.CMPJ')
tabres.add_para(
['NOEUD_I', 'NOEUD_J', 'NOM_CMP_I', 'NOM_CMP_J'], 'K8')
# ------------------------------------------------------------------
# Cas de tous les indices centraux
elif OPTION == 'DIAG':
if aster.getvectjev(intespec + '.NUMI'):
l_ind_i_all = aster.getvectjev(intespec + '.NUMI')
l_ind_j_all = aster.getvectjev(intespec + '.NUMJ')
l_ind_i = [
ind for i, ind in enumerate(l_ind_i_all)
if l_ind_j_all[i] == ind
]
l_ind_j = l_ind_i
tabres.add_para(['NUME_ORDRE_I', 'NUME_ORDRE_J'], 'I')
if aster.getvectjev(intespec + '.NOEI'):
l_ind_i_all = aster.getvectjev(intespec + '.NOEI')
l_ind_j_all = aster.getvectjev(intespec + '.NOEJ')
l_ind_i = [
ind for i, ind in enumerate(l_ind_i_all)
if l_ind_j_all[i] == ind
]
l_ind_j = l_ind_i
l_cmp_i_all = aster.getvectjev(intespec + '.CMPI')
l_cmp_j_all = aster.getvectjev(intespec + '.CMPJ')
l_cmp_i = [
cmpi for i, cmpi in enumerate(l_cmp_i_all)
if l_cmp_j_all[i] == cmpi
]
l_cmp_j = l_cmp_i
tabres.add_para(
['NOEUD_I', 'NOEUD_J', 'NOM_CMP_I', 'NOM_CMP_J'], 'K8')
# ------------------------------------------------------------------
# Liste des moments spectraux
l_moments = [0, 1, 2, 3, 4]
if MOMENT is not None:
l_moments.extend(list(MOMENT))
l_moments = list(set(l_moments))
# ------------------------------------------------------------------
# Boucle sur les fonctions
if aster.getvectjev(intespec + '.NOEI'):
l_ind = list(zip(l_ind_i, l_ind_j, l_cmp_i, l_cmp_j))
else:
l_ind = list(zip(l_ind_i, l_ind_j))
# pour la présentation de la table finale, on stocke le nbre de
# paramètres "initiaux"
nbpara0 = len(tabres.para)
if INFO == 2:
texte = 'POUR LA MATRICE INTERSPECTRALE ' + INTE_SPEC.getName(
) + '\n'
aster.affiche('MESSAGE', texte)
for ind in l_ind:
dlign = {}
dlrecu = {}
if NOEUD_I:
i_foncstat = ind[0] == ind[1] and ind[2] == ind[3]
dlign['NOEUD_I'], dlign['NOEUD_J'], dlign['NOM_CMP_I'], dlign['NOM_CMP_J'] = \
ind[0], ind[1], ind[2], ind[3]
if ind[0] == ind[1] and ind[2] == ind[3]:
dlrecu['NOEUD_I'], dlrecu['NOM_CMP_I'] = ind[0], ind[2]
else:
dlrecu['NOEUD_I'], dlrecu['NOEUD_J'], dlrecu['NOM_CMP_I'], \
dlrecu['NOM_CMP_J'] = ind[0], ind[1], ind[2], ind[3]
if INFO == 2:
aster.affiche('MESSAGE',
'INDICES :' + ind[0] + ' - ' + ind[1])
aster.affiche('MESSAGE',
'INDICES :' + ind[2] + ' - ' + ind[3] + '\n')
elif NUME_ORDRE_I:
i_foncstat = ind[0] == ind[1]
dlign['NUME_ORDRE_I'], dlign['NUME_ORDRE_J'] = ind[0], ind[1]
if ind[0] == ind[1]:
dlrecu['NUME_ORDRE_I'] = ind[0]
else:
dlrecu['NUME_ORDRE_I'], dlrecu['NUME_ORDRE_J'] = ind[
0], ind[1]
if INFO == 2:
aster.affiche(
'MESSAGE',
'INDICES :' + str(ind[0]) + ' - ' + str(ind[1]) + '\n')
else: # TOUT_ORDRE
if aster.getvectjev(intespec + '.NUMI'):
i_foncstat = ind[0] == ind[1]
dlign['NUME_ORDRE_I'], dlign['NUME_ORDRE_J'] = ind[0], ind[
1]
if ind[0] == ind[1]:
dlrecu['NUME_ORDRE_I'] = ind[0]
else:
dlrecu['NUME_ORDRE_I'], dlrecu['NUME_ORDRE_J'] = ind[
0], ind[1]
if aster.getvectjev(intespec + '.NOEI'):
i_foncstat = ind[0] == ind[1] and ind[2] == ind[3]
dlign['NOEUD_I'], dlign['NOEUD_J'], dlign['NOM_CMP_I'], dlign['NOM_CMP_J'] = \
ind[0], ind[1], ind[2], ind[3]
if ind[0] == ind[1] and ind[2] == ind[3]:
dlrecu['NOEUD_I'], dlrecu['NOM_CMP_I'] = ind[0], ind[2]
else:
dlrecu['NOEUD_I'], dlrecu['NOEUD_J'], dlrecu['NOM_CMP_I'], \
dlrecu['NOM_CMP_J'] = ind[
0], ind[1], ind[2], ind[3]
__fon1 = RECU_FONCTION(INTE_SPEC=INTE_SPEC, **dlrecu)
val = __fon1.Valeurs()
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 = 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 = NP.cumsum(trapz)
val_mom[i_mom] = prim_y[-1]
# -- cas si, seule la partie positive du spectre est utilisée
# -- Il faut donc doubler lambda pour calculer le bon écart type
if frez >= 0.:
val_mom[i_mom] = val_mom[i_mom] * 2.
for i_mom in l_moments:
chmo = 'LAMBDA_' + str(i_mom).zfill(2)
dlign[chmo] = val_mom[i_mom]
#--- si auto-spectre:
if i_foncstat:
# test si le spectre est bien à valeurs positives
if min(fvaly) < 0.0:
aster.affiche('MESSAGE', str(ind) + '\n')
UTMESS('F', 'MODELISA9_95')
# -- fonctions statistiques
dlign['ECART'] = sqrt(val_mom[0])
if DUREE is not None:
Ts = DUREE
vop = sqrt(val_mom[2] / val_mom[0]) / (2. * pi)
Nu = Ts * vop / (-log(FRACTILE))
deltau = sqrt(1. - val_mom[1]**2 /
(val_mom[2] * val_mom[0]))
valNd = 2. * Nu * \
(1 - exp(-(deltau) ** 1.2 * sqrt(pi * log(2. * Nu))))
val_peak = sqrt(2. * log(valNd))
dlign['FACT_PIC'] = val_peak # -- facteur de peak
if FRACTILE == 0.5:
Titre_lign = 'MAX_MOY'
else:
Titre_lign = 'MAX_FRACT'
dlign[Titre_lign] = val_peak * sqrt(
val_mom[0]) # -- fractile du max (mediane pour 0.5)
if abs(val_mom[2]) >= 1e-20:
dlign['NB_EXTREMA_P_S'] = 1. / \
pi * sqrt(val_mom[4] / val_mom[2])
if abs(val_mom[0]) >= 1e-20:
dlign['NB_PASS_ZERO_P_S'] = 1. / \
pi * sqrt(val_mom[2] / val_mom[0])
dlign['FREQ_APPAR'] = 0.5 * dlign['NB_PASS_ZERO_P_S']
if abs(val_mom[4]) >= 1e-20:
dlign['FACT_IRRE'] = sqrt(val_mom[2] * val_mom[2] /
val_mom[0] / val_mom[4])
# ajoute la ligne à la Table
tabres.append(dlign)
#--- construction de la table produite
# tri des paramètres
ord_para = tabres.para[nbpara0:]
ord_para.sort()
ord_para = tabres.para[:nbpara0] + ord_para
dprod = tabres[ord_para].dict_CREA_TABLE()
tabout = CREA_TABLE(**dprod)
return tabout
def calc_modes_multi_bandes(self, stop_erreur, sturm, INFO, **args):
"""
Macro-command CALC_MODES, case of the simultaneous iterations method
over several frequency bands, with optional parallelization.
Can be used only in the case of vibration modes (TYPE_RESU='DYNAMIQUE')
"""
args = _F(args)
SOLVEUR = args.get("SOLVEUR")
SOLVEUR_MODAL = args.get("SOLVEUR_MODAL")
VERI_MODE = args.get("VERI_MODE")
MATR_RIGI = args['MATR_RIGI']
MATR_MASS = args['MATR_MASS']
CALC_FREQ = args['CALC_FREQ']
METHODE = SOLVEUR_MODAL['METHODE']
STOP_BANDE_VIDE = "NON"
# ----------------------------------------------------------------------
#
# 1a. INITIALISATIONS
#
# ----------------------------------------------------------------------
dbg = False # True si on souhaite faire un IMPR_CO intermediaire, False sinon
# Recuperation parametres solveur lineaire
dSolveur = SOLVEUR[0].cree_dict_valeurs(SOLVEUR[0].mc_liste)
for i in list(dSolveur.keys()):
if dSolveur[i] is None:
del dSolveur[i]
if 'TYPE_RESU' in dSolveur: # because TYPE_RESU is a keyword with a 'global' position
del dSolveur['TYPE_RESU']
if 'OPTION' in dSolveur: # because OPTION is a keyword with a 'global' position
del dSolveur['OPTION']
if 'FREQ' in dSolveur: # because FREQ can be a keyword with a 'global' position
del dSolveur['FREQ']
solveur_lineaire = dSolveur.get('METHODE').strip()
dSolveur_infomode = dSolveur
# pour INFO_MODE, le mot-clé facteur SOLVEUR ne doit pas contenir les
# mot-clés POSTTRAITEMENTS et RESI_RELA
if 'POSTTRAITEMENTS' in dSolveur_infomode:
del dSolveur_infomode['POSTTRAITEMENTS']
if 'RESI_RELA' in dSolveur_infomode:
del dSolveur_infomode['RESI_RELA']
# Rang du processus MPI et taille du MPI_COMM_WORLD
# Lorsqu'on ne veut q'un niveau de parallelisme (celui du solveur lineaire)
# on bluffe l'algo en posant rang=0/nbproc=1 pour tous les procs.
# Cependant si le solveur est autre que MUMPS on s'arrete en erreur.
if CALC_FREQ['NIVEAU_PARALLELISME'] == 'COMPLET':
rang, nbproc = aster_core.MPI_CommRankSize()
niv_par = 'COMPLET'
elif CALC_FREQ['NIVEAU_PARALLELISME'] == 'PARTIEL':
rang = 0
nbproc = 1
niv_par = 'PARTIEL'
nbproc_real = aster_core.MPI_CommRankSize()[1]
if ((nbproc_real > 1) & (solveur_lineaire != 'MUMPS')):
aster.affiche('MESSAGE', 72 * '-')
UTMESS('F', 'MODAL_14', vali=nbproc_real, valk=solveur_lineaire)
aster.affiche('MESSAGE', 72 * '-')
else:
assert (False) # Pb parametrage NIVEAU_PARALLELISME
# Construction de la liste de frequences
if CALC_FREQ['FREQ']:
lborne = []
nnfreq = len(CALC_FREQ['FREQ'])
for i in range(0, nnfreq):
lborne.append(CALC_FREQ['FREQ'][i])
else:
assert (False) # Pb parametrage CALC_FREQ
# ----------------------------------------------------------------------
#
# 1b. TRAVAUX PREPARATOIRES AU LANCEMENT DE LA BOUCLE
#
# ----------------------------------------------------------------------
# Modification de la sd_partition pour rendre compatible les niveaux de
# parallelisme: celui en frequence et celui des calculs ele/assemblage.
# Pour l'instant on fonctionne en mode 'CENTRALISE' au sein de la macro
# (ds les sous-communicateurs, les calculs elem/assemblages
# ne sont pas parallelises).
# On remettra le mode de fonctionnement initial en fin de Macro.
if (nbproc > 1):
_, old_prtk1 = recup_modele_partition(MATR_RIGI, dbg)
sd_modele = None
if MATR_RIGI is not None:
sd_modele = MATR_RIGI.getModel()
if (sd_modele is None):
assert (False) # Pb, on arrive pas a recuperer le nom du modele
if (old_prtk1 is not None):
motdimo = {}
motdimo['reuse'] = sd_modele
motdimo['MODELE'] = sd_modele
motdimo['DISTRIBUTION'] = _F(METHODE='CENTRALISE')
__modimo = MODI_MODELE(**motdimo)
# INFO_MODE global sur la liste de frequences
# Parametres basiques
motfaci = {}
motfaci['COMPTAGE'] = _F(
METHODE='AUTO',
SEUIL_FREQ=CALC_FREQ['SEUIL_FREQ'],
NMAX_ITER_SHIFT=CALC_FREQ['NMAX_ITER_SHIFT'],
PREC_SHIFT=CALC_FREQ['PREC_SHIFT'],
)
# Gestion des frequences
gestion_frequence(solveur_lineaire, nnfreq, nbproc)
# Parametrage du parallelisme pour la couche FORTRAN/MPI
if (nbproc > 1):
motfaci['PARALLELISME_MACRO'] = _F(TYPE_COM=1)
__nbmodi = INFO_MODE(MATR_RIGI=MATR_RIGI,
MATR_MASS=MATR_MASS,
INFO=INFO,
FREQ=lborne,
NIVEAU_PARALLELISME=niv_par,
SOLVEUR=dSolveur_infomode,
**motfaci)
# Gestion des sous-bandes de frequences et construction (si //) de l'objet
nbmodeth, nbsb_nonvide, proc_sb_nvide = gestion_sous_bande(
solveur_lineaire, __nbmodi, nnfreq, nbproc, lborne,
STOP_BANDE_VIDE == "OUI")
# ----------------------------------------------------------------------
#
# 2. BOUCLE DE MODE_ITER_SIMULT(OPTION=BANDE) + NORM_MODE/IMPR_RESU
#
# ----------------------------------------------------------------------
# On ne traite pas les sous-bandes vides (gain de temps et d'affichage!)
# On affiche un message a la place.
# Tous les processeurs font la meme chose pour ces sous-bandes vides, par
# contre, ils se repartissent bien sur les non-vides.
#
# RQ MPI:
# Les procs s'attendent via le MPI_COMM_SPLIT opere en fin de l'INFO_MODE
# precedent. Ce n'est pas la peine de commencer la boucle si un proc
# fait defaut.
# ----------------------------------------------------------------------
freq_ini = 1.E+99
freq_fin = -1.E+99
motscles = {}
motscles['FILTRE_MODE'] = []
numsb_nonvide = 0
for i in range(0, nnfreq - 1):
#--------------------------------------------------------------------
#
# 2. SOUS-BANDE NON VIDE
#
#--------------------------------------------------------------------
sb_vide = None
do_loop = None
if (__nbmodi['NB_MODE', i + 1] == 0):
sb_vide = True
do_loop = False
else:
numsb_nonvide = numsb_nonvide + 1
sb_vide = False
if (((nbproc > 1) & (proc_sb_nvide[rang] == numsb_nonvide)) |
(nbproc == 1)):
do_loop = True
else:
do_loop = False
if ((not sb_vide) & do_loop):
motscit = {}
motscfa = {}
if SOLVEUR_MODAL['DIM_SOUS_ESPACE']:
motscfa['DIM_SOUS_ESPACE'] = SOLVEUR_MODAL['DIM_SOUS_ESPACE']
if SOLVEUR_MODAL['COEF_DIM_ESPACE']:
motscfa['COEF_DIM_ESPACE'] = SOLVEUR_MODAL['COEF_DIM_ESPACE']
motscfa['FREQ'] = (lborne[i], lborne[i + 1])
motscfa['TABLE_FREQ'] = __nbmodi
motscit['CALC_FREQ'] = _F(
OPTION='BANDE',
SEUIL_FREQ=CALC_FREQ['SEUIL_FREQ'],
NMAX_ITER_SHIFT=CALC_FREQ['NMAX_ITER_SHIFT'],
PREC_SHIFT=CALC_FREQ['PREC_SHIFT'],
**motscfa)
if (sturm == 'LOCAL'):
motveri = 'OUI'
else:
motveri = 'NON'
motscit['VERI_MODE'] = _F(STOP_ERREUR=stop_erreur,
SEUIL=VERI_MODE['SEUIL'],
STURM=motveri,
PREC_SHIFT=VERI_MODE['PREC_SHIFT'])
motscit['STOP_BANDE_VIDE'] = STOP_BANDE_VIDE
OPTION = 'SANS' # option for detecting rigid body modes
if METHODE == 'TRI_DIAG':
if 'NMAX_ITER_ORTHO' in args:
motscit['NMAX_ITER_ORTHO'] = SOLVEUR_MODAL[
'NMAX_ITER_ORTHO']
if 'PREC_ORTHO' in args:
motscit['PREC_ORTHO'] = SOLVEUR_MODAL['PREC_ORTHO']
if 'PREC_LANCZOS' in args:
motscit['PREC_LANCZOS'] = SOLVEUR_MODAL['PREC_LANCZOS']
if 'MAX_ITER_QR' in args:
motscit['NMAX_ITER_QR'] = SOLVEUR_MODAL['NMAX_ITER_QR']
if SOLVEUR_MODAL['MODE_RIGIDE'] == 'OUI':
OPTION = 'MODE_RIGIDE'
elif METHODE == 'JACOBI':
if 'NMAX_ITER_BATHE' in args:
motscit['NMAX_ITER_BATHE'] = SOLVEUR_MODAL[
'NMAX_ITER_BATHE']
if 'PREC_BATHE' in args:
motscit['PREC_BATHE'] = SOLVEUR_MODAL['PREC_BATHE']
if 'NMAX_ITER_JACOBI' in args:
motscit['NMAX_ITER_JACOBI'] = SOLVEUR_MODAL[
'NMAX_ITER_JACOBI']
if 'PREC_JACOBI' in args:
motscit['PREC_JACOBI'] = SOLVEUR_MODAL['PREC_JACOBI']
elif METHODE == 'SORENSEN':
if 'NMAX_ITER_SOREN' in args:
motscit['NMAX_ITER_SOREN'] = SOLVEUR_MODAL[
'NMAX_ITER_SOREN']
if 'PARA_ORTHO_SOREN' in args:
motscit['PARA_ORTHO_SOREN'] = SOLVEUR_MODAL[
'PARA_ORTHO_SOREN']
if 'PREC_SOREN' in args:
motscit['PREC_SOREN'] = SOLVEUR_MODAL['PREC_SOREN']
elif METHODE == 'QZ':
motscit['TYPE_QZ'] = SOLVEUR_MODAL['TYPE_QZ']
else:
assert (False) # Pb parametrage METHODE
# Parametrage du parallelisme pour la couche FORTRAN/MPI
# afin d'operer les comm des modes propres et des parametres
# modaux.
if (nbproc > 1):
motscit['PARALLELISME_MACRO'] = _F(
TYPE_COM=1,
IPARA1_COM=numsb_nonvide,
IPARA2_COM=nbsb_nonvide,
)
#-----------------------------------------------------------------
#
# 2a. Calcul des modes
#
#----------------------------------------------------------------- )
__nomre0 = MODE_ITER_SIMULT(MATR_RIGI=MATR_RIGI,
MATR_MASS=MATR_MASS,
INFO=INFO,
METHODE=METHODE,
OPTION=OPTION,
SOLVEUR=dSolveur,
**motscit)
#-----------------------------------------------------------------
#
# 2b. Preparation du test de Sturm de l'etape 3a.
#
#-----------------------------------------------------------------
if sturm in (
'GLOBAL', 'OUI'
): # in the case of CALC_MODES on several bands, OUI is reset to GLOBAL
dicomode = {}
dicomode = __nomre0.LIST_VARI_ACCES()
if (len(dicomode['FREQ']) != 0):
raux_ini = dicomode['FREQ'][0]
raux_fin = dicomode['FREQ'][-1]
if (raux_ini < freq_ini):
freq_ini = raux_ini
if (raux_fin > freq_fin):
freq_fin = raux_fin
else:
assert (False
) # Ce test ne marche pas (PB LIST_VARI_ACCES)
#-----------------------------------------------------------------
#
# 2c. Préparation pour la concaténation de l'étape 3b.
#
#-----------------------------------------------------------------
motscles['FILTRE_MODE'].append(_F(MODE=__nomre0, TOUT_ORDRE='OUI'))
# Pour verification
if (dbg):
IMPR_CO(CONCEPT=_F(NOM=__nomre0))
#--------------------------------------------------------------------
#
# 2. SOUS-BANDE VIDE
#
#--------------------------------------------------------------------
elif (sb_vide):
if (STOP_BANDE_VIDE == 'OUI'):
UTMESS('F', 'MODAL_6', vali=(i + 1, ))
elif (STOP_BANDE_VIDE == 'NON'):
aster.affiche('MESSAGE', 72 * '-')
UTMESS('I', 'MODAL_6', vali=(i + 1, ))
aster.affiche('MESSAGE', 72 * '-')
else:
assert (False) # Pb parametrage STOP_BANDE_VIDE
#-----------------------------------------------------------------------
#
# 3a. Test de sturm effectif
#
#-----------------------------------------------------------------------
if (sturm == 'NON'):
aster.affiche('MESSAGE', 72 * '-')
UTMESS('I', 'MODAL_2')
aster.affiche('MESSAGE', 72 * '-')
elif (sturm == 'LOCAL'):
aster.affiche('MESSAGE', 72 * '-')
UTMESS('I', 'MODAL_3')
aster.affiche('MESSAGE', 72 * '-')
elif sturm in (
'GLOBAL', 'OUI'
): # in the case of CALC_MODES on several bands, OUI is reset to GLOBAL
# Construction des 2 bornes de la bande a tester
if (nbmodeth != 0):
omecor = CALC_FREQ['SEUIL_FREQ']
precshift = VERI_MODE['PREC_SHIFT']
freq_ini = (1.0 - precshift) * freq_ini
freq_fin = (1.0 + precshift) * freq_fin
if (abs(freq_ini) < omecor):
freq_ini = -omecor
if (abs(freq_fin) < omecor):
freq_fin = omecor
# Parametrage du parallelisme pour la couche FORTRAN/MPI
if (nbproc > 1):
motfaci['PARALLELISME_MACRO'] = _F(TYPE_COM=2)
__nbmodf = INFO_MODE(MATR_RIGI=MATR_RIGI,
MATR_MASS=MATR_MASS,
INFO=INFO,
FREQ=(freq_ini, freq_fin),
NIVEAU_PARALLELISME=niv_par,
SOLVEUR=dSolveur_infomode,
**motfaci)
# Recuperation du nbre de modes donnes par STURM global
nbmodesg = __nbmodf['NB_MODE', 1]
if (nbmodeth == nbmodesg):
aster.affiche('MESSAGE', 72 * '-')
UTMESS('I',
'MODAL_4',
valr=(freq_ini, freq_fin),
vali=(nbmodesg, nbmodeth))
aster.affiche('MESSAGE', 72 * '-')
else:
# Message similaire a ALGELINE5_24 pour le FORTRAN
if (stop_erreur == 'OUI'):
UTMESS('F',
'MODAL_5',
valr=(freq_ini, freq_fin, precshift),
vali=(nbmodesg, nbmodeth))
elif (stop_erreur == 'NON'):
UTMESS('A',
'MODAL_5',
valr=(freq_ini, freq_fin, precshift),
vali=(nbmodesg, nbmodeth))
else:
assert (False) # Pb parametrage VERI_MODE
# La bande globale est vide
else:
aster.affiche('MESSAGE', 72 * '-')
UTMESS('I', 'MODAL_7', valr=(lborne[0], lborne[nnfreq - 1]))
aster.affiche('MESSAGE', 72 * '-')
else:
assert (False) # Pb parametrage STURM
#-----------------------------------------------------------------------
#
# 3b. Concaténation des résultats
#
#-----------------------------------------------------------------------
modes = EXTR_MODE(**motscles)
# ----------------------------------------------------------------------
#
# 3c. Epilogue
#
# RQ MPI:
# Si la SD_PARTITION existait avant de rentrer ds la Macro on remet ses
# anciennes valeurs pour continuer la suite du fichier de commande.
#----------------------------------------------------------------------
if (nbproc > 1):
if (old_prtk1 is not None):
motdimo = {}
motdimo['reuse'] = sd_modele
motdimo['MODELE'] = sd_modele
motdimo['DISTRIBUTION'] = _F(METHODE=old_prtk1)
__modimo = MODI_MODELE(**motdimo)
return modes
def macro_matr_ajou_ops(self,
MAILLAGE,
GROUP_MA_FLUIDE,
GROUP_MA_INTERF,
MODELISATION,
FLUIDE,
DDL_IMPO,
MODE_MECA=None,
DEPL_IMPO=None,
NUME_DDL_GENE=None,
MODELE_GENE=None,
MATR_MASS_AJOU=None,
MATR_AMOR_AJOU=None,
MATR_RIGI_AJOU=None,
NOEUD_DOUBLE=None,
DIST_REFE=None,
SOLVEUR=None,
INFO=None,
AVEC_MODE_STAT=None,
MODE_STAT=None,
MONO_APPUI=None,
FORC_AJOU=None,
ECOULEMENT=None,
**args):
"""
Ecriture de la macro MACRO_MATR_AJOU
"""
# On importe les definitions des commandes a utiliser dans la macro
if len(FLUIDE) == 1:
message = '<I> <MACRO_MATR_AJOU> tout le domaine fluide specifie dans GROUP_MA_INTERF et GROUP_MA_FLUIDE \n'
message = message + ' sera affecte par la masse volumique RHO = ' + \
str(FLUIDE[0]['RHO']) + ' \n'
aster.affiche('MESSAGE', message)
if FLUIDE[0]['GROUP_MA'] is not None:
message = '<I> <MACRO_MATR_AJOU> cas fluide simple : le group_ma dans lequel vous affectez la masse \n'
message = message + \
'volumique RHO doit etre la reunion de GROUP_MA_INTERF et GROUP_MA_FLUIDE. \n'
aster.affiche('MESSAGE', message)
else:
for flu in FLUIDE:
if flu['GROUP_MA'] is None:
UTMESS('F', 'MATRICE0_1')
IOCFLU = len(FLUIDE)
# ---------------------------------------------------------------
# definition du materiau fluide par caracteristique
# thermique equivalente
# CAS FLUIDE SIMPLE
if IOCFLU == 1:
__NOMMAT = DEFI_MATERIAU(THER=_F(LAMBDA=1.0, RHO_CP=FLUIDE[0]['RHO']))
__NOMCMA = AFFE_MATERIAU(
MAILLAGE=MAILLAGE,
AFFE=_F(GROUP_MA=(GROUP_MA_FLUIDE, GROUP_MA_INTERF),
MATER=__NOMMAT),
)
# ---------------------------------------------------------------
# cas fluides multiples
else:
affmat = []
for flu in FLUIDE:
__NOMMAT = DEFI_MATERIAU(THER=_F(LAMBDA=1.0, RHO_CP=flu['RHO']))
mfact = _F(GROUP_MA=flu['GROUP_MA'], MATER=__NOMMAT)
affmat.append(mfact)
__NOMCMA = AFFE_MATERIAU(MAILLAGE=MAILLAGE, AFFE=affmat)
# ---------------------------------------------------------------
# commande AFFE_MODELE modele fluide
__NOMFLU = AFFE_MODELE(
MAILLAGE=MAILLAGE,
AFFE=_F(GROUP_MA=(GROUP_MA_FLUIDE, GROUP_MA_INTERF),
MODELISATION=MODELISATION,
PHENOMENE='THERMIQUE'),
)
# ---------------------------------------------------------------
# commande AFFE_MODELE modele interface
# Pour masquer certaines alarmes
# <MODELE1_63> : DANS UN MODELE, IL EXISTE DES ELEMENTS DE TYPE "BORD" QUI N'ONT PAS DE VOISIN AVEC RIGIDITE
# <MODELE1_64> : DANS UN MODELE, IL N'Y A AUCUN ELEMENT AVEC RIGIDITE
MasquerAlarme('MODELE1_63')
MasquerAlarme('MODELE1_64')
__NOMINT = AFFE_MODELE(
MAILLAGE=MAILLAGE,
AFFE=_F(GROUP_MA=GROUP_MA_INTERF,
MODELISATION=MODELISATION,
PHENOMENE='THERMIQUE'),
)
RetablirAlarme('MODELE1_63')
RetablirAlarme('MODELE1_64')
# ---------------------------------------------------------------
# commande AFFE_CHAR_THER condition de pression imposee
# en un point ou un groupe du fluide
affimp = []
nflui = 0
for DDL in DDL_IMPO:
if DDL['PRES_FLUIDE'] is not None:
nflui = nflui + 1
if DDL['NOEUD'] is not None:
mfact = _F(NOEUD=DDL['NOEUD'], TEMP=DDL['PRES_FLUIDE'])
if DDL['GROUP_NO'] is not None:
mfact = _F(GROUP_NO=DDL['GROUP_NO'], TEMP=DDL['PRES_FLUIDE'])
affimp.append(mfact)
if nflui == 0:
UTMESS('F', 'MATRICE0_2')
__CHARGE = AFFE_CHAR_THER(MODELE=__NOMFLU, TEMP_IMPO=affimp)
# ---------------------------------------------------------------
# calcul des masses, rigidites et amortissements ajoutes en theorie
# potentielle
# commande CALC_MATR_AJOU, calcul de la masse ajoutee
if MATR_MASS_AJOU is not None:
solveur = SOLVEUR[0].cree_dict_valeurs(SOLVEUR[0].mc_liste)
mostcles = {}
if NUME_DDL_GENE is not None:
mostcles['NUME_DDL_GENE'] = NUME_DDL_GENE
if INFO is not None:
mostcles['INFO'] = INFO
if MODE_MECA is not None:
mostcles['MODE_MECA'] = MODE_MECA
elif DEPL_IMPO is not None:
mostcles['CHAM_NO'] = DEPL_IMPO
elif MODELE_GENE is not None:
mostcles['MODELE_GENE'] = MODELE_GENE
mostcles['AVEC_MODE_STAT'] = AVEC_MODE_STAT
mostcles['DIST_REFE'] = DIST_REFE
if NOEUD_DOUBLE is not None:
mostcles['NOEUD_DOUBLE'] = NOEUD_DOUBLE
MASSAJ = CALC_MATR_AJOU(MODELE_FLUIDE=__NOMFLU,
MODELE_INTERFACE=__NOMINT,
CHARGE=__CHARGE,
CHAM_MATER=__NOMCMA,
OPTION='MASS_AJOU',
SOLVEUR=solveur,
**mostcles)
self.register_result(MASSAJ, MATR_MASS_AJOU)
# ---------------------------------------------------------------
# calcul de l amortissement ajoute
if (MATR_AMOR_AJOU is not None) or (MATR_RIGI_AJOU is not None):
# ---------------------------------------------------------------
# on definit un nouveau modele fluide pour calculer
# le potentiel stationnaire - AFFE_MODELE
grma = [
GROUP_MA_FLUIDE,
]
if ECOULEMENT is not None:
grma.append(ECOULEMENT['GROUP_MA_1'])
grma.append(ECOULEMENT['GROUP_MA_2'])
if type(ECOULEMENT) not in (list, tuple):
ECOULEMENT = (ECOULEMENT, )
__NOFLUI = AFFE_MODELE(
MAILLAGE=MAILLAGE,
AFFE=_F(GROUP_MA=grma,
MODELISATION=MODELISATION,
PHENOMENE='THERMIQUE'),
)
affimp = []
for DDL in DDL_IMPO:
if DDL['PRES_SORTIE'] is not None:
if DDL['NOEUD'] is not None:
mfact = _F(NOEUD=DDL['NOEUD'], TEMP=DDL['PRES_SORTIE'])
if DDL['GROUP_NO'] is not None:
mfact = _F(GROUP_NO=DDL['GROUP_NO'],
TEMP=DDL['PRES_SORTIE'])
affimp.append(mfact)
affecl = []
for ECL in ECOULEMENT:
mfact = _F(GROUP_MA=ECL['GROUP_MA_1'], FLUN=ECL['VNOR_1'])
affecl.append(mfact)
mfact = _F(GROUP_MA=ECL['GROUP_MA_2'], FLUN=ECL['VNOR_2'])
affecl.append(mfact)
__CHARG2 = AFFE_CHAR_THER(MODELE=__NOFLUI,
TEMP_IMPO=affimp,
FLUX_REP=affecl)
__POTEN = THER_LINEAIRE(MODELE=__NOFLUI,
CHAM_MATER=__NOMCMA,
EXCIT=_F(CHARGE=__CHARG2))
# ---------------------------------------------------------------
# calcul amortissement proprement dit
if MATR_AMOR_AJOU is not None:
solveur = SOLVEUR[0].cree_dict_valeurs(SOLVEUR[0].mc_liste)
mostcles = {}
if NUME_DDL_GENE is not None:
mostcles['NUME_DDL_GENE'] = NUME_DDL_GENE
if INFO is not None:
mostcles['INFO'] = INFO
if MODE_MECA is not None:
mostcles['MODE_MECA'] = MODE_MECA
elif DEPL_IMPO is not None:
mostcles['CHAM_NO'] = DEPL_IMPO
else:
UTMESS('F', 'MATRICE0_3')
AMORAJ = CALC_MATR_AJOU(MODELE_FLUIDE=__NOMFLU,
MODELE_INTERFACE=__NOMINT,
CHARGE=__CHARGE,
CHAM_MATER=__NOMCMA,
OPTION='AMOR_AJOU',
SOLVEUR=solveur,
POTENTIEL=__POTEN,
**mostcles)
self.register_result(AMORAJ, MATR_AMOR_AJOU)
# ---------------------------------------------------------------
# calcul de la rigidite ajoutee
if MATR_RIGI_AJOU is not None:
solveur = SOLVEUR[0].cree_dict_valeurs(SOLVEUR[0].mc_liste)
mostcles = {}
if NUME_DDL_GENE is not None:
mostcles['NUME_DDL_GENE'] = NUME_DDL_GENE
if INFO is not None:
mostcles['INFO'] = INFO
if MODE_MECA is not None:
mostcles['MODE_MECA'] = MODE_MECA
elif DEPL_IMPO is not None:
mostcles['CHAM_NO'] = DEPL_IMPO
else:
UTMESS('F', 'MATRICE0_4')
RIGIAJ = CALC_MATR_AJOU(MODELE_FLUIDE=__NOMFLU,
MODELE_INTERFACE=__NOMINT,
CHARGE=__CHARGE,
CHAM_MATER=__NOMCMA,
OPTION='RIGI_AJOU',
SOLVEUR=solveur,
POTENTIEL=__POTEN,
**mostcles)
self.register_result(RIGIAJ, MATR_RIGI_AJOU)
# ---------------------------------------------------------------
# boucle sur le nombre de vecteurs a projeter, commande CALC_FORC_AJOU
if FORC_AJOU is not None:
for FORCAJ in FORC_AJOU:
solveur = SOLVEUR[0].cree_dict_valeurs(SOLVEUR[0].mc_liste)
mostcles = {}
if NUME_DDL_GENE is not None:
mostcles['NUME_DDL_GENE'] = NUME_DDL_GENE
if MODE_MECA is not None:
mostcles['MODE_MECA'] = MODE_MECA
elif MODELE_GENE is not None:
mostcles['MODELE_GENE'] = MODELE_GENE
mostcles['AVEC_MODE_STAT'] = AVEC_MODE_STAT
mostcles['DIST_REFE'] = DIST_REFE
if NOEUD_DOUBLE is not None:
mostcles['NOEUD_DOUBLE'] = NOEUD_DOUBLE
if MODE_STAT is not None:
mostcles['MODE_STAT'] = MODE_STAT
if FORCAJ['NOEUD'] is not None:
mostcles['NOEUD'] = FORCAJ['NOEUD']
if FORCAJ['GROUP_NO'] is not None:
mostcles['GROUP_NO'] = FORCAJ['GROUP_NO']
else:
mostcles['MONO_APPUI'] = MONO_APPUI
VECTAJ = CALC_FORC_AJOU(DIRECTION=FORCAJ['DIRECTION'],
MODELE_FLUIDE=__NOMFLU,
MODELE_INTERFACE=__NOMINT,
CHARGE=__CHARGE,
CHAM_MATER=__NOMCMA,
SOLVEUR=solveur,
**mostcles)
self.register_result(VECTAJ, FORCAJ['VECTEUR'])
return
def force_iss_vari(self, imod, MATR_GENE, NOM_CMP, ISSF, INFO, UNITE_RESU_FORC,
UNITE_RESU_IMPE, PRECISION, INTERF, MATR_COHE, TYPE, fini,
PAS, fmax):
"""Force sismique variable en ISS"""
#--------------------------------------------------------------------------------
NB_FREQ = 1 + int((fmax - fini) / PAS)
FREQ_INIT = fini
GROUP_NO_INTER = INTERF['GROUP_NO_INTERF']
# MAILLAGE NUME_DDL
resultat = MATR_GENE['BASE']
n_resultat = resultat.getName()
nume_ddl = resultat.getDOFNumbering()
nom_mail = nume_ddl.getMesh().getName()
# MODELE, DDLGENE
nume_ddlgene = MATR_GENE['NUME_DDL_GENE']
_, noe_interf = get_group_nom_coord(GROUP_NO_INTER, nom_mail)
# del nume_ddl, nom_mail, nom_modele
# MODES
_, nbmodd, _ = aster.dismoi('NB_MODES_DYN', n_resultat, 'RESULTAT', 'F')
_, nbmods, _ = aster.dismoi('NB_MODES_STA', n_resultat, 'RESULTAT', 'F')
_, nbmodt, _ = aster.dismoi('NB_MODES_TOT', n_resultat, 'RESULTAT', 'F')
FSIST = NP.zeros((NB_FREQ, nbmodt)) + 0j
nbno, _ = noe_interf.shape
if INFO == 2:
texte = 'NOMBRE DE MODES: ' + str(
nbmodt) + ' MODES DYNAMIQUES: ' + str(
nbmodd) + ' MODES STATIQUES: ' + str(nbmods)
aster.affiche('MESSAGE', texte)
aster.affiche('MESSAGE', 'COMPOSANTE ' + NOM_CMP)
aster.affiche('MESSAGE', 'NBNO INTERFACE : ' + str(nbno))
# ----- boucle sur les modes statiques
for mods in range(0, nbmods):
nmo = nbmodd + mods + 1
__CHAM = CREA_CHAMP(TYPE_CHAM='NOEU_DEPL_R',
OPERATION='EXTR',
NUME_ORDRE=nmo,
RESULTAT=resultat,
NOM_CHAM='DEPL')
MCMP2 = __CHAM.EXTR_COMP(' ', [GROUP_NO_INTER], 0).valeurs
if mods == 0:
NCMP2 = __CHAM.EXTR_COMP(' ', [GROUP_NO_INTER], topo=1).comp
nddi = len(MCMP2)
PHI = NP.zeros((nddi, nbmods))
PHI[:, mods] = MCMP2
PHIT = NP.transpose(PHI)
PPHI = NP.dot(PHIT, PHI)
# MODEL fonction de cohérence
MODEL = MATR_COHE['TYPE']
print('MODEL :', MODEL)
Data_Cohe = {}
Data_Cohe['TYPE'] = MODEL
Data_Cohe['MAILLAGE'] = nom_mail
Data_Cohe['GROUP_NO_INTERF'] = GROUP_NO_INTER
Data_Cohe['NOEUDS_INTERF'] = noe_interf
Data_Cohe['DIST'] = calc_dist2(noe_interf)
if MODEL == 'MITA_LUCO':
Data_Cohe['VITE_ONDE'] = MATR_COHE['VITE_ONDE']
Data_Cohe['PARA_ALPHA'] = MATR_COHE['PARA_ALPHA']
#---------------------------------------------------------------------
# BOUCLE SUR LES FREQUENCES
for k in range(NB_FREQ):
freqk = FREQ_INIT + PAS * k
if INFO == 2:
aster.affiche('MESSAGE', 'FREQUENCE DE CALCUL: ' + str(freqk))
COHE = CALC_COHE(freqk * 2. * pi, **Data_Cohe)
#---------------------------------------------------------
# On desactive temporairement les FPE qui pourraient etre generees (a tord!) par blas
aster_core.matfpe(-1)
eig, vec = linalg.eig(COHE)
vec = NP.transpose(vec) # les vecteurs sont en colonne dans numpy
aster_core.matfpe(1)
eig = eig.real
vec = vec.real
# on rearrange selon un ordre decroissant
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 = NP.sum(eig**2)
ener = 0.0
nbme = 0
while nbme < nbno:
ener = eig[nbme]**2 + ener
prec = ener / etot
nbme = nbme + 1
if INFO == 2:
aster.affiche(
'MESSAGE',
'VALEUR PROPRE ' + str(nbme) + ' : ' + str(eig[nbme - 1]))
if prec > PRECISION:
break
if INFO == 2:
aster.affiche('MESSAGE',
'NOMBRE DE MODES POD RETENUS : ' + str(nbme))
aster.affiche('MESSAGE',
'PRECISION (ENERGIE RETENUE) : ' + str(prec))
PVEC = NP.zeros((nbme, nbno))
for k1 in range(0, nbme):
PVEC[k1, 0:nbno] = NP.sqrt(eig[k1]) * vec[k1]
#----Impedances + force sismique.-----------------------------------------------------------------
if k > 0:
DETRUIRE(CONCEPT=_F(NOM=(__impe, __fosi)), INFO=1)
__impe = LIRE_IMPE_MISS(
BASE=resultat,
TYPE=TYPE,
NUME_DDL_GENE=nume_ddlgene,
UNITE_RESU_IMPE=UNITE_RESU_IMPE,
ISSF=ISSF,
FREQ_EXTR=freqk,
)
# on cree __fosi pour RECU_VECT_GENE_C plus loin
__fosi = LIRE_FORC_MISS(
BASE=resultat,
NUME_DDL_GENE=nume_ddlgene,
NOM_CMP=NOM_CMP,
NOM_CHAM='DEPL',
UNITE_RESU_FORC=UNITE_RESU_FORC,
ISSF=ISSF,
FREQ_EXTR=freqk,
)
# -------------- impedance--------------------------------
MIMPE = __impe.EXTR_MATR_GENE()
# extraction de la partie modes interface
KRS = MIMPE[nbmodd:nbmodt, nbmodd:nbmodt]
# -------------- force sismique-------------------------------
FSISM = __fosi.EXTR_VECT_GENE_C()
FS0 = FSISM[
nbmodd:nbmodt][:] # extraction de la partie modes interface
U0 = NP.dot(linalg.inv(KRS), FS0)
# projection pour obtenir UO en base physique
XI = NP.dot(PHI, U0)
XPI = XI
# # facteur de correction pour tous les modes (on somme) >> c'est faux
SI0 = 0.0
for k1 in range(0, nbme):
XOe = abs(NP.sum(PVEC[k1])) / nbno
SI0 = SI0 + XOe**2
SI = sqrt(SI0)
for idd in range(0, nddi): #nddi: nombre de ddl interface
if NCMP2[idd][0:2] == NOM_CMP:
XPI[idd] = SI * XI[idd]
# retour en base modale
QPI = NP.dot(PHIT, XPI)
U0 = NP.dot(linalg.inv(PPHI), QPI)
FS = NP.dot(KRS, U0)
FSISM[nbmodd:nbmodt][:] = FS
FSIST[k, nbmods:nbmodt] = FSISM[0:nbmodd][:]
FSIST[k, 0:nbmods] = FS
return FSIST
def impr_fonction_ops(self, FORMAT, COURBE, INFO, **args):
"""
Macro IMPR_FONCTION permettant d'imprimer dans un fichier des fonctions,
colonnes de table...
Erreurs<S> dans IMPR_FONCTION pour ne pas perdre la base.
"""
macro = 'IMPR_FONCTION'
import pprint
import aster
from code_aster.Cata.Syntax import _F
from code_aster.Cata.DataStructure import (nappe_sdaster, fonction_c,
formule, formule_c)
from Utilitai import Graph
from Utilitai.Utmess import UTMESS
from Utilitai.UniteAster import UniteAster
ier = 0
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
# On importe les definitions des commandes a utiliser dans la macro
# Le nom de la variable doit etre obligatoirement le nom de la commande
CALC_FONC_INTERP = self.get_cmd('CALC_FONC_INTERP')
DEFI_LIST_REEL = self.get_cmd('DEFI_LIST_REEL')
#----------------------------------------------
# 0. Traitement des arguments, initialisations
# unité logique des fichiers réservés
ul_reserve = (8, )
UL = UniteAster()
# 0.1. Fichier
nomfich = None
if args['UNITE'] and args['UNITE'] != 6:
nomfich = UL.Nom(args['UNITE'])
if INFO == 2:
aster.affiche('MESSAGE', ' Nom du fichier :' + nomfich)
if nomfich and os.path.exists(nomfich) and os.stat(nomfich).st_size != 0:
if FORMAT == 'XMGRACE':
niv = 'I'
else:
niv = 'I'
UTMESS(niv, 'FONCT0_1', valk=nomfich)
# 0.2. Récupération des valeurs sous COURBE
unparmi = ('FONCTION', 'LIST_RESU', 'FONC_X', 'ABSCISSE', 'NAPPE',
'NAPPE_LISSEE')
# i0 : indice du mot-clé facteur qui contient LIST_PARA, sinon i0=0
i0 = 0
Courbe = []
iocc = -1
for Ci in COURBE:
iocc += 1
dC = Ci.cree_dict_valeurs(Ci.mc_liste)
if dC.has_key('LIST_PARA') and dC['LIST_PARA'] != None and i0 == 0:
i0 = iocc
for mc in dC.keys():
if dC[mc] == None:
del dC[mc]
Courbe.append(dC)
if INFO == 2:
aster.affiche('MESSAGE',
' Nombre de fonctions à analyser : ' + str(len(Courbe)))
# 0.3. Devra-t-on interpoler globalement ?
# Dans ce cas, __linter est le LIST_PARA
# ou, à défaut, les abscisses de la première courbe
interp = False
if FORMAT == 'TABLEAU':
interp = True
dCi = Courbe[i0]
if dCi.has_key('LIST_PARA'):
__linter = dCi['LIST_PARA']
else:
obj = None
for typi in unparmi:
if dCi.has_key(typi):
obj = dCi[typi]
break
if obj == None:
UTMESS('S', 'SUPERVIS_56')
if typi == 'FONCTION' or typi == 'NAPPE' or typi == 'NAPPE_LISSEE':
if isinstance(obj, nappe_sdaster):
lpar, lval = obj.Valeurs()
linterp = lval[0][0]
else:
linterp = obj.Valeurs()[0]
elif typi == 'FONC_X':
lbid, linterp = obj.Valeurs()
elif typi == 'ABSCISSE':
linterp = obj
__linter = DEFI_LIST_REEL(VALE=linterp)
if INFO == 2:
aster.affiche('MESSAGE', ' Interpolation globale sur la liste :')
aster.affiche('MESSAGE', pprint.pformat(__linter.Valeurs()))
#----------------------------------------------
# 1. Récupération des valeurs des N courbes sous forme
# d'une liste de N listes
#----------------------------------------------
graph = Graph.Graph()
iocc = -1
for dCi in Courbe:
iocc += 1
# 1.1. Type d'objet à traiter
obj = None
for typi in unparmi:
if dCi.has_key(typi):
obj = dCi[typi]
break
if not dCi.has_key('LEGENDE') and hasattr(obj, 'get_name'):
dCi['LEGENDE'] = obj.get_name()
if obj == None:
UTMESS('S', 'SUPERVIS_56')
# 1.2. Extraction des valeurs
# 1.2.1. Mot-clé FONCTION
if typi == 'FONCTION' or typi == 'NAPPE' or typi == 'NAPPE_LISSEE':
# formule à un paramètre seulement
if isinstance(obj, formule):
dpar = obj.Parametres()
if len(dpar['NOM_PARA']) != 1:
UTMESS('S',
'FONCT0_50',
valk=obj.nom,
vali=len(dpar['NOM_PARA']))
if isinstance(obj, nappe_sdaster):
lpar, lval = obj.Valeurs()
dico, ldicf = obj.Parametres()
Leg = dCi['LEGENDE']
for i in range(len(lpar)):
p = lpar[i]
lx = lval[i][0]
ly = lval[i][1]
# sur quelle liste interpoler chaque fonction
if i == 0:
if interp:
__li = __linter
elif dCi.has_key('LIST_PARA'):
__li = dCi['LIST_PARA']
else:
__li = DEFI_LIST_REEL(VALE=lx)
# compléter les paramètres d'interpolation
dic = dico.copy()
dic.update(ldicf[i])
if (interp or dCi.has_key('LIST_PARA')) and i > 0:
try:
__ftmp = CALC_FONC_INTERP(FONCTION=obj,
VALE_PARA=p,
LIST_PARA_FONC=__li,
**dic)
pv, lv2 = __ftmp.Valeurs()
lx = lv2[0][0]
ly = lv2[0][1]
except aster.error, err:
# on verifie que la bonne exception a ete levee
assert err.id_message == "FONCT0_9", 'unexpected id : %s' % err.id_message
continue
# on stocke les données dans le Graph
nomresu = dic['NOM_RESU'].strip() + '_' + str(
len(graph.Legendes))
dicC = {
'Val': [lx, ly],
'Lab': [dic['NOM_PARA_FONC'], nomresu]
}
# ajoute la valeur du paramètre
dCi['LEGENDE'] = '%s %s=%g' % (Leg,
dic['NOM_PARA'].strip(), p)
if typi == 'NAPPE':
dCi['LEGENDE'] = '%s %s=%g' % (
Leg, dic['NOM_PARA'].strip(), p)
if typi == 'NAPPE_LISSEE':
dCi['LEGENDE'] = 'NAPPE_LISSEE %s %s=%g' % (
Leg, dic['NOM_PARA'].strip(), p)
Graph.AjoutParaCourbe(dicC, args=dCi)
graph.AjoutCourbe(**dicC)
else:
__ftmp = obj
dpar = __ftmp.Parametres()
# pour les formules à un paramètre (test plus haut)
if type(dpar['NOM_PARA']) in (list, tuple):
dpar['NOM_PARA'] = dpar['NOM_PARA'][0]
if interp:
try:
__ftmp = CALC_FONC_INTERP(FONCTION=obj,
LIST_PARA=__linter,
**dpar)
except aster.error, err:
# on verifie que la bonne exception a ete levee
assert err.id_message == "FONCT0_9", 'unexpected id : %s' % err.id_message
continue
elif dCi.has_key('LIST_PARA'):
try:
__ftmp = CALC_FONC_INTERP(FONCTION=obj,
LIST_PARA=dCi['LIST_PARA'],
**dpar)
except aster.error, err:
# on verifie que la bonne exception a ete levee
assert err.id_message == "FONCT0_9", 'unexpected id : %s' % err.id_message
continue
lx = obj
lr = dCi['ORDONNEE']
if len(lx) != len(lr):
UTMESS('S', 'FONCT0_7')
# on stocke les données dans le Graph
dicC = {'Val': [lx, lr], 'Lab': ['Absc', 'Ordo']}
Graph.AjoutParaCourbe(dicC, args=dCi)
graph.AjoutCourbe(**dicC)
# 1.3. dbg
if INFO == 2:
message = '\n' + '-' * 70 + \
'\n Contenu du Graph : \n' + '-' * 70 + '\n'
message = message + graph.__repr__()
message = message + '-' * 70 + '\n'
aster.affiche('MESSAGE', message)
#----------------------------------------------
# 2. Impression du 'tableau' de valeurs
#----------------------------------------------
# 2.0. Surcharge des propriétés du graphique et des axes
# (bloc quasiment identique dans Table)
if args['TITRE'] != None:
graph.Titre = args['TITRE']
if args['SOUS_TITRE'] != None:
graph.SousTitre = args['SOUS_TITRE']
if FORMAT in ('XMGRACE', 'AGRAF', 'LISS_ENVELOP'):
if args['BORNE_X'] != None:
graph.Min_X = args['BORNE_X'][0]
graph.Max_X = args['BORNE_X'][1]
