+++ /dev/null
-#@ 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.
-#
-#
-# ======================================================================
+++ /dev/null
-#@ 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
+++ /dev/null
-#@ 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
-
+++ /dev/null
-#@ 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("""<F> <CALC_PRECONT> 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
-
+++ /dev/null
-#@ 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("""<F> <DEFI_CABLE_BP> 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("""<F> <DEFI_CABLE_BP> 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("""<F> <DEFI_CABLE_BP> 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
+++ /dev/null
-#@ 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
+++ /dev/null
-#@ 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)
+++ /dev/null
-#@ 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")
+++ /dev/null
-#@ 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<S> 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
+++ /dev/null
-#@ 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<S> 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
+++ /dev/null
-#@ 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
+++ /dev/null
-#@ 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= "<F> <LIRE_FONCTION> 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= "<F> <LIRE_FONCTION> 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= "<F> <LIRE_FONCTION> 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= "<F> <LIRE_FONCTION> 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= "<F> <LIRE_FONCTION> 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= "<F> <LIRE_FONCTION> 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= "<F> <LIRE_FONCTION> 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("<F> <LIRE_FONCTION> 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
+++ /dev/null
-#@ 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("<F> <LIRE_INTE_SPEC> 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("<F> <LIRE_INTE_SPEC> 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("<F> <LIRE_INTE_SPEC> 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("<F> <LIRE_INTE_SPEC> 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("<F> <LIRE_INTE_SPEC> 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
+++ /dev/null
-#@ 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= "<F> <CREA_TABLE> 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= "<F> <CREA_TABLE> 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("<F> <LIRE_TABLE> 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
