From: eficas <> Date: Tue, 7 Jun 2005 08:36:39 +0000 (+0000) Subject: *** empty log message *** X-Git-Tag: CC_param_poursuite~114 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=f6ef2beb9fca4cb9dac0375c75ccb719fbaaed45;p=modules%2Feficas.git *** empty log message *** --- diff --git a/Aster/Cata/Macro/__init__.py b/Aster/Cata/Macro/__init__.py deleted file mode 100644 index 4aebb58b..00000000 --- a/Aster/Cata/Macro/__init__.py +++ /dev/null @@ -1,21 +0,0 @@ -#@ MODIF __init__ Macro DATE 20/09/2004 AUTEUR DURAND C.DURAND -# -*- 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. -# -# -# ====================================================================== diff --git a/Aster/Cata/Macro/ajout_quad_gmsh.py b/Aster/Cata/Macro/ajout_quad_gmsh.py deleted file mode 100644 index e0d64393..00000000 --- a/Aster/Cata/Macro/ajout_quad_gmsh.py +++ /dev/null @@ -1,252 +0,0 @@ -#@ MODIF ajout_quad_gmsh Macro DATE 14/09/2004 AUTEUR MCOURTOI 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. -# ====================================================================== - - - -# script PYTHON de modification d'un fichier de maillage GMSH (*.msh) -# pour transformer les mailles lineiques en mailles quadratiques -# SEG2->SEG3 / TRIA3->TRIA6 / QUAD4->QUAD8, -# TETRA4 -> TETRA10 / PENTA6 -> PENTA15 / PYRAM5 -> PYRAM13 - -def ajout_quad_gmsh(texte): - - import os,sys,copy - - try: -# construction du dictionnaire nom du noeud / coordonnees : dict_no -# construction de la liste des noeuds : l_no - - typ_mail={} - typ_mail['LI']=['1'] - typ_mail['2D']=['2','3'] - typ_mail['3D']=['4','5','6','7'] - typ_mail['PO']=['15'] - - texte_eclate=texte.split('\n') - nbno=int(texte_eclate[texte_eclate.index('$NOD')+1]) - l_no=texte_eclate[texte_eclate.index('$NOD')+2:texte_eclate.index('$ENDNOD')] - dict_no={} - for i in texte_eclate[texte_eclate.index('$NOD')+2:texte_eclate.index('$ENDNOD')]: - cc=i.split(' ') - dict_no[cc[0]]=[] - for j in cc[1:]:dict_no[cc[0]].append(float(j)) - - l_el1=texte_eclate[texte_eclate.index('$ELM')+2:texte_eclate.index('$ENDELM')] - nbel =texte_eclate[texte_eclate.index('$ELM')+1] - - -# construction du dictionnaire : element / liste des aretes de l'element : elems_aretes -# et de son inverse : aretes / elements contenant cette arete : aretes_elems - - aretes_elems={} - elems_aretes={} - l_el=[] - for elem in l_el1 : - connec0=elem.split(' ')[5:] - while '' in connec0 : connec0.remove('') - aa=elem.split(' ')[:4] - -# attention : indicateur de type de maille : ajouter 7 pour passer -# de TRIA3 a TRIA6, de SEG2 a SEG3, de QUAD4 a QUAD8 (voir inigms.f) - -# si maille POI1, on ne fait rien - - if aa[1] not in typ_mail['PO'] : typel=str(int(aa[1])+7) - else : typel=aa[1] - nom_elem=aa[0]+' '+typel+' '+aa[2]+' '+aa[3] - segments=[] - -# traitement des mailles lineaires : un seul segment - if aa[1] in typ_mail['LI']: - segments.append([int(connec0[0]),int(connec0[1])]) - -# traitement des mailles planes (TRI3 QUA4) : on cree les segments en prenant les noeuds consecutivement, puis on ferme - elif aa[1] in typ_mail['2D']: - for i in range(len(connec0)-1) : segments.append([int(connec0[i]),int(connec0[i+1])]) - segments.append([int(connec0[-1]),int(connec0[0])]) - -# traitement des mailles TETRA4 : pour comprendre, voir "fonctions de forme des elements isoparametriques" R3.01.01 - elif aa[1]=='4': - for i in range(0,2) : segments.append([int(connec0[i]),int(connec0[i+1])]) - segments.append([int(connec0[2]),int(connec0[0])]) - for i in range(0,3) : segments.append([int(connec0[3]),int(connec0[i])]) - -# traitement des mailles HEXA8 : pour comprendre, voir "fonctions de forme des elements isoparametriques" R3.01.01 - elif aa[1]=='5': - for i in range(0,3) : segments.append([int(connec0[i]),int(connec0[i+1])]) - segments.append([int(connec0[3]),int(connec0[0])]) - for i in range(4,7) : segments.append([int(connec0[i]),int(connec0[i+1])]) - segments.append([int(connec0[7]),int(connec0[4])]) - for i in range(0,4) : segments.append([int(connec0[i]),int(connec0[i+4])]) - -# traitement des mailles PENTA6 : pour comprendre, voir "fonctions de forme des elements isoparametriques" R3.01.01 - elif aa[1]=='6': - for i in range(0,2) : segments.append([int(connec0[i]),int(connec0[i+1])]) - segments.append([int(connec0[2]),int(connec0[0])]) - for i in range(3,5) : segments.append([int(connec0[i]),int(connec0[i+1])]) - segments.append([int(connec0[5]),int(connec0[3])]) - for i in range(0,3) : segments.append([int(connec0[i]),int(connec0[i+3])]) - -# traitement des mailles PYRA5 : pour comprendre, voir "fonctions de forme des elements isoparametriques" R3.01.01 - elif aa[1]=='7': - for i in range(0,3) : segments.append([int(connec0[i]),int(connec0[i+1])]) - segments.append([int(connec0[3]),int(connec0[0])]) - for i in range(0,4) : segments.append([int(connec0[4]),int(connec0[i])]) - - elems_aretes[nom_elem]=[] - for seg in segments : - elems_aretes[nom_elem].append(copy.copy(seg)) - seg.sort() - for seg in segments : - if aretes_elems.has_key(tuple(seg)):aretes_elems[tuple(seg)].append(nom_elem) - else :aretes_elems[tuple(seg)]=[nom_elem] - l_el.append(nom_elem) - -# construction de la liste complete des aretes - - l_ar=aretes_elems.keys() - l_ar.sort() - -# numero du plus grand noeud : - nmax=int(l_no[-1].split(' ')[0]) - -# nouveau nombre total de noeuds : - ndtot=nbno+len(l_ar) - -# insertion des noeuds milieux dans le dictionnaire "aretes" et la liste "l_no" : - ind=nmax - for i in l_ar: - ind=ind+1 - x=(dict_no[str(i[0])][0]+dict_no[str(i[1])][0])/2 - y=(dict_no[str(i[0])][1]+dict_no[str(i[1])][1])/2 - z=(dict_no[str(i[0])][2]+dict_no[str(i[1])][2])/2 - l_no.append(str(ind)+' '+str(x)+' '+str(y)+' '+str(z)) - for elem in aretes_elems[i]: - for ar in elems_aretes[elem]: - k=copy.copy(ar) - k.sort() - kk=tuple(k) - if i==kk: - ar.insert(1,ind) - -# re-ecriture du fichier avec les noeuds milieux : - - resu='$NOD\n'+str(ndtot)+'\n' - for i in l_no: - resu=resu+i+'\n' - resu=resu+'$ENDNOD\n'+'$ELM\n'+nbel+'\n' - for i in l_el: - aa=i.split(' ')[:4] - if aa[1] not in typ_mail['PO']: - typ=str(int(aa[1])-7) - else : typ=aa[1] - if elems_aretes[i]!=[]: - resu=resu+i - -# traitement des mailles lineaires : d'abord les noeuds sommets, puis le noeud milieu - if typ in typ_mail['LI']: - resu=resu+' 3 ' - for j in elems_aretes[i]: - resu=resu+str(j[0])+' '+str(j[2])+' '+str(j[1])+' ' - -# traitement des mailles planes (TRI3 QUA4) : d'abord les noeuds sommets, puis, dans le meme ordre, les noeuds milieux - elif typ in typ_mail['2D']: - resu=resu+' '+str(len(elems_aretes[i])*2)+' ' - for j in elems_aretes[i]: - resu=resu+str(j[0])+' ' - for j in elems_aretes[i]: - resu=resu+str(j[1])+' ' - -# traitement des mailles TETRA4 : pour comprendre, voir "fonctions de forme des elements isoparametriques" R3.01.01 - elif typ=='4': - resu=resu+' 10 ' - for j in elems_aretes[i][:4]: - resu=resu+str(j[0])+' ' - resu=resu+str(elems_aretes[i][0][1])+' ' - resu=resu+str(elems_aretes[i][1][1])+' ' - resu=resu+str(elems_aretes[i][2][1])+' ' - resu=resu+str(elems_aretes[i][3][1])+' ' - resu=resu+str(elems_aretes[i][4][1])+' ' - resu=resu+str(elems_aretes[i][5][1])+' ' - -# traitement des mailles HEXA8 : pour comprendre, voir "fonctions de forme des elements isoparametriques" R3.01.01 - elif typ=='5': - resu=resu+' 20 ' - for j in elems_aretes[i][:8]: - resu=resu+str(j[0])+' ' - resu=resu+str(elems_aretes[i][0][1])+' ' - resu=resu+str(elems_aretes[i][1][1])+' ' - resu=resu+str(elems_aretes[i][2][1])+' ' - resu=resu+str(elems_aretes[i][3][1])+' ' - - resu=resu+str(elems_aretes[i][8][1])+' ' - resu=resu+str(elems_aretes[i][9][1])+' ' - resu=resu+str(elems_aretes[i][10][1])+' ' - resu=resu+str(elems_aretes[i][11][1])+' ' - - resu=resu+str(elems_aretes[i][4][1])+' ' - resu=resu+str(elems_aretes[i][5][1])+' ' - resu=resu+str(elems_aretes[i][6][1])+' ' - resu=resu+str(elems_aretes[i][7][1])+' ' - -# traitement des mailles PENTA6 : pour comprendre, voir "fonctions de forme des elements isoparametriques" R3.01.01 - elif typ=='6': - resu=resu+' 15 ' - for j in elems_aretes[i][:6]: - resu=resu+str(j[0])+' ' - resu=resu+str(elems_aretes[i][0][1])+' ' - resu=resu+str(elems_aretes[i][1][1])+' ' - resu=resu+str(elems_aretes[i][2][1])+' ' - - resu=resu+str(elems_aretes[i][6][1])+' ' - resu=resu+str(elems_aretes[i][7][1])+' ' - resu=resu+str(elems_aretes[i][8][1])+' ' - - resu=resu+str(elems_aretes[i][3][1])+' ' - resu=resu+str(elems_aretes[i][4][1])+' ' - resu=resu+str(elems_aretes[i][5][1])+' ' - -# traitement des mailles PYRA5 : pour comprendre, voir "fonctions de forme des elements isoparametriques" R3.01.01 - elif typ=='7': - resu=resu+' 13 ' - for j in elems_aretes[i][:4]: - resu=resu+str(j[0])+' ' - resu=resu+str(elems_aretes[i][0][1])+' ' - resu=resu+str(elems_aretes[i][1][1])+' ' - resu=resu+str(elems_aretes[i][2][1])+' ' - - resu=resu+str(elems_aretes[i][6][1])+' ' - resu=resu+str(elems_aretes[i][7][1])+' ' - resu=resu+str(elems_aretes[i][8][1])+' ' - - resu=resu+str(elems_aretes[i][3][1])+' ' - resu=resu+str(elems_aretes[i][4][1])+' ' - resu=resu+str(elems_aretes[i][5][1])+' ' - - else: -# traitement des mailles POI1 : on recopie la connectivite telle quelle, sans ajouter de nouveau noeud - resu=resu+l_el1[l_el.index(i)] - - resu=resu+'\n' - - resu=resu+'$ENDELM\n' - return resu - except : - return 0 diff --git a/Aster/Cata/Macro/calc_fonction_ops.py b/Aster/Cata/Macro/calc_fonction_ops.py deleted file mode 100644 index 8a2907bb..00000000 --- a/Aster/Cata/Macro/calc_fonction_ops.py +++ /dev/null @@ -1,322 +0,0 @@ -#@ MODIF calc_fonction_ops Macro DATE 12/05/2005 AUTEUR DURAND C.DURAND -# -*- coding: iso-8859-1 -*- -# CONFIGURATION MANAGEMENT OF EDF VERSION -# ====================================================================== -# COPYRIGHT (C) 1991 - 2005 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 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,ASSE,CORR_ACCE,PUISSANCE,INVERSE, - NOM_PARA,NOM_RESU,INTERPOL,PROL_DROITE, - PROL_GAUCHE,NOM_PARA_FONC,INTERPOL_FONC,PROL_DROITE_FONC, - PROL_GAUCHE_FONC,**args): - """ - Ecriture de la macro CALC_FONCTION - """ - ier=0 - import types - import string - import copy - from math import pi - from Utilitai.t_fonction import t_fonction,t_fonction_c,t_nappe - 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 - - ### On importe les definitions des commandes a utiliser dans la macro - DEFI_FONCTION = self.get_cmd('DEFI_FONCTION') - DEFI_NAPPE = self.get_cmd('DEFI_NAPPE') - - ### Comptage commandes + déclaration concept sortant - self.set_icmd(1) - self.DeclareOut('C_out',self.sd) - - ### type de traitement - ### - if (INTEGRE != None): - __ff=INTEGRE['FONCTION'].convert() - if INTEGRE['METHODE']=='TRAPEZE' : __ex=__ff.trapeze(INTEGRE['COEF']) - if INTEGRE['METHODE']=='SIMPSON' : __ex=__ff.simpson(INTEGRE['COEF']) - ### - if (DERIVE != None): - __ff=DERIVE['FONCTION'].convert() - __ex=__ff.derive() - ### - if (INVERSE != None): - __ff=INVERSE['FONCTION'].convert() - __ex=__ff.inverse() - ### - if (ABS != None): - __ff=ABS['FONCTION'].convert() - __ex=__ff.abs() - ### - if (COMPOSE != None): - __ff=COMPOSE['FONC_RESU'].convert() - __fg=COMPOSE['FONC_PARA'].convert() - __ex=__ff[__fg] - ### - if (ASSE != None): - __f0=ASSE['FONCTION'][0].convert() - __f1=ASSE['FONCTION'][1].convert() - __ex=__f0.cat(__f1,ASSE['SURCHARGE']) - ### - if (COMB != None): - if args['LIST_PARA']!=None : vale_x=args['LIST_PARA'].Valeurs() - else : - vale_x=[] - for mcfact in COMB : - vale_x=vale_x+mcfact['FONCTION'].Absc() - vale_x=dict([(i,0) for i in vale_x]).keys() - vale_x.sort() - list_fonc=[] - if isinstance(self.sd,nappe_sdaster): - for mcfact in COMB : - list_fonc.append(mcfact['FONCTION'].convert()) - list_fonch=[] - for f in list_fonc : - __ex=f - for g in list_fonc : - __ex=__ex.homo_support(g) - list_fonch.append(__ex) - list_fonc=list_fonch - elif isinstance(self.sd,fonction_sdaster): - for mcfact in COMB : - __ex=mcfact['FONCTION'].convert() - list_fonc.append(__ex.evalfonc(vale_x)) - - __ex=list_fonc[0] - __ex=__ex*COMB[0]['COEF'] - i=1 - for item in list_fonc[1:] : - item=item*COMB[i]['COEF'] - __ex=__ex+item - i=i+1 - ### - if (COMB_C != None): - if args['LIST_PARA']!=None : vale_x=args['LIST_PARA'].Valeurs() - else : - vale_x=[] - for mcfact in COMB_C : - vale_x=vale_x+mcfact['FONCTION'].Absc() - vale_x=dict([(i,0) for i in vale_x]).keys() - vale_x.sort() - list_fonc=[] - if isinstance(self.sd,nappe_sdaster): - for mcfact in COMB_C : - list_fonc.append(mcfact['FONCTION'].convert()) - list_fonch=[] - for f in list_fonc : - __ex=f - for g in list_fonc : - __ex=__ex.homo_support(g) - list_fonch.appen(__ex) - list_fonc=list_fonch - elif isinstance(self.sd,fonction_sdaster) or isinstance(self.sd,fonction_c): - for mcfact in COMB_C : - __ex=mcfact['FONCTION'].convert(arg='complex') - list_fonc.append(__ex.evalfonc(vale_x)) - - __ex=list_fonc[0] - if COMB_C[0]['COEF_R']!=None: __ex=__ex*complex(COMB_C[0]['COEF_R']) - if COMB_C[0]['COEF_C']!=None: __ex=__ex*tocomplex(COMB_C[0]['COEF_C']) - i=1 - for item in list_fonc[1:] : - if COMB_C[i]['COEF_R']!=None: coef=complex(COMB_C[i]['COEF_R']) - if COMB_C[i]['COEF_C']!=None: coef=tocomplex(COMB_C[i]['COEF_C']) - item=item*coef - __ex=__ex+item - i=i+1 - ### - if (PUISSANCE != None): - __ff=PUISSANCE['FONCTION'].convert() - __ex=__ff - for i in range(PUISSANCE['EXPOSANT']-1) : __ex=__ex*__ff - ### - if (EXTRACTION != None): - if EXTRACTION['PARTIE']=='REEL' : __ex=EXTRACTION['FONCTION'].convert(arg='real') - if EXTRACTION['PARTIE']=='IMAG' : __ex=EXTRACTION['FONCTION'].convert(arg='imag') - if EXTRACTION['PARTIE']=='MODULE' : __ex=EXTRACTION['FONCTION'].convert(arg='modul') - if EXTRACTION['PARTIE']=='PHASE' : __ex=EXTRACTION['FONCTION'].convert(arg='phase') - ### - if (ENVELOPPE != None): - list_fonc=[] - if isinstance(self.sd,nappe_sdaster): - for f in ENVELOPPE['FONCTION'] : list_fonc.append(f.convert()) - list_fonch=[] - for f in list_fonc : - __ff=f - for g in list_fonc : - __ff=__ff.homo_support(g) - list_fonch.append(__ff) - list_fonc=list_fonch - vale_para=list_fonc[0].vale_para - para =list_fonc[0].para - l_fonc_f =[] - for i in range(len(vale_para)): - __ff=list_fonc[0].l_fonc[i] - if ENVELOPPE['CRITERE']=='SUP' : - for f in list_fonc[1:] : __ff=__ff.sup(f.l_fonc[i]) - if ENVELOPPE['CRITERE']=='INF' : - for f in list_fonc[1:] : __ff=__ff.inf(f.l_fonc[i]) - l_fonc_f.append(__ff) - __ex=t_nappe(vale_para,l_fonc_f,para) - elif isinstance(self.sd,fonction_sdaster): - for f in ENVELOPPE['FONCTION'] : list_fonc.append(f.convert()) - __ex=list_fonc[0] - if ENVELOPPE['CRITERE']=='SUP' : - for f in list_fonc[1:] : __ex=__ex.sup(f) - if ENVELOPPE['CRITERE']=='INF' : - for f in list_fonc[1:] : __ex=__ex.inf(f) - ### - if (CORR_ACCE != None): - __ex=CORR_ACCE['FONCTION'].convert() - para=copy.copy(__ex.para) - # suppression de la tendance de l accelero - __ex=__ex.suppr_tend() - # calcul de la vitesse - __ex=__ex.trapeze(0.) - # calcul de la tendance de la vitesse : y = a1*x +a0 - __ex=__ex.suppr_tend() - if CORR_ACCE['CORR_DEPL']=='OUI': - # suppression de la tendance deplacement - # calcul du deplacement : integration - __ex=__ex.trapeze(0.) - # calcul de la tendance du déplacement : y = a1*x +a0 - __ex=__ex.suppr_tend() - # regeneration de la vitesse : derivation - __ex=__ex.derive() - # regeneration de l accelero : derivation - __ex=__ex.derive() - __ex.para=para - ### - if (FFT != None): - if isinstance(self.sd,fonction_c): - __ff=FFT['FONCTION'].convert() - __ex=__ff.fft(FFT['METHODE']) - if isinstance(self.sd,fonction_sdaster): - __ff=FFT['FONCTION'].convert(arg='complex') - __ex=__ff.fft(FFT['METHODE'],FFT['SYME']) - ### - if (SPEC_OSCI != None): - if SPEC_OSCI['AMOR_REDUIT']==None : - l_amor=[0.02,0.05,0.1] - UTMESS('I','CALC_FONCTION',' : génération par défaut de 3 amortissements :'+str(l_amor)) - else : - if type(SPEC_OSCI['AMOR_REDUIT']) not in (types.ListType,types.TupleType): - l_amor=[SPEC_OSCI['AMOR_REDUIT'],] - else : l_amor= SPEC_OSCI['AMOR_REDUIT'] - if SPEC_OSCI['FREQ']==None and SPEC_OSCI['LIST_FREQ']==None: - l_freq=[] - for i in range(56) : l_freq.append( 0.2+0.050*i) - for i in range( 8) : l_freq.append( 3.0+0.075*i) - for i in range(14) : l_freq.append( 3.6+0.100*i) - for i in range(24) : l_freq.append( 5.0+0.125*i) - for i in range(28) : l_freq.append( 8.0+0.250*i) - for i in range( 6) : l_freq.append(15.0+0.500*i) - for i in range( 4) : l_freq.append(18.0+1.000*i) - for i in range(10) : l_freq.append(22.0+1.500*i) - texte=[] - for i in range(len(l_freq)/5) : - texte.append(' %f %f %f %f %f' %tuple(l_freq[i*5:i*5+5])) - UTMESS('I','CALC_FONCTION',' : génération par défaut de 150 fréquences :\n'+'\n'.join(texte)) - elif SPEC_OSCI['LIST_FREQ']!=None: - l_freq=SPEC_OSCI['LIST_FREQ'].Valeurs() - elif SPEC_OSCI['FREQ']!=None: - if type(SPEC_OSCI['FREQ']) not in (types.ListType,types.TupleType): - l_freq=[SPEC_OSCI['FREQ'],] - else : l_freq= SPEC_OSCI['FREQ'] - if abs(SPEC_OSCI['NORME'])<1.E-10 : - UTMESS('S','CALC_FONCTION',' : SPEC_OSCI, la norme ne peut etre nulle') - if SPEC_OSCI['NATURE_FONC']!='ACCE' : - UTMESS('S','CALC_FONCTION',' : SPEC_OSCI, le type de la fonction doit etre ACCE') - if SPEC_OSCI['METHODE']!='NIGAM' : - UTMESS('S','CALC_FONCTION',' : SPEC_OSCI, seule la méthode NIGAM est codée') - eps=1.e-6 - for amor in l_amor : - if amor>(1-eps) : - UTMESS('S','CALC_FONCTION',' : SPEC_OSCI, la méthode choisie '\ - 'suppose des amortissements sous-critiques, amor<1.') - - __ff=SPEC_OSCI['FONCTION'].convert() - - # appel à SPEC_OSCI - spectr = aster_fonctions.SPEC_OSCI(__ff.vale_x, __ff.vale_y, l_freq, l_amor) - - # construction de la nappe - vale_para = l_amor - para = { 'INTERPOL' : ['LIN','LOG'], - 'NOM_PARA_FONC' : 'FREQ', - 'NOM_PARA' : 'AMOR', - 'PROL_DROITE' : 'EXCLU', - 'PROL_GAUCHE' : 'EXCLU', - 'NOM_RESU' : SPEC_OSCI['NATURE'] } - para_fonc = { 'INTERPOL' : ['LOG','LOG'], - 'NOM_PARA' : 'FREQ', - 'PROL_DROITE' : 'CONSTANT', - 'PROL_GAUCHE' : 'EXCLU', - 'NOM_RESU' : SPEC_OSCI['NATURE'] } - if SPEC_OSCI['NATURE']=='DEPL' : ideb = 0 - elif SPEC_OSCI['NATURE']=='VITE' : ideb = 1 - else : ideb = 2 - l_fonc = [] - for iamor in range(len(l_amor)) : - l_fonc.append(t_fonction(l_freq,spectr[iamor,ideb,:]/SPEC_OSCI['NORME'],para_fonc)) - __ex=t_nappe(vale_para,l_fonc,para) - ### - if (LISS_ENVELOP!= None): return - - ### creation de la fonction produite par appel à DEFI_FONCTION - ### on récupère les paramètres issus du calcul de __ex - ### et on les surcharge par ceux imposés par l'utilisateur - - if isinstance(__ex,t_fonction) or isinstance(__ex,t_fonction_c): - para=__ex.para - if NOM_PARA !=None : para['NOM_PARA'] =NOM_PARA - if NOM_RESU !=None : para['NOM_RESU'] =NOM_RESU - if PROL_DROITE!=None : para['PROL_DROITE']=PROL_DROITE - if PROL_GAUCHE!=None : para['PROL_GAUCHE']=PROL_GAUCHE - if INTERPOL !=None : para['INTERPOL'] =INTERPOL - if isinstance(__ex,t_fonction_c): para['VALE_C'] = __ex.tabul() - elif isinstance(__ex,t_fonction) : para['VALE'] = __ex.tabul() - C_out=DEFI_FONCTION(**para) - elif isinstance(__ex,t_nappe): - def_fonc=[] - for f in __ex.l_fonc : - para=f.para - def_fonc.append(_F(VALE =f.tabul(), - INTERPOL =f.para['INTERPOL'], - PROL_DROITE=f.para['PROL_DROITE'], - PROL_GAUCHE=f.para['PROL_GAUCHE'],) - ) - para=__ex.para - if NOM_PARA !=None : para['NOM_PARA'] =NOM_PARA - if NOM_RESU !=None : para['NOM_RESU'] =NOM_RESU - if PROL_DROITE !=None : para['PROL_DROITE']=PROL_DROITE - if PROL_GAUCHE !=None : para['PROL_GAUCHE']=PROL_GAUCHE - if NOM_PARA_FONC !=None : para['NOM_PARA_FONC'] =INTERPOL - if INTERPOL_FONC !=None : para['INTERPOL'] =INTERPOL - C_out=DEFI_NAPPE(PARA=__ex.vale_para.tolist(),DEFI_FONCTION=def_fonc,**para) - return ier - diff --git a/Aster/Cata/Macro/calc_precont_ops.py b/Aster/Cata/Macro/calc_precont_ops.py deleted file mode 100644 index a012dfb5..00000000 --- a/Aster/Cata/Macro/calc_precont_ops.py +++ /dev/null @@ -1,468 +0,0 @@ -#@ MODIF calc_precont_ops Macro DATE 07/03/2005 AUTEUR DURAND C.DURAND -# -*- coding: iso-8859-1 -*- -# CONFIGURATION MANAGEMENT OF EDF VERSION -# ====================================================================== -# COPYRIGHT (C) 1991 - 2003 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 ASSIRE A.ASSIRE - -def calc_precont_ops(self,reuse,MODELE,CHAM_MATER,CARA_ELEM,EXCIT, - CABLE_BP,CABLE_BP_INACTIF, - COMP_INCR,ETAT_INIT,NEWTON,RECH_LINEAIRE, - CONVERGENCE,INCREMENT,SOLVEUR,SOLV_NON_LOCAL, - LAGR_NON_LOCAL,PARM_THETA,INFO,TITRE,**args): - - - """ - Ecriture de la macro CALC_PRECONT - """ - import copy - import aster - import string - import types - from Accas import _F - from Noyau.N_utils import AsType - ier=0 - - # On importe les definitions des commandes a utiliser dans la macro - AFFE_MODELE = self.get_cmd('AFFE_MODELE') - CREA_CHAMP = self.get_cmd('CREA_CHAMP') - AFFE_CHAR_MECA = self.get_cmd('AFFE_CHAR_MECA') - DEFI_LIST_REEL = self.get_cmd('DEFI_LIST_REEL') - STAT_NON_LINE = self.get_cmd('STAT_NON_LINE') - CALC_NO = self.get_cmd('CALC_NO') - CREA_CHAMP = self.get_cmd('CREA_CHAMP') - DEFI_FONCTION = self.get_cmd('DEFI_FONCTION') - RECU_TABLE = self.get_cmd('RECU_TABLE') - DEFI_MATERIAU = self.get_cmd('DEFI_MATERIAU') - AFFE_MATERIAU = self.get_cmd('AFFE_MATERIAU') - - # La macro compte pour 1 dans la numerotation des commandes - self.icmd=1 - - # Le concept sortant (de type evol_noli) est nomme RES dans - # le contexte de la macro - - self.DeclareOut('RES',self.sd) - - # ------------------------------------------------------------- - # 1. CREATION DES MOTS-CLES ET CONCEPTS POUR LES STAT_NON_LINE - # ------------------------------------------------------------ - - - # 1.1 Recuperation de la liste d'instants, de l'instant initial et final - # Creation de la nouvelle liste d'instants - # ---------------------------------------------------------- - - dIncrement=INCREMENT[0].cree_dict_valeurs(INCREMENT[0].mc_liste) - - __prec = dIncrement['PRECISION'] - __L0 = dIncrement['LIST_INST'] - __L1 = __L0.Valeurs() - - # Traitement de l'etat initial - if ETAT_INIT: - dEtatInit=ETAT_INIT[0].cree_dict_valeurs(ETAT_INIT[0].mc_liste) - for i in dEtatInit.keys(): - if dEtatInit[i]==None : del dEtatInit[i] - - __EVINIT = dEtatInit['EVOL_NOLI'] - 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: - __TMIN = __L1[0] - else: - __dico = __EVINIT.LIST_VARI_ACCES() - __TMIN = __dico['INST'][-1] - else: - __TMIN = dIncrement['INST_INIT'] - - # Teste si INST_FIN est donné ou bien recalcule __TMAX - if dIncrement['INST_FIN'] == None: - __TMAX = __L1[-1] - else: - __TMAX = dIncrement['INST_FIN'] - - # Teste si INST_INIT est bien plus petit que INST_FIN - if __TMAX <= __TMIN: - ier=ier+1 - self.cr.fatal(""" ERREUR : INST_FIN PLUS PETIT QUE INST_INIT""") - return ier - - # Cree la liste d'instant __L2 allant de __TMIN a __TMAX et contenant - # un instant supplementaire __TINT - __L2=[] - for m in __L1: - if m>=__TMIN and m<=__TMAX: - __L2.append(m) - - __TINT = (9.*__L2[-1] + __L2[-2])/10. - __L2[-1:-1] = [__TINT] - - # __LST0 est la liste d'instants utilisée pour l'etape 1 - __LST0=DEFI_LIST_REEL( DEBUT = __TMIN, - INTERVALLE = _F(JUSQU_A = __TMAX, NOMBRE = 1),) - - # __LST et __FCT sont utilisés pour les etapes 2 et 3 - __LST=DEFI_LIST_REEL(VALE=__L2,); - __FCT=DEFI_FONCTION(INTERPOL=('LIN','LIN'), - NOM_PARA='INST', - VALE=(__TMIN,0.0,__TINT,1.0,__TMAX,1.0),); - - for i in dIncrement.keys(): - if dIncrement[i]==None : del dIncrement[i] - dIncrement['LIST_INST']= __LST - dIncrement['INST_FIN'] = __TINT - - - - # 1.2 Recuperation des parametres pour STAT_NON_LINE - # ------------------------------------------------------- - - dNewton=NEWTON[0].cree_dict_valeurs(NEWTON[0].mc_liste) - for i in dNewton.keys(): - if dNewton[i]==None : del dNewton[i] - - dConvergence=CONVERGENCE[0].cree_dict_valeurs(CONVERGENCE[0].mc_liste) - for i in dConvergence.keys(): - if dConvergence[i]==None : del dConvergence[i] - - dSolveur=SOLVEUR[0].cree_dict_valeurs(SOLVEUR[0].mc_liste) - for i in dSolveur.keys(): - if dSolveur[i]==None : del dSolveur[i] - - if RECH_LINEAIRE: - dRech_lin=RECH_LINEAIRE[0].cree_dict_valeurs(RECH_LINEAIRE[0].mc_liste) - for i in dRech_lin.keys(): - if dRech_lin[i]==None : del dRech_lin[i] - else : - dRech_lin=None - - if SOLV_NON_LOCAL: - dSolv_nonloc=SOLV_NON_LOCAL[0].cree_dict_valeurs(SOLV_NON_LOCAL[0].mc_liste) - for i in dSolv_nonloc.keys(): - if dSolv_nonloc[i]==None : del dSolv_nonloc[i] - else : - dSolv_nonloc=None - - if LAGR_NON_LOCAL: - dLagr_nonloc=LAGR_NON_LOCAL[0].cree_dict_valeurs(LAGR_NON_LOCAL[0].mc_liste) - for i in dLagr_nonloc.keys(): - if dLagr_nonloc[i]==None : del dLagr_nonloc[i] - else : - dLagr_nonloc=None - - - - # 1.3 Creation des mots-cles pour les 3 AFFE_CHAR_MECA - # Recuperation des cables dans les concepts CABLE_BP - # et CABLE_BP_INACTIF - # ------------------------------------------------------ - if type(CABLE_BP) is not types.NoneType: - if type(CABLE_BP) is not types.TupleType: - CABLE_BP0 = CABLE_BP - CABLE_BP = [] - CABLE_BP.append ( CABLE_BP0 ) - - if type(CABLE_BP_INACTIF) is not types.NoneType: - if type(CABLE_BP_INACTIF) is not types.TupleType: - CABLE_BP_INACTIF0 = CABLE_BP_INACTIF - CABLE_BP_INACTIF = [] - CABLE_BP_INACTIF.append ( CABLE_BP_INACTIF0 ) - - motscles={} - motscles['RELA_CINE_BP']=[] - motscle2={} - motscle2['RELA_CINE_BP']=[] - motscle3={} - motscle3['RELA_CINE_BP']=[] - __GROUP_MA_A=[] - Result = [[None]*1] - for mcabl in CABLE_BP: - # Creation de mots-cles pour les AFFE_CHAR_MECA - motscles['RELA_CINE_BP'].append(_F(CABLE_BP=mcabl, - SIGM_BPEL = 'OUI', - RELA_CINE = 'NON',) ) - motscle2['RELA_CINE_BP'].append(_F(CABLE_BP=mcabl, - SIGM_BPEL = 'NON', - RELA_CINE = 'OUI',) ) - motscle3['RELA_CINE_BP'].append(_F(CABLE_BP=mcabl, - SIGM_BPEL = 'OUI', - RELA_CINE = 'OUI',) ) - - # Creation de __GROUP_MA_A : liste des noms des cables contenus - # dans chaque concept CABLE_BP = cables a activer - __TCAB = RECU_TABLE(CO=mcabl,NOM_TABLE='CABLE_BP'); - __nb = 0 - while 1: - try: - Result[__nb][0] = __TCAB['NOM_CABLE',__nb+1] - __CAB = __TCAB['NOM_CABLE',__nb+1] - if __nb == 0: - __GROUP_MA_A.append(__CAB) - else: - i = 0 - # enlève les doublons - for m in __GROUP_MA_A: - i=i+1 - if __CAB == m: - break - if i == len(__GROUP_MA_A): - __GROUP_MA_A.append(__CAB) - - __nb = __nb + 1 - Result.append([None]*1) - # Si on a lu toutes les valeurs alors on sort de la boucle - except KeyError: - break - - # Creation de __GROUP_MA_I : liste des noms des cables contenus - # dans chaque CABLE_BP_INACTIF - # __GROUP_MA_CABLE = liste des cables actifs et inactifs - Result = [[None]*1] - __GROUP_MA_I=[] - - if CABLE_BP_INACTIF: - for mcabl in CABLE_BP_INACTIF: - __TCA0 = RECU_TABLE(CO=mcabl,NOM_TABLE='CABLE_BP'); - __nb = 0 - while 1: - try: - Result[__nb][0] = __TCA0['NOM_CABLE',__nb+1] - __CA0 = __TCA0['NOM_CABLE',__nb+1] - if __nb == 0: - __GROUP_MA_I.append(__CA0) - else: - i = 0 - # enlève les doublons - for m in __GROUP_MA_I: - i=i+1 - if __CA0 == m: - break - if i == len(__GROUP_MA_I): - __GROUP_MA_I.append(__CA0) - - __nb = __nb + 1 - Result.append([None]*1) - # Si on a lu toutes les valeurs alors on sort de la boucle - except KeyError: - break - motscle6={} - motscle6['RELA_CINE_BP']=[] - for mcabl in CABLE_BP_INACTIF: - # Creation de mots-cles pour les AFFE_CHAR_MECA - motscle6['RELA_CINE_BP'].append(_F(CABLE_BP=mcabl, - SIGM_BPEL = 'NON', - RELA_CINE = 'OUI',) ) - - __GROUP_MA_CABLES = __GROUP_MA_A + __GROUP_MA_I - - - # 1.4 Creation des mots-clés facteurs COMP_INCR - # pour étape 2 (dComp_incr0) et étape 3 (dComp_incr1) - # ------------------------------------------------------ - - dComp_incr=[] - for j in COMP_INCR : - dComp_incr.append(j.cree_dict_valeurs(j.mc_liste)) - for i in dComp_incr[-1].keys(): - if dComp_incr[-1][i]==None : del dComp_incr[-1][i] - - dComp_incr0=copy.copy(dComp_incr) - dComp_incr1=copy.copy(dComp_incr) - - dComp_incr0.append(_F(RELATION='SANS',GROUP_MA=__GROUP_MA_CABLES) ) - if __GROUP_MA_I: - dComp_incr1.append(_F(RELATION='SANS',GROUP_MA=__GROUP_MA_I) ) - - - # 1.5 Modele contenant uniquement les cables de precontrainte - # --------------------------------------------------------- - - __MOD = string.ljust(MODELE.nom,8) - __MOD =__MOD+'.MODELE .NOMA ' - __LMAIL = aster.getvectjev(__MOD) - __MAIL = string.strip(__LMAIL[0]) - - objma=self.get_sd_avant_etape(__MAIL,self) - - __M_CA=AFFE_MODELE( MAILLAGE=objma, - AFFE =_F( GROUP_MA = __GROUP_MA_A, - PHENOMENE = 'MECANIQUE', - MODELISATION = 'BARRE') ) - - - # 1.6 Blocage de tous les noeuds des cables actifs - # -------------------------------------------------- - - _B_CA=AFFE_CHAR_MECA(MODELE=__M_CA, - DDL_IMPO= _F( GROUP_MA = __GROUP_MA_A, - DX = 0., - DY = 0., - DZ = 0.),) - - - # 1.7 Chargements concernant les cables - # ------------------------------------- - _C_CN=AFFE_CHAR_MECA(MODELE=__M_CA,**motscles) - _C_CA=AFFE_CHAR_MECA(MODELE=MODELE,**motscle2) - _C_CT=AFFE_CHAR_MECA(MODELE=MODELE,**motscle3) - if CABLE_BP_INACTIF: - _C_CI=AFFE_CHAR_MECA(MODELE=MODELE,**motscle6) - - - - # ------------------------------------------------------------- - # 2. CALCULS - # ------------------------------------------------------------ - - - #------------------------------------------------------------------- - # 2.1 Premiere etape : calcul sur le(s) cable(s) et - # recuperation des _F_CAs aux noeuds - # on travaile entre tmin et tmax - #------------------------------------------------------------------- - - __EV1=STAT_NON_LINE( - MODELE = __M_CA, - CHAM_MATER = CHAM_MATER, - CARA_ELEM = CARA_ELEM, - EXCIT =(_F(CHARGE = _B_CA), - _F(CHARGE = _C_CN),), - COMP_INCR =_F( RELATION = 'ELAS', - DEFORMATION = 'PETIT', - TOUT = 'OUI'), - INCREMENT =_F(LIST_INST = __LST0, - PRECISION = __prec), - SOLVEUR = dSolveur, - PARM_THETA = PARM_THETA, - INFO =INFO, - TITRE = TITRE, ) - - __EV1 = CALC_NO( reuse = __EV1, - RESULTAT = __EV1, - GROUP_MA = __GROUP_MA_A, - OPTION = 'FORC_NODA' ) - - __REA = CREA_CHAMP ( - TYPE_CHAM = 'NOEU_DEPL_R', - OPERATION = 'EXTR', - RESULTAT = __EV1, - NOM_CHAM = 'FORC_NODA', - INST = __TMAX); - - __REAC = CREA_CHAMP (TYPE_CHAM='NOEU_DEPL_R', - OPERATION = 'ASSE', - MODELE = MODELE, - ASSE= _F(GROUP_MA=__GROUP_MA_A, - CHAM_GD=__REA, - COEF_R = -1.), ) - - _F_CA=AFFE_CHAR_MECA(MODELE=__M_CA, - VECT_ASSE = __REAC ) - - - - #----------------------------------------------------------------------- - # 2.2 Deuxieme etape : application de la precontrainte sur le beton - # en desactivant les cables - #----------------------------------------------------------------------- - - # Regeneration des mots-cles EXCIT passés en argument de la macro - dExcit=[] - for j in EXCIT : - dExcit.append(j.cree_dict_valeurs(j.mc_liste)) - for i in dExcit[-1].keys(): - if dExcit[-1][i]==None : del dExcit[-1][i] - - if CABLE_BP_INACTIF: - dExcit.append(_F(CHARGE=_C_CI),) - - # Creation du mots-cle EXCIT pour le STAT_NON_LINE - dExcit1=copy.copy(dExcit) - dExcit1.append(_F(CHARGE=_C_CA),) - dExcit1.append(_F(CHARGE = _F_CA, - FONC_MULT=__FCT ),) - - RES=STAT_NON_LINE( - MODELE =MODELE, - CARA_ELEM =CARA_ELEM, - CHAM_MATER = CHAM_MATER, - COMP_INCR=dComp_incr0, - INCREMENT=dIncrement, - ETAT_INIT = dEtatInit, - NEWTON =dNewton, - CONVERGENCE=dConvergence, - RECH_LINEAIRE = dRech_lin, - SOLVEUR = dSolveur, - SOLV_NON_LOCAL = dSolv_nonloc, - LAGR_NON_LOCAL = dLagr_nonloc, - ARCHIVAGE = _F(INST = __TINT), - PARM_THETA = PARM_THETA, - INFO =INFO, - TITRE = TITRE, - EXCIT = dExcit1, - ) - - # Recuperation du dernier numero d'ordre pour pouvoir l'écraser dans RES - __dico2 = RES.LIST_VARI_ACCES() - __no = __dico2['NUME_ORDRE'][-1] - - - #----------------------------------------------------------------------- - # 2.2 Troisieme etape : on remet la tension dans les cables - #----------------------------------------------------------------------- - - # Creation du mots-cles EXCIT pour le STAT_NON_LINE - dExcit2=copy.copy(dExcit) - dExcit2.append(_F(CHARGE=_C_CT,) ) - - # Calcul sur un seul pas (de __TINT a __TMAX) - RES=STAT_NON_LINE( reuse = RES, - ETAT_INIT = _F(EVOL_NOLI =RES), - MODELE = MODELE, - CHAM_MATER = CHAM_MATER, - CARA_ELEM = CARA_ELEM, - COMP_INCR=dComp_incr1, - INCREMENT=_F(LIST_INST = __LST, - PRECISION = __prec), - NEWTON =dNewton, - RECH_LINEAIRE = dRech_lin, - CONVERGENCE=dConvergence, - SOLVEUR = dSolveur, - SOLV_NON_LOCAL = dSolv_nonloc, - LAGR_NON_LOCAL = dLagr_nonloc, - ARCHIVAGE = _F(NUME_INIT = __no, - DETR_NUME_SUIV = 'OUI' ), - PARM_THETA = PARM_THETA, - INFO =INFO, - TITRE = TITRE, - EXCIT =dExcit2, - ) - - return ier - diff --git a/Aster/Cata/Macro/defi_cable_bp_ops.py b/Aster/Cata/Macro/defi_cable_bp_ops.py deleted file mode 100644 index 3d234d76..00000000 --- a/Aster/Cata/Macro/defi_cable_bp_ops.py +++ /dev/null @@ -1,313 +0,0 @@ -#@ MODIF defi_cable_bp_ops Macro DATE 14/09/2004 AUTEUR MCOURTOI M.COURTOIS -# -*- coding: iso-8859-1 -*- -# CONFIGURATION MANAGEMENT OF EDF VERSION -# ====================================================================== -# COPYRIGHT (C) 1991 - 2003 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 ASSIRE A.ASSIRE - -# =========================================================================== -# CORPS DE LA MACRO "DEFI_CABLE_BP" -# ------------------------------------- -# USAGE : -# Entrée : -# - MAILLAGE -# - MODELE -# - CABLE -# - CHAM_MATER -# - CARA_ELEM -# - GROUP_MA_BETON -# - DEFI_CABLE -# - TYPE_ANCRAGE -# - TENSION_INIT -# - RECUL_ANCRAGE -# - RELAXATION -# - CONE -# RAYON -# LONGUEUR -# PRESENT OUI ou NON deux fois -# - TITRE -# - INFO 1 / 2 -# -# =========================================================================== - - - -def defi_cable_bp_ops(self,MAILLAGE,MODELE,CHAM_MATER,CARA_ELEM,GROUP_MA_BETON, - DEFI_CABLE,TYPE_ANCRAGE,TENSION_INIT,RECUL_ANCRAGE, - RELAXATION,CONE,TITRE,INFO,**args): - - """ - Ecriture de la macro DEFI_CABLE_BP - """ - from Accas import _F - import aster,string - ier=0 - - # On importe les definitions des commandes a utiliser dans la macro - DEFI_GROUP = self.get_cmd('DEFI_GROUP') - IMPR_RESU = self.get_cmd('IMPR_RESU') - DEFI_CABLE_OP = self.get_cmd('DEFI_CABLE_OP') - RECU_TABLE = self.get_cmd('RECU_TABLE') - IMPR_TABLE = self.get_cmd('IMPR_TABLE') - IMPR_CO = self.get_cmd('IMPR_CO') - - # La macro compte pour 1 dans la numerotation des commandes - self.set_icmd(1) - - # Le concept sortant (de type char_meca) est nomme CHCABLE dans - # le contexte de la macro - - self.DeclareOut('__DC',self.sd) - - # ---------------------------------------------------------------------------- # - # Début de la Macro : - - motscles={} - - # RECUPERATION DES INFOS DONNEES PAR LE MOT-CLE "CONE" - - if CONE: - dCONE=CONE[0].cree_dict_valeurs(CONE[0].mc_liste) - for i in dCONE.keys(): - if dCONE[i]==None : del dCONE[i] - - RAYON = dCONE['RAYON'] - LONGUEUR = dCONE['LONGUEUR'] - - motscles['CONE']=[] - motscles['CONE'].append( dCONE ) - - - # VERIFICATION QUE LE MAILLAGE EST COHERENT AVEC LE MODELE - - __MAIL = aster.getvectjev( string.ljust(MODELE.nom,8) + '.MODELE .NOMA ' ) - if string.ljust(MAILLAGE.nom,8) != __MAIL[0] : - self.DeclareOut(MAILLAGE.nom,maillage) - print ' ' - print ' # ---------------------------------------------------------------------------' - print ' # DEFI_CABLE_BP - Erreur : LE CONCEPT MAILLAGE RENSEIGNE NE CORRESPOND' - print ' # PAS A CELUI UTILISE DANS LE MODELE !' - print ' # ',MAILLAGE.nom,' - ',__MAIL[0] - print ' # ---------------------------------------------------------------------------' - print ' ' - ier=ier+1 - self.cr.fatal(""" Erreur dans la macro""") - return ier - - - # DEFINITION DU NOM DES GROUP_NO - - __NOM = '_AN_' - __LGNO = MAILLAGE.LIST_GROUP_NO() - __LGN1 = [] - for i in __LGNO : - __LGN1.append( i[0][:len(__NOM)] ) - - __NB = __LGN1.count(__NOM) - -# FIN RECUPERATION DES INFOS DONNEES PAR LE MOT-CLE "CONE" - - - # RECUPERATION DES INFOS DONNEES PAR LE MOT-CLE "DEFI_CABLE" - - dDEFI_CABLE=[] - for j in DEFI_CABLE : - dDEFI_CABLE.append(j.cree_dict_valeurs(j.mc_liste)) - for i in dDEFI_CABLE[-1].keys(): - if dDEFI_CABLE[-1][i]==None : del dDEFI_CABLE[-1][i] - - - # BOUCLE SUR LES FACTEURS DU MOT-CLE "DEFI_CABLE" - - motscles['DEFI_CABLE']=[] - - for i in dDEFI_CABLE: - - # CAS OU L'ON A DEFINI LE MOT-CLE "CONE" - if CONE: - - # CREATION DU PREMIER TUNNEL - - if dCONE['PRESENT'][0] == 'OUI': - __NB = __NB + 1 - __NOM1 = __NOM + str( int(__NB) ) - - motscle2={} - motscle2['CREA_GROUP_NO']=[] - - if i.has_key('GROUP_MA') == 1: - __CAB = i['GROUP_MA'] - motscle2= {'CREA_GROUP_NO': [{'LONGUEUR': LONGUEUR, 'RAYON': RAYON, 'OPTION': 'TUNNEL', 'GROUP_MA': [ GROUP_MA_BETON, __CAB ], 'GROUP_MA_AXE': __CAB, 'NOM': __NOM1}]} - if i.has_key('MAILLE') == 1: - print ' ' - print ' # ---------------------------------------------------------------------------' - print ' # DEFI_CABLE_BP - Erreur : MAILLE INTERDIT - UTILISER GROUP_MA' - print ' # ---------------------------------------------------------------------------' - print ' ' - ier=ier+1 - self.cr.fatal(""" Erreur dans la macro""") - return ier - if i.has_key('GROUP_NO_ANCRAGE') == 1: - __PC1 = i['GROUP_NO_ANCRAGE'][0] - motscle2['CREA_GROUP_NO'][0]['GROUP_NO_ORIG'] = __PC1 - if i.has_key('NOEUD_ANCRAGE') == 1: - __PC1 = i['NOEUD_ANCRAGE'][0] - motscle2['CREA_GROUP_NO'][0]['NOEUD_ORIG'] = __PC1 - - - DEFI_GROUP( reuse=MAILLAGE, - MAILLAGE=MAILLAGE, - INFO=INFO, - ALARME='NON', - **motscle2 - ) ; - - # CREATION DU DEUXIEME TUNNEL - - if dCONE['PRESENT'][1] == 'OUI': - __NB = __NB + 1 - __NOM2 = __NOM + str( int(__NB) ) - - motscle2={} - motscle2['CREA_GROUP_NO']=[] - - if i.has_key('GROUP_MA') == 1: - __CAB = i['GROUP_MA'] - motscle2= {'CREA_GROUP_NO': [{'LONGUEUR': LONGUEUR, 'RAYON': RAYON, 'OPTION': 'TUNNEL', 'GROUP_MA': [ GROUP_MA_BETON, __CAB ], 'GROUP_MA_AXE': __CAB, 'NOM': __NOM2}]} - if i.has_key('MAILLE') == 1: - print ' ' - print ' # ---------------------------------------------------------------------------' - print ' # DEFI_CABLE_BP - Erreur : MAILLE INTERDIT - UTILISER GROUP_MA' - print ' # ---------------------------------------------------------------------------' - print ' ' - ier=ier+1 - self.cr.fatal(""" Erreur dans la macro""") - return ier - if i.has_key('GROUP_NO_ANCRAGE') == 1: - __PC1 = i['GROUP_NO_ANCRAGE'][1] - motscle2['CREA_GROUP_NO'][0]['GROUP_NO_ORIG'] = __PC1 - if i.has_key('NOEUD_ANCRAGE') == 1: - __PC1 = i['NOEUD_ANCRAGE'][1] - motscle2['CREA_GROUP_NO'][0]['NOEUD_ORIG'] = __PC1 - - DEFI_GROUP( reuse=MAILLAGE, - MAILLAGE=MAILLAGE, - INFO=INFO, - ALARME='NON', - **motscle2 - ) ; - - - # CREATION DES NOUVEAUX FACTEURS DU MOT-CLE "DEFI_CABLE" POUR DEFI_CABLE_BP - - if dCONE['PRESENT'][0] == 'OUI' and dCONE['PRESENT'][1] == 'OUI': - if i.has_key('GROUP_MA') == 1 and i.has_key('GROUP_NO_ANCRAGE') == 1: - motscles['DEFI_CABLE'].append( _F(GROUP_MA=i['GROUP_MA'], - GROUP_NO_ANCRAGE=i['GROUP_NO_ANCRAGE'], - GROUP_NO_FUT=( __NOM1,__NOM2, ), ), ) - if i.has_key('GROUP_MA') == 1 and i.has_key('NOEUD_ANCRAGE') == 1: - motscles['DEFI_CABLE'].append( _F(GROUP_MA=i['GROUP_MA'], - NOEUD_ANCRAGE=i['NOEUD_ANCRAGE'], - GROUP_NO_FUT=( __NOM1,__NOM2, ), ), ) - - if dCONE['PRESENT'][0] == 'OUI' and dCONE['PRESENT'][1] == 'NON': - if i.has_key('GROUP_MA') == 1 and i.has_key('GROUP_NO_ANCRAGE') == 1: - motscles['DEFI_CABLE'].append( _F(GROUP_MA=i['GROUP_MA'], - GROUP_NO_ANCRAGE=i['GROUP_NO_ANCRAGE'], - GROUP_NO_FUT=( __NOM1, ), ), ) - if i.has_key('GROUP_MA') == 1 and i.has_key('NOEUD_ANCRAGE') == 1: - motscles['DEFI_CABLE'].append( _F(GROUP_MA=i['GROUP_MA'], - NOEUD_ANCRAGE=i['NOEUD_ANCRAGE'], - GROUP_NO_FUT=( __NOM1, ), ), ) - - if dCONE['PRESENT'][0] == 'NON' and dCONE['PRESENT'][1] == 'OUI': - if i.has_key('GROUP_MA') == 1 and i.has_key('GROUP_NO_ANCRAGE') == 1: - motscles['DEFI_CABLE'].append( _F(GROUP_MA=i['GROUP_MA'], - GROUP_NO_ANCRAGE=i['GROUP_NO_ANCRAGE'], - GROUP_NO_FUT=( __NOM2, ), ), ) - if i.has_key('GROUP_MA') == 1 and i.has_key('NOEUD_ANCRAGE') == 1: - motscles['DEFI_CABLE'].append( _F(GROUP_MA=i['GROUP_MA'], - NOEUD_ANCRAGE=i['NOEUD_ANCRAGE'], - GROUP_NO_FUT=( __NOM2, ), ), ) - - if dCONE['PRESENT'][0] == 'NON' and dCONE['PRESENT'][1] == 'NON': - if i.has_key('GROUP_MA') == 1 and i.has_key('GROUP_NO_ANCRAGE') == 1: - motscles['DEFI_CABLE'].append( _F(GROUP_MA=i['GROUP_MA'], - GROUP_NO_ANCRAGE=i['GROUP_NO_ANCRAGE'], ), ) - if i.has_key('GROUP_MA') == 1 and i.has_key('NOEUD_ANCRAGE') == 1: - motscles['DEFI_CABLE'].append( _F(GROUP_MA=i['GROUP_MA'], - NOEUD_ANCRAGE=i['NOEUD_ANCRAGE'], ), ) - - - # CAS OU L'ON A PAS DEFINI LE MOT-CLE "CONE" - else: - if i.has_key('GROUP_MA') == 1 and i.has_key('GROUP_NO_ANCRAGE') == 1: - motscles['DEFI_CABLE'].append( _F(GROUP_MA=i['GROUP_MA'], - GROUP_NO_ANCRAGE=i['GROUP_NO_ANCRAGE'], ), ) - - if i.has_key('GROUP_MA') == 1 and i.has_key('NOEUD_ANCRAGE') == 1: - motscles['DEFI_CABLE'].append( _F(GROUP_MA=i['GROUP_MA'], - NOEUD_ANCRAGE=i['NOEUD_ANCRAGE'], ), ) - - if i.has_key('MAILLE') == 1 and i.has_key('GROUP_NO_ANCRAGE') == 1: - motscles['DEFI_CABLE'].append( _F(MAILLE=i['MAILLE'], - GROUP_NO_ANCRAGE=i['GROUP_NO_ANCRAGE'], ), ) - - if i.has_key('MAILLE') == 1 and i.has_key('NOEUD_ANCRAGE') == 1: - motscles['DEFI_CABLE'].append( _F(MAILLE=i['MAILLE'], - NOEUD_ANCRAGE=i['NOEUD_ANCRAGE'], ), ) - - -# FIN BOUCLE sur i in DEFI_CABLE - - - # LANCEMENT DE DEFI_CABLE_BP - - if RELAXATION: - dRelaxation=RELAXATION[0].cree_dict_valeurs(RELAXATION[0].mc_liste) - for i in dRelaxation.keys(): - if dRelaxation[i]==None : del dRelaxation[i] - - __DC=DEFI_CABLE_OP(MODELE=MODELE, - CHAM_MATER=CHAM_MATER, - CARA_ELEM=CARA_ELEM, - GROUP_MA_BETON=GROUP_MA_BETON, - TYPE_ANCRAGE=TYPE_ANCRAGE, - TENSION_INIT=TENSION_INIT, - RECUL_ANCRAGE=RECUL_ANCRAGE, - RELAXATION=dRelaxation, - INFO=INFO, - **motscles - ); - - else: - - __DC=DEFI_CABLE_OP(MODELE=MODELE, - CHAM_MATER=CHAM_MATER, - CARA_ELEM=CARA_ELEM, - GROUP_MA_BETON=GROUP_MA_BETON, - TYPE_ANCRAGE=TYPE_ANCRAGE, - TENSION_INIT=TENSION_INIT, - RECUL_ANCRAGE=RECUL_ANCRAGE, - INFO=INFO, - **motscles - ); - -# __TCAB = RECU_TABLE(CO=__DC,NOM_TABLE='CABLE_BP'); -# IMPR_TABLE(TABLE=__TCAB); - - return ier diff --git a/Aster/Cata/Macro/defi_part_feti_ops.py b/Aster/Cata/Macro/defi_part_feti_ops.py deleted file mode 100644 index bf46f881..00000000 --- a/Aster/Cata/Macro/defi_part_feti_ops.py +++ /dev/null @@ -1,182 +0,0 @@ -#@ MODIF defi_part_feti_ops Macro DATE 23/11/2004 AUTEUR ASSIRE A.ASSIRE -# -*- 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. -# ====================================================================== -# RESPONSABLE ASSIRE A.ASSIRE - - -# =========================================================================== -# CORPS DE LA MACRO "DEFI_PART_FETI" -# ------------------------------------- -# USAGE : -# MAILLAGE maillage a partitionner -# MODELE modele (facultatif) -# NB_PART nb de sous-domaines -# EXCIT liste des chargements -# METHODE PMETIS, KMETIS ou AUTRE -# LOGICIEL si AUTRE alors on attend un chemin complet vers executable -# NOM_GROUP_MA Un nom de base pour les group_ma contenant les SD -# INFO 1,2 -# -# =========================================================================== -# script PYTHON : appel a Metis et lancement de DEFI_PART_OPS - - -def defi_part_feti_ops(self,MAILLAGE,MODELE,NB_PART,EXCIT,METHODE,NOM_GROUP_MA,INFO,**args): - - import aster, string, sys - - from Accas import _F - from Noyau.N_utils import AsType - - from Utilitai import partition - - # DEBUT DE LA MACRO - ier=0 - - INCLUSE='NON' # On cree des GROUP_MA pour les mailles de bords (pour developpeur) - - # Nom des GROUP_MA générés - NOM_GROUP_MA = string.strip(NOM_GROUP_MA) - NOM_GROUP_MA_BORD = '_' + NOM_GROUP_MA - - # Test sur le nombre de caractères de NOM_GROUP_MA - if ( len(NOM_GROUP_MA)+len(str(NB_PART)) > 7 ): - print '\n\n ERREUR : Afin de pouvoir générer les GROUP_MA, réduisez le nombre \n de caractères de NOM_GROUP_MA à un maximum de :', 7-len(str(NB_PART)) - print '\n\n' - sys.exit(1) - - # Verification que des GROUP_MA ne portent pas deja les memes noms - _lst = [] - for i in MAILLAGE.LIST_GROUP_MA(): - _lst.append( string.strip(i[0]) ) - for i in range(NB_PART): - if ( NOM_GROUP_MA+str(i) in _lst ): - print '\n\n ERREUR : Il existe déjà un GROUP_MA nommé : ', NOM_GROUP_MA+str(i) - print '\n\n' - sys.exit(1) - if ( NOM_GROUP_MA_BORD+str(i) in _lst ): - print '\n\n ERREUR : Il existe déjà un GROUP_MA nommé : ', NOM_GROUP_MA_BORD+str(i) - print '\n\n' - sys.exit(1) - - # Executable du partitionneur - if METHODE=="AUTRE": - exe_metis = arg['LOGICIEL'] - else: - exe_metis = aster.repout() + string.lower(METHODE) - - # On importe les definitions des commandes a utiliser dans la macro - DEFI_PART_OPS = self.get_cmd('DEFI_PART_OPS') - INFO_EXEC_ASTER = self.get_cmd('INFO_EXEC_ASTER') - DEFI_FICHIER = self.get_cmd('DEFI_FICHIER') - DETRUIRE = self.get_cmd('DETRUIRE') - - # La macro compte pour 1 dans la numerotation des commandes - self.icmd=1 - - # Le concept sortant dans le contexte de la macro - self.DeclareOut('_SDFETI',self.sd) - - # Debut : - print """ - - # --------------------------------------------------------------------------- - # MACRO-COMMANDE : DEFI_PART_FETI - # ---------------- -""" - - # Objet Partition - _part = partition.PARTITION(jdc=self); - - # Recuperation de deux UL libres - _UL=INFO_EXEC_ASTER(LISTE_INFO='UNITE_LIBRE') - ul1=_UL['UNITE_LIBRE',1] - DETRUIRE(CONCEPT=(_F(NOM=_UL),), INFO=1) - DEFI_FICHIER(UNITE=ul1) - _UL=INFO_EXEC_ASTER(LISTE_INFO='UNITE_LIBRE') - ul2=_UL['UNITE_LIBRE',1] - DEFI_FICHIER(ACTION='LIBERER',UNITE=ul1) - - fichier_in = 'fort.' + str(ul1) - fichier_out = 'fort.' + str(ul2) - - # Options de la classe Partition - _part.OPTIONS['exe_metis'] = exe_metis - _part.OPTIONS['fichier_in'] = fichier_in - _part.OPTIONS['fichier_out'] = fichier_out - - - # Partitionnement - if MODELE: - _part.Partitionne_Aster( - MAILLAGE = MAILLAGE, - MODELE = MODELE, - NB_PART = NB_PART, - INFO = INFO, - ); - - elif MAILLAGE: - _part.Partitionne_Aster( - MAILLAGE = MAILLAGE, - NB_PART = NB_PART, - INFO = INFO, - ); - - - # Creation des group_ma dans le maillage Aster - _part.Creation_Group_ma_Aster_par_SD(NOM=NOM_GROUP_MA, NOM2=NOM_GROUP_MA_BORD, INCLUSE=INCLUSE) - - - # Creation de la SDFETI - if MODELE: - _tmp = [] - for i in range(NB_PART): - txt = { 'GROUP_MA': NOM_GROUP_MA + str(i) } - if ( NOM_GROUP_MA_BORD+str(i) in _part.ASTER['GROUP_MA_BORD'] ): - txt['GROUP_MA_BORD'] = NOM_GROUP_MA_BORD + str(i) - _tmp.append( txt ) - - motscle2= {'DEFI': _tmp } - - # Regeneration des mots-cles EXCIT passés en argument de la macro - if EXCIT: - dExcit=[] - for j in EXCIT : - dExcit.append(j.cree_dict_valeurs(j.mc_liste)) - for i in dExcit[-1].keys(): - if dExcit[-1][i]==None : del dExcit[-1][i] - motscle2['EXCIT']=dExcit - - _SDFETI=DEFI_PART_OPS(NOM='SDD', - MODELE=MODELE, - INFO=1, - **motscle2 - ); - else: - _SDFETI=None - - - # Fin : - print """ - - % FIN MACRO-COMMANDE: DEFI_PART_FETI - -""" - - return ier diff --git a/Aster/Cata/Macro/fiabilite_fichier.py b/Aster/Cata/Macro/fiabilite_fichier.py deleted file mode 100644 index 1462a5ec..00000000 --- a/Aster/Cata/Macro/fiabilite_fichier.py +++ /dev/null @@ -1,335 +0,0 @@ -#@ MODIF fiabilite_fichier Macro DATE 14/09/2004 AUTEUR MCOURTOI M.COURTOIS -# -*- 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. -# ====================================================================== -# RESPONSABLE GNICOLAS G.NICOLAS -# -class fiabilite_fichier : -# - """ Classe des fichiers de données des logiciels fiabilistes - Cette classe a été mise au point pour le couplage entre - Code_ASTER et MEFISTO, mais pourrait servir ailleurs. - """ -# -# -#==== -# 1. Le constructeur -#==== -# -# - def __init__ ( self, jdc, Rep_Calc_LOGICIEL_global, nomfic, info = 1 ) : -# -# jdc : le jeu de commandes en cours de traitement -# - self.jdc = jdc -# -# Rep_Calc_LOGICIEL_global : le répertoire d'exécution du logiciel de fiabilité -# - self.Rep_Calc_LOGICIEL_global = Rep_Calc_LOGICIEL_global -# -# nomfic : nom local du fichier à créer -# - self.nomfic = nomfic -# -# messages_erreur : messages d'erreur -# - self.messages_erreur = { 0 : "Tout va bien", - 1 : "==> Ce fichier est inconnu.", - 2 : "==> Ce type d'ouverture est inconnu.", - 10 : "==> Problème à l'ouverture.", - 11 : "==> Problème à la fermeture.", - 20 : "==> Problème à l'impression." } -# -# info : niveau d'information au sens ASTER -# - self.info = info -# -# ligne_sep : ligne de séparation -# - self.ligne_sep = "=========================================================" - self.ligne_commentaire = "#" + self.ligne_sep + "\n" -# - if info >= 2 : - print "Création du fichier : "+self.nomfic -# -#==== -# 2. Ouverture du fichier -#==== -# - def Ouvre_Fichier ( self, type_ouvr ) : -# -# 2.0. ==> Préalables -# - """ - Ouvre le fichier en lecture ou écriture. - 0 : tout s'est bien passé - 1 : on veut ouvrir en lecture un fichier qui n'existe pas - 2 : le mode d'ouverture est inconnu - 10 : impossible d'ouvrir - """ -# - import os -# -# 2.1. ==> Le nom global du fichier -# - self.nomfic_global = os.path.join(self.Rep_Calc_LOGICIEL_global,self.nomfic) -# -# 2.2. ==> Controles -# - erreur = 0 -# - if ( type_ouvr == "w" or type_ouvr == "r" ) : -# - if ( type_ouvr == "r" ) : - if not os.path.isfile(self.nomfic_global) : - erreur = 1 - - else : -# - self.jdc.cr.warn("Type d'ouverture : "+type_ouvr) - erreur = 2 -# -# 2.3. ==> Ouverture vraie -# - if not erreur : -# - erreur_partiel = [0] - try : - self.fic = open( self.nomfic_global, type_ouvr ) - except os.error,erreur_partiel : - self.jdc.cr.warn("Code d'erreur de open : " + str(erreur_partiel[0]) + " : " + erreur_partiel[1]) - erreur = 10 -# -# 2.4. ==> C'est fini -# - if erreur : - self.jdc.cr.warn("Fichier : "+self.nomfic) - self.jdc.cr.warn(self.messages_erreur[erreur]) -# - return erreur -# -#==== -# 3. Fermeture du fichier -#==== -# - def Ferme_Fichier ( self ) : -# -# 3.0. ==> Préalables -# - """ - Ferme le fichier. - 0 : tout s'est bien passé - 20 : impossible d'imprimer - """ -# - import os -# -# 3.1. ==> Controles -# - erreur = 0 -# - if not os.path.isfile(self.nomfic_global) : - erreur = 1 -# -# 3.2. ==> Fermeture vraie -# - if not erreur : -# - erreur_partiel = [0] - try : - self.fic.close( ) - except os.error,erreur_partiel : - self.jdc.cr.warn("Code d'erreur de close : " + str(erreur_partiel[0]) + " : " + erreur_partiel[1]) - erreur = 11 -# -# 3.3. ==> C'est fini -# - if erreur : - self.jdc.cr.warn("Fichier : "+self.nomfic) - self.jdc.cr.warn(self.messages_erreur[erreur]) -# - return erreur -# -#==== -# 4. Impression du contenu du fichier -#==== -# - def Imprime_Fichier ( self ) : -# -# 4.0. ==> Préalables -# - """ - Imprime le fichier. - 0 : tout s'est bien passé - 20 : impossible d'imprimer - """ -# -# 4.1. ==> Lecture -# - erreur = self.Ouvre_Fichier ( "r" ) - if not erreur : - les_lignes = self.fic.readlines() - erreur = self.Ferme_Fichier ( ) -# -# 4.2. ==> Impression -# - if not erreur : -# - print "\n"+self.ligne_sep - print "Contenu du fichier " + self.nomfic," :" - for ligne in les_lignes : - print ligne[:-1] - print self.ligne_sep+"\n" -# -# 4.4. ==> C'est fini -# - if erreur : - erreur = 20 - self.jdc.cr.warn("Fichier : "+self.nomfic) - self.jdc.cr.warn(self.messages_erreur[erreur]) -# - return erreur -# -#==== -# 5. Ecriture de lignes de commentaires -#==== -# - def Ecrit_Commentaires ( self, comm ) : -# - """ - Liste = commentaires à écrire - Soit c'est une chaine qu'on écrit sur une ligne ; - Soit c'est une liste, qu'on écrit à raison de une par ligne. - Remarque : cela suppose que le fichier est ouvert en écriture - """ -# - if type(comm) == type([ ]) : - Liste = comm - else : - Liste = [comm] -# - for ligne in Liste : - self.fic.write("# "+str(ligne)+"\n") -# -#==== -# 6. Ecriture de lignes de titres -#==== -# - def Ecrit_Titre ( self, comm ) : -# - """ - Liste = commentaires à écrire, encadrés par des séparateurs - Soit c'est une chaine qu'on écrit sur une ligne ; - Soit c'est une liste, qu'on écrit à raison de une par ligne. - Remarque : cela suppose que le fichier est ouvert en écriture - """ -# - self.fic.write(self.ligne_commentaire) - self.Ecrit_Commentaires(comm) - self.fic.write(self.ligne_commentaire) -# -#==== -# 7. Ecriture d'une ligne de valeurs -#==== -# - def Ecrit_Valeurs ( self, val ) : -# - """ - Liste = liste des valeurs à écrire, représenatn une ligne - Remarque : cela suppose que le fichier est ouvert en écriture - """ -# - if type(val) == type([ ]) : - ligne = " " - for aux in val : - ligne = ligne + " " + str(aux) - else : - ligne = str(val) -# - self.fic.write(ligne+"\n") -# -# -#======================================================================================= -#======================================================================================= - - -# -# -if __name__ == "__main__" : -# - import os - import sys - import tempfile -# -# 1. ==> Préalable -# - Rep_Calc_LOGICIEL_global = tempfile.mktemp() - os.mkdir(Rep_Calc_LOGICIEL_global) -# - jdc = None -# -# 2. ==> Création de la classe -# - nomfic = "dataGrad" - fic = fiabilite_fichier ( jdc, Rep_Calc_LOGICIEL_global , nomfic ) -# -# 3. ==> Ouverture du fichier -# - erreur = fic.Ouvre_Fichier ( "w" ) -# -# 4. ==> Remplissage du fichier -# - if not erreur : - aux = ["Titre 1", "Titre 2"] - fic.Ecrit_Titre (aux) - aux = ["Ligne 1", "Ligne 2"] - fic.Ecrit_Commentaires (aux) - aux = "Ligne en forme de chaine" - fic.Ecrit_Commentaires (aux) - aux = 1789.1792 - fic.Ecrit_Commentaires (aux) - aux = [1, 0.0] - fic.Ecrit_Valeurs (aux) - aux = 1958. - fic.Ecrit_Valeurs (aux) -# -# 5. ==> Fermeture du fichier -# - if not erreur : - erreur = fic.Ferme_Fichier ( ) -# -# 4. ==> Impression du fichier -# - if not erreur : - erreur = fic.Imprime_Fichier ( ) -# -# 4. ==> La fin -# - Liste = os.listdir(Rep_Calc_LOGICIEL_global) -# - for nomfic in Liste : - fic_total = os.path.join(Rep_Calc_LOGICIEL_global,nomfic) - os.chmod (fic_total,0755) - os.remove (fic_total) - os.rmdir (Rep_Calc_LOGICIEL_global) -# - if erreur : - mess = "Erreur " + str(erreur) - else : - mess = "Fin normale." - sys.exit(mess) diff --git a/Aster/Cata/Macro/fiabilite_mefisto.py b/Aster/Cata/Macro/fiabilite_mefisto.py deleted file mode 100644 index 3f820843..00000000 --- a/Aster/Cata/Macro/fiabilite_mefisto.py +++ /dev/null @@ -1,448 +0,0 @@ -#@ MODIF fiabilite_mefisto Macro DATE 14/09/2004 AUTEUR MCOURTOI M.COURTOIS -# -*- 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. -# ====================================================================== - - -# RESPONSABLE GNICOLAS G.NICOLAS -# -def fiabilite_mefisto ( self, Rep_Calc_LOGICIEL_global, - INFO, VERSION, - SEUIL, SEUIL_TYPE, - VARIABLE, - valeurs_lois, - **args ) : -# -# valeurs_lois est un dictionnaire indexé sur les variables. -# Chaque case, valeurs_lois[m], est un dictionnaire contenant : -# d["v_moy_physique"] = valeur moyenne physique -# d["v_moy_loi"] = valeur moyenne de la loi -# d["v_min_loi"] = valeur minimale de la loi -# d["v_max_loi"] = valeur maximale de la loi -# d["sigma_loi"] = ecart type de la loi -# -# args est le dictionnaire des arguments optionnels -# args.keys() est la liste des mots-clés -# args.keys()[0] est la premiere valeur de cette liste -# args.keys()[1:] est la liste des valeurs suivantes dans cette liste -# args.keys(mot_cle) représente le contenu de la variable mot_cle dans la macro appelante. -# - """ Ecriture des données spécifiques à MEFISTO. """ -# - from Macro import fiabilite_fichier - import os - import string -# -#____________________________________________________________________ -# -# 1. Préalables -#____________________________________________________________________ -# -# - messages_erreur = { 0 : "Tout va bien", - 1 : "Fichier inconnu.", - 2 : "Problème d'ouverture de fichier.", - 10 : "Problème d'ouverture de fichier.", - 11 : "Problème de fermeture de fichier.", - 20 : "Problème d'impression de fichier.", - 50 : "Donnée inacceptable.", - 100 : "Erreur." } -# - trad_oui_non = { "OUI" : 1, - "NON" : 0 } -# - erreur = 0 -# - while not erreur : -# -#____________________________________________________________________ -# -# 2. Les fichiers pour le logiciel de fiabilité -# Ils sont créés dans le répertoire d'exécution du logiciel de fiabilité, avec leurs noms officiels -#____________________________________________________________________ -# -# - fic_dataMenu = "dataMenu" - fic_dataStoch = "dataStoch" - fic_dataNum = "dataNum" - fic_dataGrad = "dataGrad" -# -#____________________________________________________________________ -# -# 3. Construction du fichier 'dataMenu' -#____________________________________________________________________ -# -# 3.1 ==> Ouverture du fichier -# - f_menu = fiabilite_fichier.fiabilite_fichier ( self, Rep_Calc_LOGICIEL_global, fic_dataMenu, INFO ) - erreur = f_menu.Ouvre_Fichier ( "w" ) - if erreur : - break -# -# 3.2 ==> Ecriture des données nécessaires -# - f_menu.Ecrit_Titre ("MENU DU PROGRAMME MEFISTO") - f_menu.Ecrit_Titre ("1 <=> OUI et 0 <=> NON (entiers)") -# - f_menu.Ecrit_Titre ("Recherche du point de conception") - aux = trad_oui_non[args["RECH_PT_CONCEPT"]] - f_menu.Ecrit_Valeurs (aux) -# - f_menu.Ecrit_Titre ("First Order Reliability Analyses") - aux = trad_oui_non[args["METHODE_FORM"]] - f_menu.Ecrit_Valeurs (aux) -# - f_menu.Ecrit_Titre ("Second Order Reliability Analyses") - aux = trad_oui_non[args["METHODE_SORM"]] - f_menu.Ecrit_Valeurs (aux) -# - f_menu.Ecrit_Titre ("Importance Sampling Analyses") - aux = trad_oui_non[args["TIRAGE_IMPORTANCE"]] - f_menu.Ecrit_Valeurs (aux) -# - f_menu.Ecrit_Titre ("Optimality Test (1) : Hessian Test") - aux = trad_oui_non[args["T_HESSIEN"]] - f_menu.Ecrit_Valeurs (aux) -# - f_menu.Ecrit_Titre ("Optimality Test (2) : Sphere Test") - aux = trad_oui_non[args["T_SPHERE"]] - f_menu.Ecrit_Valeurs (aux) -# - f_menu.Ecrit_Titre ("Optimality Test (3) : Strong Max Test") - aux = trad_oui_non[args["T_MAXIMUM_FORT"]] - f_menu.Ecrit_Valeurs (aux) -# - f_menu.Ecrit_Titre ("Experiment Plan") - aux = trad_oui_non[args["PLAN_EXPERIENCE"]] - f_menu.Ecrit_Valeurs (aux) -# - f_menu.Ecrit_Titre ("Polynomial Taylor Approximation (order 2)") - aux = trad_oui_non[args["POLYNOME_TAYLOR"]] - f_menu.Ecrit_Valeurs (aux) -# -# 3.3 ==> Fermeture du fichier -# - erreur = f_menu.Ferme_Fichier ( ) - if erreur : - break -# - if INFO >= 2 : - erreur = f_menu.Imprime_Fichier ( ) - if erreur : - break -# -#____________________________________________________________________ -# -# 4. Construction du fichier "dataStoch" -#____________________________________________________________________ -# -# 4.1 ==> Ouverture du fichier -# - f_stoch = fiabilite_fichier.fiabilite_fichier ( self, Rep_Calc_LOGICIEL_global, fic_dataStoch, INFO ) - erreur = f_stoch.Ouvre_Fichier ( "w" ) - if erreur : - break -# -# 4.2 ==> Nombre d'occurence de VARIABLE -# - nb_occu_variable = len(VARIABLE) -# -# 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") - f_stoch.Ecrit_Valeurs ( "aster_" + aux ) -# - aux = [ "Gradients evaluated by the code" ] - aux.append("1 : Au moins 1 ; 0 : aucun") - f_stoch.Ecrit_Titre (aux) - gradient = 0 - for m in VARIABLE : - if m["GRADIENT"] == "OUI" : gradient = 1 - f_stoch.Ecrit_Valeurs (gradient) -# - f_stoch.Ecrit_Titre ("Variates number") - f_stoch.Ecrit_Valeurs ( nb_occu_variable ) -# - aux = [ "Stochastic Variates" ] - aux.append("1: Uniforme (min, max)") - aux.append("2: Normal (mean, std dev)") - aux.append("3: LogNormal (mean, std dev, min)") - aux.append("4: Normal Truncated (mean, std dev, min, max)") - f_stoch.Ecrit_Titre (aux) -# - for m in VARIABLE : -# - d = valeurs_lois[m] - if m["LOI"] == "UNIFORME" : - f_stoch.Ecrit_Valeurs ( [ m["NOM"], 1 , d["v_min_loi"] , d["v_max_loi"] ] ) - elif m["LOI"] == "NORMALE" : - f_stoch.Ecrit_Valeurs ( [ m["NOM"], 2 , d["v_moy_loi"] , d["sigma_loi"] ] ) - elif m["LOI"] == "LOGNORMALE" : - f_stoch.Ecrit_Valeurs ( [ m["NOM"], 3 , d["v_moy_loi"] , d["sigma_loi"] , d["v_min_loi"] ] ) - elif m["LOI"] == "NORMALE_TRONQUEE" : - f_stoch.Ecrit_Valeurs ( [ m["NOM"], 4 , d["v_moy_loi"] , d["sigma_loi"] , d["v_min_loi"] , d["v_max_loi"] ] ) - else : - erreur = 50 -# - if erreur : - break -# - f_stoch.Ecrit_Titre ("Initial Points") - for m in VARIABLE : - if m["POINT_INI"] is None : - aux = valeurs_lois[m]["v_moy_physique"] - else : - aux = m["POINT_INI"] - f_stoch.Ecrit_Valeurs ( aux ) -# - f_stoch.Ecrit_Titre ("Reference Points") - for m in VARIABLE : - if m["POINT_REF"] is None : - aux = valeurs_lois[m]["v_moy_physique"] - else : - aux = m["POINT_REF"] - f_stoch.Ecrit_Valeurs ( aux ) -# - f_stoch.Ecrit_Titre ("Design Points") - for m in VARIABLE : - if args["RECH_PT_CONCEPT"] == "OUI" : - aux = 1792. - elif m["POINT_CONCEPT"] is None : - aux = valeurs_lois[m]["v_moy_physique"] - else : - aux = m["POINT_CONCEPT"] - f_stoch.Ecrit_Valeurs ( aux ) -# - f_stoch.Ecrit_Titre ("Correlation matrix fictive") - for m in range(nb_occu_variable) : - aux = [ ] - for n in range(nb_occu_variable) : - aux.append(args["MATRICE"][n + m*nb_occu_variable]) - f_stoch.Ecrit_Valeurs ( aux ) -# - f_stoch.Ecrit_Titre ("Parameter threshold value") - if SEUIL_TYPE == "MAXIMUM" : - aux = SEUIL - else : - aux = -SEUIL - f_stoch.Ecrit_Valeurs ( aux ) -# -# 4.4 ==> Fermeture du fichier -# - erreur = f_stoch.Ferme_Fichier ( ) - if erreur : - break -# - if INFO >= 2 : - erreur = f_stoch.Imprime_Fichier ( ) - if erreur : - break -# -#____________________________________________________________________ -# -# 5. Construction du fichier 'dataNum' -#____________________________________________________________________ -# -# 5.1 ==> Ouverture du fichier -# - f_num = fiabilite_fichier.fiabilite_fichier ( self, Rep_Calc_LOGICIEL_global, fic_dataNum, INFO ) - erreur = f_num.Ouvre_Fichier ( "w" ) - if erreur : - break -# -# 5.2 ==> Ecriture des données nécessaires -# - f_num.Ecrit_Titre ("Parameters : EpsU, EpsG, Tau, Omega, iterMax") - if args["RECH_PT_CONCEPT"] == "OUI" : - f_num.Ecrit_Valeurs (args["EPSILON_U"]) - f_num.Ecrit_Valeurs (args["EPSILON_G"]) - f_num.Ecrit_Valeurs (args["TAU"]) - f_num.Ecrit_Valeurs (args["OMEGA"]) - f_num.Ecrit_Valeurs (args["ITER_MAX"]) - else : - aux = 0.1848 - for k in range(5) : - f_num.Ecrit_Valeurs (aux) -# - f_num.Ecrit_Titre ("Parameters : hgrad, hhess") - f_num.Ecrit_Valeurs (args["HGRAD"]) - f_num.Ecrit_Valeurs (args["HHESS"]) -# - aux = [ "Parameter Optimality Test(sphere)" ] - aux.append("1: Parametric Method (Point Number in each direction)") - aux.append("2: Gaussian Method (Total Point Number)") - aux.append("3: Rejection Method (Total Point Number)") - f_num.Ecrit_Titre (aux) -# - if args["T_SPHERE"] == "OUI" : -# - if args["METHODE_TEST"] == "PARAMETRIQUE" : - aux1 = 1 - elif args["METHODE_TEST"] == "GAUSSIENNE" : - aux1 = 2 - elif args["METHODE_TEST"] == "REJECTION" : - aux1 = 3 - else : - self.cr.warn("METHODE DE TEST : "+args["METHODE_TEST"]) - erreur = 50 - break -# - aux2 = args["NB_POINT"] -# - else : -# -# remarque : il faut mettre une valeur plausible en aux1, sinon plantage violent ... - aux1 = 1 - aux2 = 1789 -# - f_num.Ecrit_Valeurs ( [ aux1 , aux2 ] ) -# - aux = [ "Parameters : alpha, beta" ] - aux.append("alpha: common net") - aux.append("beta: extreme net") - f_num.Ecrit_Titre (aux) - if args["PLAN_EXPERIENCE"] == "OUI" : - aux1 = args["ALPHA"] - aux2 = args["BETA"] - else : - aux1 = 1789.0 - aux2 = 1789.0 - f_num.Ecrit_Valeurs ( aux1 ) - f_num.Ecrit_Valeurs ( aux2 ) -# - f_num.Ecrit_Titre ("Parameters Strong Max Test : cosLim, dProb") - if args["T_MAXIMUM_FORT"] == "OUI" : - aux1 = args["COS_LIM"] - aux2 = args["DPROB"] - else : - aux1 = 0.1789 - aux2 = 0.1789 - f_num.Ecrit_Valeurs ( aux1 ) - f_num.Ecrit_Valeurs ( aux2 ) -# - f_num.Ecrit_Titre ("Parameter Importance Samplings : Simulation Number") - if args["TIRAGE_IMPORTANCE"] == "OUI" : - aux = args["NB_SIMULATION"] - else : - aux = 1945 - f_num.Ecrit_Valeurs ( aux ) -# -# 5.3 ==> Fermeture du fichier -# - erreur = f_num.Ferme_Fichier ( ) - if erreur : - break -# - if INFO >= 2 : - erreur = f_num.Imprime_Fichier ( ) - if erreur : - break -# -#____________________________________________________________________ -# -# 6. Construction du fichier 'dataGrad' -#____________________________________________________________________ -# -# 6.1 ==> Création du fichier -# - f_grad = fiabilite_fichier.fiabilite_fichier ( self, Rep_Calc_LOGICIEL_global, fic_dataGrad, INFO ) - erreur = f_grad.Ouvre_Fichier ( "w" ) - if erreur : - break -# -# 6.2 ==> Ecriture des données nécessaires -# - f_grad.Ecrit_Titre ("Commentaires") -# - for m in VARIABLE : - f_grad.Ecrit_Commentaires (m["NOM"]) - if m["GRADIENT"] == "OUI" : - gradient = 1 - increment = 0.0 - else : - gradient = 0 - increment = m["INCREMENT"] - aux = [gradient,increment] - f_grad.Ecrit_Valeurs (aux) -# -# 6.3 ==> Fermeture du fichier -# - erreur = f_grad.Ferme_Fichier ( ) - if erreur : - break -# - if INFO >= 2 : - erreur = f_grad.Imprime_Fichier ( ) - if erreur : - break -# -#____________________________________________________________________ -# -# 7. C'est fini ! -#____________________________________________________________________ -# - break -# - if erreur : - if not messages_erreur.has_key(erreur) : - erreur = 100 - self.cr.warn(messages_erreur[erreur]) - erreur = 11 -# - return erreur -# -########################## Fin de la fonction################################## -# -########################## Auto-test################################## -# -if __name__ == "__main__" : -# - import os - import sys - import tempfile -# - Rep_Calc_LOGICIEL_global = tempfile.mktemp() - os.mkdir(Rep_Calc_LOGICIEL_global) -# - INFO = 2 - VERSION = "V3_2" - SEUIL = 1789. - SEUIL_TYPE = "MAXIMUM" - VARIABLE = [] - args = {} - valeurs = {} -# - erreur = fiabilite_mefisto ( None, Rep_Calc_LOGICIEL_global, - INFO, VERSION, - SEUIL, SEUIL_TYPE, - VARIABLE, - valeurs, - **args ) -### print "Erreur = ", erreur - Liste = os.listdir(Rep_Calc_LOGICIEL_global) -# - for nomfic in Liste : - fic_total = os.path.join(Rep_Calc_LOGICIEL_global,nomfic) - os.chmod (fic_total,0755) - os.remove (fic_total) - os.rmdir (Rep_Calc_LOGICIEL_global) -# - sys.exit("blabla") diff --git a/Aster/Cata/Macro/impr_fonction_ops.py b/Aster/Cata/Macro/impr_fonction_ops.py deleted file mode 100644 index 1e9d6e49..00000000 --- a/Aster/Cata/Macro/impr_fonction_ops.py +++ /dev/null @@ -1,400 +0,0 @@ -#@ MODIF impr_fonction_ops Macro DATE 11/05/2005 AUTEUR MCOURTOI M.COURTOIS -# -*- 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. -# ====================================================================== - -# RESPONSABLE MCOURTOI M.COURTOIS - -import os.path - -# ------------------------------------------------------------------------------ -def impr_fonction_ops(self, FORMAT, COURBE, INFO, **args): - """ - Macro IMPR_FONCTION permettant d'imprimer dans un fichier des fonctions, - colonnes de table... - Erreurs dans IMPR_FONCTION pour ne pas perdre la base. - """ - macro='IMPR_FONCTION' - import aster - from Accas import _F - 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') - DETRUIRE = self.get_cmd('DETRUIRE') - - #---------------------------------------------- - # 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: - print ' Nom du fichier :',nomfich - if nomfich and os.path.exists(nomfich) and os.stat(nomfich).st_size<>0: - if FORMAT=='XMGRACE': - niv='A' - else: - niv='I' - UTMESS(niv,macro,'Le fichier '+nomfich+' existe déjà, on écrit ' \ - 'à la suite.') - - # 0.2. Récupération des valeurs sous COURBE - unparmi=('FONCTION','LIST_RESU','FONC_X','ABSCISSE') - - # 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: - print ' Nombre de fonctions à analyser : ',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] - typ=obj.__class__.__name__ - break - if obj==None: - UTMESS('S',macro,'incohérence entre le catalogue et la macro.') - if typi=='FONCTION': - if typ=='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: - print ' Interpolation globale sur la liste :\n',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] - typ=obj.__class__.__name__ - break - if not dCi.has_key('LEGENDE') and hasattr(obj,'get_name'): - dCi['LEGENDE']=obj.get_name() - if obj==None: - UTMESS('S',macro,'incohérence entre le catalogue et la macro.') - - # 1.2. Extraction des valeurs - - # 1.2.1. Mot-clé FONCTION - if typi=='FONCTION': - if typ=='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: - 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] - # 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) - Graph.AjoutParaCourbe(dicC, args=dCi) - graph.AjoutCourbe(**dicC) - DETRUIRE(CONCEPT=_F(NOM=('li__','ftmp__'),),ALARME='NON',INFO=1) - else: - ftmp__=obj - dpar=ftmp__.Parametres() - if interp: - ftmp__=CALC_FONC_INTERP( - FONCTION=obj, - LIST_PARA=linter__, - **dpar - ) - elif dCi.has_key('LIST_PARA'): - ftmp__=CALC_FONC_INTERP( - FONCTION=obj, - LIST_PARA=dCi['LIST_PARA'], - **dpar - ) - lval=list(ftmp__.Valeurs()) - lx=lval[0] - lr=lval[1] - if typ=='fonction_c' and dCi.has_key('PARTIE'): - if dCi['PARTIE']=='IMAG' : lr=lval[2] - # on stocke les données dans le Graph - if typ=='fonction_c' and not dCi.has_key('PARTIE'): - nomresu=dpar['NOM_RESU'].strip()+'_'+str(len(graph.Legendes)) - dicC={ - 'Val' : lval, - 'Lab' : [dpar['NOM_PARA'],nomresu+'_R',nomresu+'_I'] - } - else: - nomresu=dpar['NOM_RESU'].strip()+'_'+str(len(graph.Legendes)) - dicC={ - 'Val' : [lx,lr], - 'Lab' : [dpar['NOM_PARA'],nomresu] - } - Graph.AjoutParaCourbe(dicC, args=dCi) - graph.AjoutCourbe(**dicC) - - # 1.2.2. Mot-clé LIST_RESU - elif typi=='LIST_RESU': - if interp and iocc>0: - UTMESS('S',macro,"""Il n'y a pas de règles d'interpolation pour LIST_PARA/LIST_RESU, - LIST_PARA/LIST_RESU ne peut donc apparaitre qu'une seule fois - et à la première occurence de COURBE""") - lx=dCi['LIST_PARA'].Valeurs() - lr=obj.Valeurs() - if len(lx)<>len(lr): - UTMESS('S',macro,"LIST_PARA et LIST_RESU n'ont pas la meme taille") - # on stocke les données dans le Graph - dicC={ - 'Val' : [lx,lr], - 'Lab' : [dCi['LIST_PARA'].get_name(),obj.get_name()] - } - Graph.AjoutParaCourbe(dicC, args=dCi) - graph.AjoutCourbe(**dicC) - - # 1.2.3. Mot-clé FONC_X - # exemple : obj(t)=sin(t), on imprime x=sin(t), y=cos(t) - # ob2(t)=cos(t) - elif typi=='FONC_X': - ob2=dCi['FONC_Y'] - # peut-on blinder au niveau du catalogue - if typ=="nappe_sdaster" or ob2.__class__.__name__=="nappe_sdaster": - UTMESS('S',macro,"FONC_X/FONC_Y ne peuvent pas etre des nappes !") - if interp and iocc>0: - UTMESS('S',macro,"""Au format 'TABLEAU' ,FONC_X/FONC_Y ne peut apparaitre qu'une seule fois - et à la première occurence de COURBE""") - ftmp__=obj - dpar=ftmp__.Parametres() - ftm2__=ob2 - dpa2=ftm2__.Parametres() - intloc=False - if interp and not dCi.has_key('LIST_PARA'): - # dans ce cas, linter__ contient les ordonnées de FONC_X - intloc=False - li__=linter__ - elif dCi.has_key('LIST_PARA'): - intloc=True - li__=dCi['LIST_PARA'] - if intloc: - ftmp__=CALC_FONC_INTERP( - FONCTION=obj, - LIST_PARA=li__, - **dpar - ) - lt,lx=ftmp__.Valeurs() - ftm2__=CALC_FONC_INTERP( - FONCTION=ob2, - LIST_PARA=li__, - **dpa2 - ) - else: - lt,lx=ftmp__.Valeurs() - li__=DEFI_LIST_REEL(VALE=lt) - ftm2__=CALC_FONC_INTERP( - FONCTION=ob2, - LIST_PARA=li__, - **dpa2 - ) - - lbid,ly=ftm2__.Valeurs() - # on stocke les données dans le Graph - # on imprime la liste des paramètres seulement si LIST_PARA - if intloc: - nomresur=dpar['NOM_RESU'].strip()+'_'+str(len(graph.Legendes)) - nomresu2=dpa2['NOM_RESU'].strip()+'_'+str(len(graph.Legendes)+1) - dicC={ - 'Val' : [lt,lx,ly], - 'Lab' : [dpar['NOM_PARA'],nomresur,nomresu2] - } - else: - nomresur=dpar['NOM_RESU'].strip()+'_'+str(len(graph.Legendes)) - nomresu2=dpa2['NOM_RESU'].strip()+'_'+str(len(graph.Legendes)+1) - dicC={ - 'Val' : [lx,ly], - 'Lab' : [nomresur,nomresu2] - } - Graph.AjoutParaCourbe(dicC, args=dCi) - graph.AjoutCourbe(**dicC) - - # 1.2.4. Mot-clé ABSCISSE / ORDONNEE - elif typi=='ABSCISSE': - if interp and iocc>0: - UTMESS('S',macro,"""Il n'y a pas de règles d'interpolation pour ABSCISSE/ORDONNEE, - ABSCISSE/ORDONNEE ne peut donc apparaitre qu'une seule fois - et à la première occurence de COURBE""") - lx=obj - lr=dCi['ORDONNEE'] - if len(lx)<>len(lr): - UTMESS('S',macro,"ABSCISSE et ORDONNEE n'ont pas la meme taille") - # on stocke les données dans le Graph - dicC={ - 'Val' : [lx,lr], - 'Lab' : ['Absc','Ordo'] - } - Graph.AjoutParaCourbe(dicC, args=dCi) - graph.AjoutCourbe(**dicC) - - # 1.2.9. ménage - DETRUIRE(CONCEPT=_F(NOM=('li__','ftmp__','ftm2__'),),ALARME='NON',INFO=1) - - # 1.2.99. ménage hors boucle - DETRUIRE(CONCEPT=_F(NOM=('linter__'),), ALARME='NON',INFO=1) - - # 1.3. dbg - if INFO==2: - print '\n'+'-'*70+'\n Contenu du Graph : \n'+'-'*70 - print graph - print '-'*70+'\n' - - #---------------------------------------------- - # 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'): - if args['BORNE_X']<>None: - graph.Min_X=args['BORNE_X'][0] - graph.Max_X=args['BORNE_X'][1] - if args['BORNE_Y']<>None: - graph.Min_Y=args['BORNE_Y'][0] - graph.Max_Y=args['BORNE_Y'][1] - if args['LEGENDE_X']<>None: graph.Legende_X=args['LEGENDE_X'] - if args['LEGENDE_Y']<>None: graph.Legende_Y=args['LEGENDE_Y'] - if args['ECHELLE_X']<>None: graph.Echelle_X=args['ECHELLE_X'] - if args['ECHELLE_Y']<>None: graph.Echelle_Y=args['ECHELLE_Y'] - if args['GRILLE_X']<>None: graph.Grille_X=args['GRILLE_X'] - if args['GRILLE_Y']<>None: graph.Grille_Y=args['GRILLE_Y'] - - kargs={ - 'FORMAT' : FORMAT, - 'FICHIER' : nomfich, - } - - # 2.1. au format TABLEAU - if FORMAT=='TABLEAU': - # surcharge par les formats de l'utilisateur - kargs['dform']={ - 'csep' : args['SEPARATEUR'], - 'ccom' : args['COMMENTAIRE'], - 'cdeb' : args['DEBUT_LIGNE'], - 'cfin' : args['FIN_LIGNE'] - } - - # 2.2. au format AGRAF - elif FORMAT=='AGRAF': - nomdigr=None - if args['UNITE_DIGR']<>6: - nomdigr=UL.Nom(args['UNITE_DIGR']) - kargs['FICHIER']=[nomfich, nomdigr] - kargs['dform']={ 'formR' : '%12.5E' } - - # 2.3. au format XMGRACE et dérivés - elif FORMAT=='XMGRACE': - kargs['dform']={ 'formR' : '%.8g' } - kargs['PILOTE']=args['PILOTE'] - - # 2.39. Format inconnu - else: - UTMESS('S',macro,'Format inconnu : '+FORMAT) - - # Traiter le cas des UL réservées - if args['UNITE'] and args['UNITE'] in ul_reserve: - UL.Etat(args['UNITE'], etat='F') - if FORMAT=='AGRAF' and args['UNITE_DIGR']<>args['UNITE'] \ - and args['UNITE_DIGR'] in ul_reserve: - UL.Etat(args['UNITE_DIGR'], etat='F') - - # 2.4. On trace ! - graph.Trace(**kargs) - - # 99. Traiter le cas des UL réservées - UL.EtatInit() - - return ier diff --git a/Aster/Cata/Macro/impr_table_ops.py b/Aster/Cata/Macro/impr_table_ops.py deleted file mode 100644 index 74776f0b..00000000 --- a/Aster/Cata/Macro/impr_table_ops.py +++ /dev/null @@ -1,231 +0,0 @@ -#@ MODIF impr_table_ops Macro DATE 11/05/2005 AUTEUR MCOURTOI M.COURTOIS -# -*- 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. -# ====================================================================== - -# RESPONSABLE MCOURTOI M.COURTOIS - -import os.path -import re - -from types import ListType, TupleType, StringTypes -EnumTypes=(ListType, TupleType) - - -# ------------------------------------------------------------------------------ -def impr_table_ops(self, FORMAT, TABLE, INFO, **args): - """ - Macro IMPR_TABLE permettant d'imprimer une table dans un fichier. - Erreurs dans IMPR_TABLE pour ne pas perdre la base. - """ - macro='IMPR_TABLE' - import aster - from Accas import _F - from Cata.cata import table_jeveux - 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 - DETRUIRE = self.get_cmd('DETRUIRE') - RECU_FONCTION = self.get_cmd('RECU_FONCTION') - - #---------------------------------------------- - # 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 nomfich and os.path.exists(nomfich) and os.stat(nomfich).st_size<>0: - if FORMAT=='XMGRACE': - UTMESS('A',macro,'Le fichier '+nomfich+' existe déjà, on écrit ' \ - 'à la suite.') - - # 0.2. Création des dictionnaires des FILTRES - Filtre=[] - if args['FILTRE']: - for Fi in args['FILTRE']: - dF = Fi.cree_dict_valeurs(Fi.mc_liste) - for mc in dF.keys(): - if dF[mc]==None: del dF[mc] - Filtre.append(dF) - # format pour l'impression des filtres - form_filtre='\nFILTRE -> NOM_PARA: %-16s CRIT_COMP: %-4s VALE: %s' - - # 0.3. Création de la liste des tables (une seule sans SENSIBILITE) - form_sens='\n... SENSIBILITE AU PARAMETRE %s' - ltab=[] - if args['SENSIBILITE']: - nmemo='&NOSENSI.MEMO.CORR'.ljust(24) - vect=aster.getvectjev(nmemo) - if vect: - lps=args['SENSIBILITE'] - if not type(lps) in EnumTypes: - lps=[lps,] - for ps in [ps.get_name() for ps in lps]: - trouv=False - for ch in vect[0:len(vect):2]: - if ch[0:8].strip()==TABLE.get_name() and ch[8:16].strip()==ps: - trouv=True - ncomp=ch[16:24].strip() - sdtab=table_jeveux(ncomp) - tabs=sdtab.EXTR_TABLE() - tabs.titr+=form_sens % ps - ltab.append([tabs, sdtab]) - if not trouv: - UTMESS('A',macro,'Dérivée de %s par rapport à %s non disponible'\ - % (TABLE.get_name(), ps)) - else: - UTMESS('A',macro,'Pas de calcul de sensibilité accessible.') - else: - ltab.append([TABLE.EXTR_TABLE(), TABLE]) - - if len(ltab)<1: - return ier - - # 0.4.1. liste des paramètres à conserver - nom_para=ltab[0][0].para - if args['NOM_PARA']: - nom_para=args['NOM_PARA'] - - # 0.4.2. Traiter le cas des UL réservées - if args['UNITE'] and args['UNITE'] in ul_reserve: - UL.Etat(args['UNITE'], etat='F') - - #---------------------------------------------- - # Boucle sur les tables - for tab, sdtab in ltab: - - # ----- 1. Infos de base - if INFO==2: - print 'IMPRESSION DE LA TABLE : %s' % sdtab.get_name() - - if args['TITRE']: - tab.titr=args['TITRE'] + '\n' + tab.titr - - # ----- 2. Filtres - for Fi in Filtre: - col = getattr(tab, Fi['NOM_PARA']) - # peu importe le type - opts=[Fi[k] for k in ('VALE','VALE_I','VALE_C','VALE_K') if Fi.has_key(k)] - kargs={} - for k in ('CRITERE','PRECISION'): - if Fi.has_key(k): - kargs[k]=Fi[k] - tab = tab & ( getattr(col, Fi['CRIT_COMP'])(*opts,**kargs) ) - # trace l'operation dans le titre - #if FORMAT in ('TABLEAU','ASTER'): - tab.titr+=form_filtre % (Fi['NOM_PARA'], Fi['CRIT_COMP'], \ - ' '.join([str(v) for v in opts])) - - # ----- 3. Tris - if args['TRI']: - # une seule occurence de TRI - T0=args['TRI'][0] - dT=T0.cree_dict_valeurs(T0.mc_liste) - tab.sort(CLES=dT['NOM_PARA'], ORDRE=dT['ORDRE']) - - # ----- 4. Impression - timp=tab[nom_para] - # passage des mots-clés de mise en forme à la méthode Impr - kargs=args.copy() - kargs.update({ - 'FORMAT' : FORMAT, - 'FICHIER' : nomfich, - 'dform' : {}, - }) - # pour l'impression des fonctions - kfonc={ - 'FORMAT' : FORMAT, - 'FICHIER' : nomfich, - } - - # 4.1. au format AGRAF - if FORMAT=='AGRAF': - kargs['dform']={ 'formR' : '%12.5E' } - kfonc['FORMAT']='TABLEAU' - - # 4.2. au format XMGRACE et dérivés - elif FORMAT=='XMGRACE': - kargs['dform']={ 'formR' : '%.8g' } - kargs['PILOTE']=args['PILOTE'] - kfonc['PILOTE']=args['PILOTE'] - - # 4.3. format spécifié dans les arguments - if args['FORMAT_R']: - kargs['dform'].update({ 'formR' : fmtF2PY(args['FORMAT_R']) }) - - # 4.4. regroupement par paramètre : PAGINATION - if args['PAGINATION']: - kargs['PAGINATION']=args['PAGINATION'] - - timp.Impr(**kargs) - - # ----- 5. IMPR_FONCTION='OUI' - if args['IMPR_FONCTION'] and args['IMPR_FONCTION']=='OUI': - # cherche parmi les cellules celles qui contiennent un nom de fonction - dfon={} - for row in timp: - for par,cell in row.items(): - if type(cell) in StringTypes: - if aster.getvectjev(cell.strip().ljust(19)+'.PROL')<>None: - dfon[cell.strip().ljust(19)]=par - # impression des fonctions trouvées - for f,par in dfon.items(): - __fonc=RECU_FONCTION( - TABLE=sdtab, - FILTRE=_F( - NOM_PARA=par, - VALE_K=f, - ), - NOM_PARA_TABL=par, - ) - __fonc.Trace(**kfonc) - DETRUIRE(CONCEPT=_F(NOM=('__fonc',),), ALARME='NON', INFO=1,) - - # 99. Traiter le cas des UL réservées - UL.EtatInit() - - return ier - -# ------------------------------------------------------------------------------ -def fmtF2PY(fformat): - """Convertit un format Fortran en format Python (printf style). - Gère uniquement les fortrans réels, par exemple : E12.5, 1PE13.6, D12.5... - """ - fmt='' - matP=re.search('([0-9]+)P',fformat) - if matP: - fmt+=' '*int(matP.group(1)) - matR=re.search('([eEdDfFgG]{1})([\.0-9]+)',fformat) - if matR: - fmt+='%'+matR.group(2)+re.sub('[dD]+','E',matR.group(1)) - try: - s=fmt % -0.123 - except (ValueError, TypeError), msg: - fmt='%12.5E' - print 'Error :',msg - print 'Format par défaut utilisé :',fmt - return fmt diff --git a/Aster/Cata/Macro/info_fonction_ops.py b/Aster/Cata/Macro/info_fonction_ops.py deleted file mode 100644 index b728f6a4..00000000 --- a/Aster/Cata/Macro/info_fonction_ops.py +++ /dev/null @@ -1,252 +0,0 @@ -#@ MODIF info_fonction_ops Macro DATE 12/05/2005 AUTEUR DURAND C.DURAND -# -*- coding: iso-8859-1 -*- -# CONFIGURATION MANAGEMENT OF EDF VERSION -# ====================================================================== -# COPYRIGHT (C) 1991 - 2005 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 info_fonction_ops(self,RMS,NOCI_SEISME,MAX,NORME,ECART_TYPE,**args): - """ - Ecriture de la macro INFO_FONCTION - """ - ier=0 - import string - from Utilitai.t_fonction import t_fonction,t_fonction_c,t_nappe - import math - from Accas import _F - from Utilitai.Utmess import UTMESS - - ### On importe les definitions des commandes a utiliser dans la macro - CREA_TABLE = self.get_cmd('CREA_TABLE') - CALC_FONCTION = self.get_cmd('CALC_FONCTION') - - ### Comptage commandes + déclaration concept sortant - self.set_icmd(1) - self.DeclareOut('C_out',self.sd) - - ### type de traitement - - ### - if (MAX != None): - __ff=MAX['FONCTION'].convert() - __ex=__ff.extreme() - n_mini=len(__ex['min']) - n_maxi=len(__ex['max']) - listeMCF=[_F(LISTE_K=[MAX['FONCTION'].nom]*(n_mini+n_maxi),PARA='FONCTION'), - _F(LISTE_K=['MINI',]*n_mini+['MAXI',]*n_maxi,PARA='TYPE'),] - if isinstance(__ff,t_nappe) : - listeMCF=listeMCF+[\ - _F(LISTE_R=[i[0] for i in __ex['min']]+[i[0] for i in __ex['max']],PARA=__ff.para['NOM_PARA']),\ - _F(LISTE_R=[i[1] for i in __ex['min']]+[i[1] for i in __ex['max']],PARA=__ff.para['NOM_PARA_FONC']),\ - _F(LISTE_R=[i[2] for i in __ex['min']]+[i[2] for i in __ex['max']],PARA=__ff.para['NOM_RESU'])] - else : - listeMCF=listeMCF+[\ - _F(LISTE_R=[i[0] for i in __ex['min']]+[i[0] for i in __ex['max']],PARA=__ff.para['NOM_PARA']),\ - _F(LISTE_R=[i[1] for i in __ex['min']]+[i[1] for i in __ex['max']],PARA=__ff.para['NOM_RESU'])] - C_out=CREA_TABLE(LISTE=listeMCF) - - ### - if (ECART_TYPE != None): - __ff=ECART_TYPE['FONCTION'].convert() - if ECART_TYPE['INST_INIT']!=None : tini=ECART_TYPE['INST_INIT'] - else : tini=__ff.vale_x[0] - if ECART_TYPE['INST_FIN' ]!=None : tfin=ECART_TYPE['INST_FIN' ] - else : tfin=__ff.vale_x[-1] - __ff=__ff.cut(tini,__ff.vale_x[-1],ECART_TYPE['PRECISION'],ECART_TYPE['CRITERE']) - __ff=__ff.cut(__ff.vale_x[0],tfin,ECART_TYPE['PRECISION'],ECART_TYPE['CRITERE']) - if ECART_TYPE['METHODE' ]=='SIMPSON' : __ex=__ff.simpson(0.) - if ECART_TYPE['METHODE' ]=='TRAPEZE' : __ex=__ff.trapeze(0.) - fmoy=__ex.vale_y[-1]/(__ff.vale_x[-1]-__ff.vale_x[0]) - __ff=__ff+(-1*fmoy) - __ff=__ff*__ff - if ECART_TYPE['METHODE' ]=='SIMPSON' : __ez=__ff.simpson(0.) - if ECART_TYPE['METHODE' ]=='TRAPEZE' : __ez=__ff.trapeze(0.) - sigma=math.sqrt(__ez.vale_y[-1]/(__ff.vale_x[-1]-__ff.vale_x[0])) - C_out=CREA_TABLE(LISTE=(_F(LISTE_K=ECART_TYPE['FONCTION'].nom,PARA='FONCTION'), - _F(LISTE_K=ECART_TYPE['METHODE'] ,PARA='METHODE'), - _F(LISTE_R=fmoy ,PARA='MOYENNE'), - _F(LISTE_R=sigma ,PARA='ECART_TYPE'), - _F(LISTE_R=tini ,PARA='INST_INIT'), - _F(LISTE_R=tfin ,PARA='INST_FIN'),) - ) - - ### - if (RMS != None): - RMS =list(RMS) - sigm =[] - tmpi =[] - tmpf =[] - nomf =[] - meth =[] - for i_rms in RMS : - __ff=i_rms['FONCTION'].convert() - if i_rms['INST_INIT']!=None : tini=i_rms['INST_INIT'] - else : tini=__ff.vale_x[0] - if i_rms['INST_FIN' ]!=None : tfin=i_rms['INST_FIN' ] - else : tfin=__ff.vale_x[-1] - __ff=__ff.cut(tini,__ff.vale_x[-1],i_rms['PRECISION'],i_rms['CRITERE']) - __ff=__ff.cut(__ff.vale_x[0],tfin,i_rms['PRECISION'],i_rms['CRITERE']) - __ff=__ff*__ff - if i_rms['METHODE' ]=='SIMPSON' : __ez=__ff.simpson(0.) - if i_rms['METHODE' ]=='TRAPEZE' : - __ez=__ff.trapeze(0.) - sigm.append(math.sqrt(__ez.vale_y[-1]/(__ff.vale_x[-1]-__ff.vale_x[0]))) - tmpi.append(tini) - tmpf.append(tfin) - nomf.append(i_rms['FONCTION'].nom) - meth.append(i_rms['METHODE']) - C_out=CREA_TABLE(LISTE=(_F(LISTE_K=nomf ,PARA='FONCTION'), - _F(LISTE_K=meth ,PARA='METHODE'), - _F(LISTE_R=tmpi ,PARA='INST_INIT'), - _F(LISTE_R=tmpf ,PARA='INST_FIN'), - _F(LISTE_R=sigm ,PARA='RMS'), ) - ) - - ### - if (NORME != None): - __ff=NORME['FONCTION'].convert() - norme=[] - for __fi in __ff.l_fonc : - norme.append(__fi.normel2()) - nom=[NORME['FONCTION'].nom,]*len(norme) - C_out=CREA_TABLE(LISTE=(_F(LISTE_R=norme ,PARA='NORME'), - _F(LISTE_K=nom ,PARA='FONCTION'), ) - ) - - ### - if (NOCI_SEISME != None): - l_table=[] - if NOCI_SEISME['SPEC_OSCI'] !=None : - ### cas intensité spectrale d'une nappe de SRO - ### la seule option licite est INTE_SPEC - UTMESS('I','INFO_FONCTION',''' : intensite spectrale, avant de calculer l'\ -intensite spectrale, il est prudent de verifier la norme de la nappe sur laquelle \ -porte le calcul, ceci peut etre une source d erreurs.''') - amor=NOCI_SEISME['AMOR_REDUIT'] - fini=NOCI_SEISME['FREQ_INIT' ] - ffin=NOCI_SEISME['FREQ_FIN' ] - __sp =NOCI_SEISME['SPEC_OSCI'].convert() - vale_x=__sp.l_fonc[0].vale_x - vale_y=[__sp(amor,f) for f in vale_x] - para =__sp.l_fonc[0].para - __srov=t_fonction(vale_x,vale_y,para) - if NOCI_SEISME['NATURE']=='DEPL' : - __srov.vale_y=(__srov.vale_y/__srov.vale_x)*2.*math.pi - elif NOCI_SEISME['NATURE']=='VITE' : - __srov.vale_y=__srov.vale_y/__srov.vale_x/__srov.vale_x - elif NOCI_SEISME['NATURE']=='ACCE' : - __srov.vale_y=__srov.vale_y/__srov.vale_x/__srov.vale_x - __srov.vale_y=__srov.vale_y/__srov.vale_x/2./math.pi - __srov=__srov.cut(fini,ffin,NOCI_SEISME['PRECISION'],NOCI_SEISME['CRITERE']) - insp=__srov.trapeze(0.).vale_y[-1] - l_table.append(_F(LISTE_R=fini ,PARA='FREQ_INIT' )) - l_table.append(_F(LISTE_R=ffin ,PARA='FREQ_FIN' )) - l_table.append(_F(LISTE_R=amor ,PARA='AMOR_REDUIT')) - l_table.append(_F(LISTE_R=insp ,PARA='INTE_SPECT' )) - if NOCI_SEISME['FONCTION'] !=None : - ### cas fonction - l_table.append(_F(LISTE_K=NOCI_SEISME['FONCTION'].nom,PARA='FONCTION')) - __ac=NOCI_SEISME['FONCTION'].convert() - option= NOCI_SEISME['OPTION'] - if NOCI_SEISME['INST_INIT']!=None : tdeb=NOCI_SEISME['INST_INIT'] - else : tdeb=__ac.vale_x[0] - if NOCI_SEISME['INST_FIN' ]!=None : tfin=NOCI_SEISME['INST_FIN' ] - else : tfin=__ac.vale_x[-1] - # calcul de la vitesse : - __vi=__ac.trapeze(NOCI_SEISME['COEF']) - # calcul du déplacement : - __de=__vi.trapeze(NOCI_SEISME['COEF']) - # calcul de |acceleration| : - __aa=__ac.abs() - # calcul de integrale(|acceleration|) : - ### on "coupe" la fonction entre tdeb et tfin - __ac=__ac.cut(tdeb,tfin,NOCI_SEISME['PRECISION'],NOCI_SEISME['CRITERE']) - __vi=__vi.cut(tdeb,tfin,NOCI_SEISME['PRECISION'],NOCI_SEISME['CRITERE']) - __de=__de.cut(tdeb,tfin,NOCI_SEISME['PRECISION'],NOCI_SEISME['CRITERE']) - __aa=__aa.cut(tdeb,tfin,NOCI_SEISME['PRECISION'],NOCI_SEISME['CRITERE']) - if NOCI_SEISME['FREQ' ]!=None : l_freq=NOCI_SEISME['FREQ'] - elif NOCI_SEISME['LIST_FREQ']!=None : l_freq=NOCI_SEISME['LIST_FREQ'].Valeurs() - else : - # fréquences par défaut - l_freq=[] - for i in range(56) : l_freq.append( 0.2+0.050*i) - for i in range( 8) : l_freq.append( 3.0+0.075*i) - for i in range(14) : l_freq.append( 3.6+0.100*i) - for i in range(24) : l_freq.append( 5.0+0.125*i) - for i in range(28) : l_freq.append( 8.0+0.250*i) - for i in range( 6) : l_freq.append(15.0+0.500*i) - for i in range( 4) : l_freq.append(18.0+1.000*i) - for i in range(10) : l_freq.append(22.0+1.500*i) - if option in('TOUT','MAXI','ACCE_SUR_VITE') : - # calcul du max des valeurs absolues - maxa_ac=__ac.abs().extreme()['max'][0][1] - maxa_vi=__vi.abs().extreme()['max'][0][1] - maxa_de=__de.abs().extreme()['max'][0][1] - l_table.append(_F(LISTE_R=maxa_ac,PARA='ACCE_MAX')) - l_table.append(_F(LISTE_R=maxa_vi,PARA='VITE_MAX')) - l_table.append(_F(LISTE_R=maxa_de,PARA='DEPL_MAX')) - l_table.append(_F(LISTE_R=maxa_ac/maxa_vi,PARA='ACCE_SUR_VITE')) - if option in('TOUT','INTE_ARIAS') : - __a2=__ac*__ac - inte_arias=__a2.trapeze(0.).vale_y[-1] - inte_arias=inte_arias*math.pi/NOCI_SEISME['PESANTEUR']/2. - l_table.append(_F(LISTE_R=inte_arias,PARA='INTE_ARIAS')) - if option in('TOUT','POUV_DEST') : - __v2=__vi*__vi - pouv_dest=__v2.trapeze(0.).vale_y[-1] - pouv_dest=pouv_dest*(math.pi)**3/NOCI_SEISME['PESANTEUR']/2. - l_table.append(_F(LISTE_R=pouv_dest,PARA='POUV_DEST')) - if option in('TOUT','VITE_ABSO_CUMU') : - __vc=__aa.trapeze(0.) - vite_abso=__vc.vale_y[-1] - l_table.append(_F(LISTE_R=vite_abso,PARA='VITE_ABSO_CUMU')) - if option in('TOUT','INTE_SPEC') : - amor=NOCI_SEISME['AMOR_REDUIT'] - fini=NOCI_SEISME['FREQ_INIT' ] - ffin=NOCI_SEISME['FREQ_FIN' ] - __so= CALC_FONCTION(SPEC_OSCI=_F( - NATURE ='VITE', - NATURE_FONC='ACCE', - FONCTION =NOCI_SEISME['FONCTION'], - METHODE ='NIGAM', - NORME =NOCI_SEISME['NORME'], - FREQ =l_freq, - AMOR_REDUIT=(amor,) - ), ) - __srov=__so.convert().l_fonc[0] - __srov=__srov.cut(fini,ffin,NOCI_SEISME['PRECISION'],NOCI_SEISME['CRITERE']) - __srov.vale_y=__srov.vale_y/__srov.vale_x/__srov.vale_x - insp=__srov.trapeze(0.).vale_y[-1] - l_table.append(_F(LISTE_R=fini ,PARA='FREQ_INIT' )) - l_table.append(_F(LISTE_R=ffin ,PARA='FREQ_FIN' )) - l_table.append(_F(LISTE_R=amor ,PARA='AMOR_REDUIT')) - l_table.append(_F(LISTE_R=insp ,PARA='INTE_SPECT' )) - if option in('TOUT','DUREE_PHAS_FORT') : - __a2=__ac*__ac - __i2=__a2.trapeze(0.) - arias = __i2.vale_y[-1]*math.pi/NOCI_SEISME['PESANTEUR']/2. - valinf = arias * NOCI_SEISME['BORNE_INF'] - valsup = arias * NOCI_SEISME['BORNE_SUP'] - for i in range(len(__i2.vale_x)) : - ariask = __i2.vale_y[i]*math.pi/NOCI_SEISME['PESANTEUR']/2. - if ariask>=valinf : break - for j in range(len(__i2.vale_x)-1,-1,-1) : - ariask = __i2.vale_y[j]*math.pi/NOCI_SEISME['PESANTEUR']/2. - if ariask<=valsup : break - dphfor = __i2.vale_x[j] - __i2.vale_x[i] - l_table.append(_F(LISTE_R=dphfor,PARA='DUREE_PHAS_FORT')) - C_out=CREA_TABLE(LISTE=l_table) - - return ier diff --git a/Aster/Cata/Macro/lire_fonction_ops.py b/Aster/Cata/Macro/lire_fonction_ops.py deleted file mode 100644 index 52d1e906..00000000 --- a/Aster/Cata/Macro/lire_fonction_ops.py +++ /dev/null @@ -1,254 +0,0 @@ -#@ MODIF lire_fonction_ops Macro DATE 30/11/2004 AUTEUR MCOURTOI M.COURTOIS -# -*- 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. -# ====================================================================== - -import string,os,Numeric - -# ------------------------------------------------------------------------------ -def m_format_libre(texte,INDIC_PARA,INDIC_RESU,SEPAR): - """Méthode de construction du VALE pour le format libre - format LIBRE - Les lignes contenant autre chose que des séquences de nombres - réels et de séparateurs sont considérées comme délimitant deux - fonctions différentes. Cette situation correspond à l exception - ValueError levée par le map de float. Le deuxieme indice de - INDIC_PARA et INDIC_RESU est l indice permettant de pointer sur la - fonction voulue, au sens de ce découpage. - """ - - from Utilitai.transpose import transpose - l_fonc=[] - fonc =[] - ier =0 - if SEPAR=='None' : SEPAR=None - for line in texte : - try : - if string.strip(line)=='' : raise ValueError - fonc.append(map(float,string.split(line,SEPAR))) - except ValueError: - if fonc==[] : pass # dans ce cas, on a plusieurs lignes délimitant 2 fonctions - else : - l_fonc.append(Numeric.array(fonc)) - fonc=[] - if fonc!=[] : - l_fonc.append(Numeric.array(fonc)) - - # vérifications de cohérences lignes et colonnes - ind_para=[INDIC_PARA[0]-1,INDIC_PARA[1]-1] - ind_resu=[INDIC_RESU[0]-1,INDIC_RESU[1]-1] - if INDIC_PARA[0]>len(l_fonc) : - ier=ier+1 - message= " INDIC_PARA :le nombre de blocs de fonctions dans " - message=message+"le fichier est inférieur à "+str(INDIC_PARA[0]) - return ier,message,[] - if INDIC_RESU[0]>len(l_fonc) : - ier=ier+1 - message= " INDIC_RESU :le nombre de blocs de fonctions dans " - message=message+"le fichier est inférieur à "+str(INDIC_RESU[0]) - return ier,message,[] - if INDIC_PARA[1]>len(l_fonc[ind_para[0]]) : - ier=ier+1 - message= " INDIC_PARA :la fonction numéro " - message=message+str(INDIC_PARA[0]) - message=message+" ne comporte que "+str(l_fonc[INDIC_PARA[0]])+" colonnes" - return ier,message,[] - if INDIC_RESU[1]>len(l_fonc[ind_resu[0]]) : - ier=ier+1 - message= " INDIC_RESU :la fonction numéro " - message=message+str(INDIC_RESU[0]) - message=message+" ne comporte que "+str(l_fonc[INDIC_RESU[0]])+" colonnes" - return ier,message,[] - - # construction du VALE de la fonction par recherche des indices - # de colonnes et de fonctions dans le tableau l_fonc - vale_1=l_fonc[ind_para[0]][:,ind_para[1]] - vale_2=l_fonc[ind_resu[0]][:,ind_resu[1]] - if len(vale_1)!=len(vale_2) : - ier=ier+1 - message= " INDIC_RESU :les deux colonnes demandées " - message=message+" pour INDIC_PARA et INDIC_RESU n ont pas la meme longueur :" - message=message+str(len(vale_1))+" et "+str(len(vale_2)) - return ier,message,[] - liste_vale=transpose([vale_1,vale_2]) - def add(x,y):return x+y - liste_vale=reduce(add,liste_vale) - return ier,'',liste_vale - -# ------------------------------------------------------------------------------ -def liste_simple(texte,INDIC_PARA,SEPAR): - """recherche d'une liste simple - """ - # format LIBRE - # liste simple - - l_fonc=[] - fonc =[] - ier =0 - if SEPAR=='None' : SEPAR=None - for line in texte : - try : - if string.strip(line)=='' : raise ValueError - fonc.append(map(float,string.split(line,SEPAR))) - except ValueError: - if fonc==[] : pass # dans ce cas, on a plusieurs lignes délimitant 2 fonctions - else : - l_fonc.append(Numeric.array(fonc)) - fonc=[] - if fonc!=[] : - l_fonc.append(Numeric.array(fonc)) - - # vérifications de cohérences lignes et colonnes - ind_para=[INDIC_PARA[0]-1,INDIC_PARA[1]-1] - if INDIC_PARA[0]>len(l_fonc) : - ier=ier+1 - message= " INDIC_PARA :le nombre de blocs de fonctions dans " - message=message+"le fichier est inférieur à "+str(INDIC_PARA[0]) - return ier,message,[] - if INDIC_PARA[1]>len(l_fonc[ind_para[0]]) : - ier=ier+1 - message= " INDIC_PARA :la fonction numéro " - message=message+str(INDIC_PARA[0]) - message=message+" ne comporte que "+str(l_fonc[INDIC_PARA[0]])+" colonnes" - self.cr.fatal(message) - return ier,message,[] - - # construction du VALE de la fonction par recherche des indices - # de colonnes et de fonctions dans le tableau l_fonc - vale_1=l_fonc[ind_para[0]][:,ind_para[1]] - return ier,'',vale_1.tolist() - -# ------------------------------------------------------------------------------ -def lire_fonction_ops(self,FORMAT,TYPE,SEPAR,INDIC_PARA,UNITE, - NOM_PARA,NOM_RESU,INTERPOL,PROL_DROITE, - PROL_GAUCHE,VERIF,INFO,TITRE,**args): - """Méthode corps de la macro - """ - ier=0 - - from Accas import _F -# On recopie le mot cle defi_fonction pour le proteger - if TYPE=='NAPPE' : - mc_DEFI_FONCTION=args['DEFI_FONCTION'] - - # On importe les definitions des commandes a utiliser dans la macro - DEFI_FONCTION =self.get_cmd('DEFI_FONCTION') - DEFI_NAPPE =self.get_cmd('DEFI_NAPPE') - - # La macro compte pour 1 dans la numerotation des commandes - self.set_icmd(1) - - # Lecture de la fonction dans un fichier d unité logique UNITE - - file="./fort."+str(UNITE) - if not os.path.isfile(file) : - ier=ier+1 - self.cr.fatal(" le fichier d unité logique "+str(UNITE)+" est introuvable") - return ier - file=open(file,'r') - texte=file.readlines() - file.close() - - self.DeclareOut('ut_fonc',self.sd) - - if TYPE=='FONCTION': - # mise en forme de la liste de valeurs suivant le format choisi : - ier,message,liste_vale=m_format_libre(texte,INDIC_PARA,args['INDIC_RESU'],SEPAR) - if ier!=0 : - self.cr.fatal(message) - return ier - - # création de la fonction ASTER : - ut_fonc=DEFI_FONCTION( NOM_PARA =NOM_PARA, - NOM_RESU =NOM_RESU, - PROL_DROITE=PROL_DROITE, - PROL_GAUCHE=PROL_GAUCHE, - INTERPOL =INTERPOL, - INFO =INFO, - TITRE =TITRE, - VERIF =VERIF, - VALE =liste_vale,) - - elif TYPE=='FONCTION_C': - # mise en forme de la liste de valeurs suivant le format choisi : - if 'INDIC_REEL' in args : - indic1=args['INDIC_REEL'] - indic2=args['INDIC_IMAG'] - if 'INDIC_MODU' in args : - indic1=args['INDIC_MODU'] - indic2=args['INDIC_PHAS'] - ier,message,liste_vale_r=m_format_libre(texte,INDIC_PARA,indic1,SEPAR) - if ier!=0 : - self.cr.fatal(message) - return ier - ier,message,liste_vale_i=m_format_libre(texte,INDIC_PARA,indic2,SEPAR) - if ier!=0 : - self.cr.fatal(message) - return ier - liste=[] - if 'INDIC_REEL' in args : - for i in range(len(liste_vale_r)/2) : - liste=liste+[liste_vale_r[2*i],liste_vale_r[2*i+1],liste_vale_i[2*i+1]] - elif 'INDIC_MODU' in args : - for i in range(len(liste_vale_r)/2) : - module=liste_vale_r[2*i+1] - phase =liste_vale_i[2*i+1] - liste=liste+[liste_vale_r[2*i],module*cos(phase),module*sin(phase)] - - # création de la fonction ASTER : - ut_fonc=DEFI_FONCTION( NOM_PARA =NOM_PARA, - NOM_RESU =NOM_RESU, - PROL_DROITE=PROL_DROITE, - PROL_GAUCHE=PROL_GAUCHE, - INTERPOL =INTERPOL, - INFO =INFO, - TITRE =TITRE, - VERIF =VERIF, - VALE_C =liste,) - - elif TYPE=='NAPPE': - - # création de la nappe ASTER : - motscles={} - motscles['DEFI_FONCTION']=[] - for elem in mc_DEFI_FONCTION: - ier,message,liste_vale=m_format_libre(texte,args['INDIC_ABSCISSE'],elem['INDIC_RESU'],SEPAR) - if ier!=0 : - self.cr.fatal(message) - return ier - motscles['DEFI_FONCTION'].append( _F( VALE =liste_vale, - INTERPOL =args['INTERPOL_FONC'], - PROL_DROITE=args['PROL_DROITE_FONC'], - PROL_GAUCHE=args['PROL_GAUCHE_FONC'] ) ) - ier,message,liste_para=liste_simple(texte,INDIC_PARA,SEPAR) - if ier!=0 : - self.cr.fatal(message) - return ier - ut_fonc=DEFI_NAPPE( PARA =liste_para, - NOM_PARA =NOM_PARA, - NOM_PARA_FONC =args['NOM_PARA_FONC'], - NOM_RESU =NOM_RESU, - PROL_DROITE =PROL_DROITE, - PROL_GAUCHE =PROL_GAUCHE, - INTERPOL =INTERPOL, - INFO =INFO, - TITRE =TITRE, - VERIF =VERIF, - **motscles) - - return ier diff --git a/Aster/Cata/Macro/lire_inte_spec_ops.py b/Aster/Cata/Macro/lire_inte_spec_ops.py deleted file mode 100644 index d3ae6d67..00000000 --- a/Aster/Cata/Macro/lire_inte_spec_ops.py +++ /dev/null @@ -1,122 +0,0 @@ -#@ MODIF lire_inte_spec_ops Macro DATE 20/09/2004 AUTEUR DURAND C.DURAND -# -*- 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. -# ====================================================================== - -def lire_inte_spec_ops(self,UNITE,FORMAT,NOM_PARA,NOM_RESU,INTERPOL, - PROL_DROITE,PROL_GAUCHE,TITRE,INFO,**args): - ier=0 - - from Accas import _F - import os - from math import cos,sin - # On importe les definitions des commandes a utiliser dans la macro - DEFI_FONCTION =self.get_cmd('DEFI_FONCTION') - CREA_TABLE =self.get_cmd('CREA_TABLE') - - # La macro compte pour 1 dans la numerotation des commandes - self.set_icmd(1) - - # Lecture de la fonction dans un fichier d unité logique UNITE - - file="./fort."+str(UNITE) - if not os.path.isfile(file) : - ier=ier+1 - self.cr.fatal(" le fichier d unité logique "+str(UNITE)+" est introuvable") - return ier - file=open(file,'r') - texte=file.read() - file.close() - - list_fonc=texte.split('FONCTION_C') - entete=list_fonc.pop(0) - try : - entete=entete[entete.index('DIM'):] - dim=int(entete[entete.index('=')+1:entete.index('\n')]) - except ValueError : - ier=ier+1 - self.cr.fatal(" la dimension DIM n est pas précisée dans le fichier lu") - return ier - - if len(list_fonc)!=(dim*(dim+1)/2): - ier=ier+1 - self.cr.fatal(" nombre de fonctions incorrect") - return ier - - nume_i=[] - nume_j=[] - l_fonc=[] - for i in range(dim*(dim+1)/2): - numi=list_fonc[i][list_fonc[i].index('I =')+3:] - numi=numi[:numi.index('\n')] - nume_i.append(int(numi)) - numj=list_fonc[i][list_fonc[i].index('J =')+3:] - numj=numj[:numj.index('\n')] - nume_j.append(int(numj)) - try : - vale_fonc=list_fonc[i][list_fonc[i].index('VALEUR =\n')+9:list_fonc[i].index('FINSF\n')] - vale_fonc=vale_fonc.replace('\n',' ') - vale_fonc=map(float,vale_fonc.split()) - except ValueError : - ier=ier+1 - self.cr.fatal(" erreur dans les données de fonctions") - return ier - - liste=[] - if FORMAT=='REEL_IMAG': - liste=vale_fonc - elif FORMAT=='MODULE_PHASE': - for i in range(len(vale_fonc)/3) : - module=vale_fonc[3*i+1] - phase =vale_fonc[3*i+2] - liste=liste+[vale_fonc[3*i],module*cos(phase),module*sin(phase)] - - # création de la fonction ASTER : - _fonc=DEFI_FONCTION( NOM_PARA =NOM_PARA, - NOM_RESU =NOM_RESU, - PROL_DROITE=PROL_DROITE, - PROL_GAUCHE=PROL_GAUCHE, - INTERPOL =INTERPOL, - INFO =INFO, - TITRE =TITRE, - VALE_C =liste,) - l_fonc.append(_fonc.nom) - - nume_ib=[] - nume_jb=[] - for i in range(dim): - for j in range(i,dim): - nume_ib.append(i+1) - nume_jb.append(j+1) - if nume_i!=nume_ib or nume_j!=nume_jb : - ier=ier+1 - self.cr.fatal(" erreur dans les indices") - return ier - mcfact=[] - mcfact.append(_F(PARA='NOM_CHAM' ,LISTE_K=(NOM_RESU),NUME_LIGN=(1,))) - mcfact.append(_F(PARA='OPTION' ,LISTE_K=('TOUT',) ,NUME_LIGN=(1,))) - mcfact.append(_F(PARA='DIMENSION' ,LISTE_I=(dim,) ,NUME_LIGN=(1,))) - mcfact.append(_F(PARA='NUME_ORDRE_I',LISTE_I=nume_i ,NUME_LIGN=range(2,len(nume_i)+2))) - mcfact.append(_F(PARA='NUME_ORDRE_J',LISTE_I=nume_j ,NUME_LIGN=range(2,len(nume_j)+2))) - mcfact.append(_F(PARA='FONCTION' ,LISTE_K=l_fonc ,NUME_LIGN=range(2,len(list_fonc)+2))) - self.DeclareOut('tab_inte',self.sd) - tab_inte=CREA_TABLE(TYPE_TABLE='TABL_INTE_SPEC', - LISTE=mcfact, - TITRE=TITRE,) - - return ier diff --git a/Aster/Cata/Macro/lire_table_ops.py b/Aster/Cata/Macro/lire_table_ops.py deleted file mode 100644 index e7ba1006..00000000 --- a/Aster/Cata/Macro/lire_table_ops.py +++ /dev/null @@ -1,173 +0,0 @@ -#@ MODIF lire_table_ops Macro DATE 30/11/2004 AUTEUR MCOURTOI M.COURTOIS -# -*- 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. -# ====================================================================== - -import string - -# ------------------------------------------------------------------------------ -def lecture_table(texte,nume,separ): - """Méthode de construction du dictionnaire PARAMETRE / LISTE DE VALEURS - format ASTER - Les lignes contenant autre chose que des séquences de nombres - réels et de séparateurs sont considérées comme délimitant deux - fonctions différentes. Cette situation correspond à l exception - ValueError levée par le map de float. Le deuxieme indice de - VALE_PARA et VALE_RESU est l indice permettant de pointer sur la - fonction voulue, au sens de ce découpage. - """ - - from Utilitai.transpose import transpose - if string.strip(separ)=='' : separ=None - tab_lue={} - nume_lign=[] - idt_deb='#DEBUT_TABLE\n' - idt_fin='#FIN_TABLE\n' - idt_tit='#TITRE' - if nume>texte.count(idt_deb) : - message= " NUME_TABLE :le nombre de blocs de tables dans " - message=message+"le fichier est "+str(texte.count(idt_deb)) - return 1,message,None,None,None - for i in range(nume): - texte=texte[texte.index(idt_deb)+1:] - texte=texte[:texte.index(idt_fin)] - - titre_tab=[string.rstrip(elem[7:-1]) for elem in texte if elem.find(idt_tit)!=-1] - texte_tab=[elem.split(separ) for elem in texte if elem.find(idt_tit)==-1] - - if ( separ!=None) : - tab_trav=[] - for line in texte_tab : - ligne=[] - for elem in line : - if ( elem != '' and elem !='\n') : - ligne.append(string.strip(elem)) - tab_trav.append(ligne) - texte_tab=tab_trav - - list_para=texte_tab[0] - list_type=texte_tab[1] - texte_tab.pop(0) - texte_tab.pop(0) - nb_para=len(texte_tab[0]) - - for line in texte_tab : - if len(line)!=nb_para : - message= " incoherence dans le nombre de colonnes " - message=message+"de la table a lire" - return 1,message,None,None,None - texte_tab=transpose(texte_tab) - for i in range(nb_para): - tab_trav=[] - list_val=[] - col_type=list_type[i] - if col_type=='R': - try : - texte_tab[i]=map(float,texte_tab[i]) - nume_lign.append([0]) - except ValueError: -# Presence de - dans la ligne - for indice in range(len(texte_tab[i])): - if texte_tab[i][indice]!='-': - tab_trav.append(indice+1) - list_val.append(float(texte_tab[i][indice])) - - nume_lign.append(tab_trav) - texte_tab[i]=list_val - elif col_type=='I' : - try : - texte_tab[i]=map(int,texte_tab[i]) - nume_lign.append([0]) -# Presence de - dans la ligne - except ValueError: - for indice in range(len(texte_tab[i])): - if texte_tab[i][indice]!='-': - tab_trav.append(indice+1) - list_val.append(float(texte_tab[i][indice])) - nume_lign.append(tab_trav) - texte_tab[i]=list_val - - else : - try : nume_lign.append([0]) - except ValueError: pass - - tab_lue[list_para[i]]=(list_type[i],texte_tab[i],nume_lign[i]) - - return 0,None,titre_tab,list_para,tab_lue - - -# ------------------------------------------------------------------------------ -def lire_table_ops(self,UNITE,FORMAT,NUME_TABLE,SEPARATEUR, - TYPE_TABLE,PARA,TITRE,**args): - """Méthode corps de la macro LIRE_TABLE - """ - from Accas import _F - import os - - ier=0 - ### On importe les definitions des commandes a utiliser dans la macro - CREA_TABLE =self.get_cmd('CREA_TABLE') - - ### La macro compte pour 1 dans la numerotation des commandes - self.set_icmd(1) - - ### Lecture de la table dans un fichier d unité logique UNITE - file="./fort."+str(UNITE) - if not os.path.isfile(file) : - ier=ier+1 - self.cr.fatal(" le fichier d unité logique "+str(UNITE)+" est introuvable") - return ier - file=open(file,'r') - texte=file.readlines() - file.close() - - ### mise en forme de la liste de valeurs suivant le format choisi : - if FORMAT=='ASTER': - ier,message,titr_tab,list_para,tab_lue=lecture_table(texte,NUME_TABLE,SEPARATEUR) - if ier!=0 : - self.cr.fatal(message) - return ier - else : pass - - ### création de la table ASTER : - self.DeclareOut('ut_tab',self.sd) - mcfact=[] - num_col=0 - for tab_para in list_para: - mcsimp={} - mcsimp['PARA']=tab_para - - if tab_lue[tab_para][2] != [0] : - mcsimp['NUME_LIGN']=tab_lue[tab_para][2] - - if tab_lue[tab_para][0] not in ('I','R') : - mcsimp['TYPE_K'] =tab_lue[tab_para][0] - mcsimp['LISTE_K']=tab_lue[tab_para][1] - elif tab_lue[tab_para][0]=='I' : - mcsimp['LISTE_I']=tab_lue[tab_para][1] - elif tab_lue[tab_para][0]=='R' : - mcsimp['LISTE_R']=tab_lue[tab_para][1] - - mcfact.append( _F(**mcsimp) ) - num_col = num_col + 1 - motscles={} - motscles['LISTE']=mcfact - - ut_tab=CREA_TABLE(TITRE=titr_tab,TYPE_TABLE=TYPE_TABLE, **motscles) - - return ier