+Version 1.11 (12/2006):
+ Mise en synchronisation avec la version 8.4 de Code_Aster de decembre 2006.
+ Première version du Traducteur de V7 en V8
+
Version 1.10 (6/2006):
Mise en synchronisation avec la version 8.3 de Code_Aster de juin 2006.
-#@ MODIF Graph Utilitai DATE 24/05/2005 AUTEUR MCOURTOI M.COURTOIS
+#@ MODIF Graph Utilitai DATE 02/05/2006 AUTEUR MCOURTOI M.COURTOIS
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# ======================================================================
# RESPONSABLE MCOURTOI M.COURTOIS
+__all__ = ['Graph', 'AjoutParaCourbe']
import sys
import os
self.Tri = []
self.Titre = ''
self.SousTitre = ''
- self.Min_X = 1.e+99
- self.Max_X = -1.e+99
- self.Min_Y = 1.e+99
+ self.Min_X = None
+ self.Max_X = None
+ self.Min_Y = None
+ self.Max_Y = None
self.MinP_X = 1.e+99 # minimum > 0 pour les échelles LOG
self.MinP_Y = 1.e+99
- self.Max_Y = -1.e+99
self.Legende_X = ''
self.Legende_Y = ''
self.Echelle_X = 'LIN'
self.Grille_Y = -1
# attributs que l'utilisateur ne doit pas modifier
self.NbCourbe = len(self.Valeurs)
- self.BBXmin = self.Min_X
- self.BBXmax = self.Max_X
- self.BBYmin = self.Min_Y
- self.BBYmax = self.Max_Y
+ self.BBXmin = 1.e+99
+ self.BBXmax = -1.e+99
+ self.BBYmin = 1.e+99
+ self.BBYmax = -1.e+99
# pour conserver les paramètres du dernier tracé
self.LastTraceArgs = {}
self.LastTraceFormat = ''
- return
+
# ------------------------------------------------------------------------------
- def SetExtrema(self,marge=0., x0=None, x1=None, y0=None, y1=None):
- """Remplit les limites du tracé (Min/Max_X/Y) avec les valeurs de la
+ def SetExtremaX(self,marge=0., x0=None, x1=None, force=True):
+ """Remplit les limites du tracé (Min/Max_X) avec les valeurs de la
bounding box +/- avec une 'marge'*(Max-Min)/2.
- x0,x1,y0,y1 permettent de modifier la bb.
+ x0,x1 permettent de modifier la bb.
"""
if x0<>None: self.BBXmin=min([self.BBXmin, x0])
if x1<>None: self.BBXmax=max([self.BBXmax, x1])
+
+ dx=max(self.BBXmax-self.BBXmin,0.01*self.BBXmax)
+ if dx == 0.:
+ dx = 1.e-6
+ if force or self.Min_X==None:
+ self.Min_X = self.BBXmin - marge*dx/2.
+ if force or self.Max_X==None:
+ self.Max_X = self.BBXmax + marge*dx/2.
+ return
+
+ def SetExtremaY(self,marge=0., y0=None, y1=None, force=True):
+ """Remplit les limites du tracé (Min/Max_Y) avec les valeurs de la
+ bounding box +/- avec une 'marge'*(Max-Min)/2.
+ y0,y1 permettent de modifier la bb.
+ """
if y0<>None: self.BBYmin=min([self.BBYmin, y0])
if y1<>None: self.BBYmax=max([self.BBYmax, y1])
- dx=max(self.BBXmax-self.BBXmin,0.01*self.BBXmax)
- self.Min_X = self.BBXmin - marge*dx/2.
- self.Max_X = self.BBXmax + marge*dx/2.
dy=max(self.BBYmax-self.BBYmin,0.01*self.BBYmax)
- self.Min_Y = self.BBYmin - marge*dy/2.
- self.Max_Y = self.BBYmax + marge*dy/2.
+ if dy == 0.:
+ dy = 1.e-6
+ if force or self.Min_Y==None:
+ self.Min_Y = self.BBYmin - marge*dy/2.
+ if force or self.Max_Y==None:
+ self.Max_Y = self.BBYmax + marge*dy/2.
+ return
+
+ def SetExtrema(self,marge=0., x0=None, x1=None, y0=None, y1=None, force=True):
+ """Remplit les limites du tracé (Min/Max_X/Y) avec les valeurs de la
+ bounding box +/- avec une 'marge'*(Max-Min)/2.
+ x0,x1,y0,y1 permettent de modifier la bb.
+ """
+ self.SetExtremaX(marge, x0, x1, force=force)
+ self.SetExtremaY(marge, y0, y1, force=force)
return
# ------------------------------------------------------------------------------
def AutoBB(self,debut=-1):
if opts<>{}:
kargs['opts']=opts
if not FORMAT in para.keys():
- print ' <A> <Objet Graph> Format inconnu : %s' % FORMAT
+ UTMESS('A', 'Objet Graph', 'Format inconnu : %s' % FORMAT)
else:
kargs['fmod']=para[FORMAT]['mode']
self.LastTraceArgs = kargs.copy()
# objet Graph sous-jacent
self.Graph=graph
# si Min/Max incohérents
- if graph.Min_X > graph.Max_X or graph.Min_Y > graph.Max_Y:
- graph.SetExtrema(marge=0.05)
- if graph.Min_X < 0. and graph.Echelle_X=='LOG':
- graph.Min_X=graph.MinP_X
- if graph.Min_Y < 0. and graph.Echelle_Y=='LOG':
- graph.Min_Y=graph.MinP_Y
+ if graph.Min_X==None or graph.Max_X==None or graph.Min_X > graph.Max_X:
+ graph.SetExtremaX(marge=0.05, force=True)
+ if graph.Min_Y==None or graph.Max_Y==None or graph.Min_Y > graph.Max_Y:
+ graph.SetExtremaY(marge=0.05, force=True)
+
+ if graph.Echelle_X=='LOG':
+ graph.Grille_X=10
+ # verif si Min<0 à cause de la marge
+ if graph.Min_X < 0.:
+ if graph.BBXmin < 0.:
+ UTMESS('A', 'Graph', 'On limite la fenetre aux abscisses positives.')
+ graph.Min_X=graph.MinP_X
+ if graph.Echelle_Y=='LOG':
+ graph.Grille_Y=10
+ if graph.Min_Y < 0.:
+ if graph.BBYmin < 0.:
+ UTMESS('A', 'Graph', 'On limite la fenetre aux ordonnées positives.')
+ graph.Min_Y=graph.MinP_Y
# formats de base (identiques à ceux du module Table)
self.DicForm={
# let's go
self.Trace()
- return
+
# ------------------------------------------------------------------------------
def __del__(self):
"""Fermeture du(des) fichier(s) à la destruction"""
# ------------------------------------------------------------------------------
def Entete(self):
"""Retourne l'entete"""
- raise StandardError, "Cette méthode doit etre définie par la classe fille."
+ raise NotImplementedError, "Cette méthode doit etre définie par la classe fille."
# ------------------------------------------------------------------------------
def DescrCourbe(self,**args):
"""Retourne la chaine de caractères décrivant les paramètres de la courbe.
"""
- raise StandardError, "Cette méthode doit etre définie par la classe fille."
+ raise NotImplementedError, "Cette méthode doit etre définie par la classe fille."
# ------------------------------------------------------------------------------
def Trace(self):
"""Méthode pour 'tracer' l'objet Graph dans un fichier.
Met en page l'entete, la description des courbes et les valeurs selon
le format et ferme le fichier.
"""
- raise StandardError, "Cette méthode doit etre définie par la classe fille."
+ raise NotImplementedError, "Cette méthode doit etre définie par la classe fille."
# ------------------------------------------------------------------------------
max0=max(abs(t0))
for i in range(1,g.NbCourbe):
if g.Courbe(i)['NbPts']<>g.Courbe(0)['NbPts']:
- msg.append(" <A> <TraceTableau> La courbe %d n'a pas le meme " \
+ msg.append("La courbe %d n'a pas le meme " \
"nombre de points que la 1ère." % i)
else:
ti=Numeric.array(g.Courbe(i)['Abs'])
if max(abs((ti-t0).flat)) > self.EPSILON*max0:
- msg.append(" <A> <TraceTableau> Courbe %d : écart entre les "\
+ msg.append("Courbe %d : écart entre les "\
"abscisses supérieur à %9.2E" % (i+1,self.EPSILON))
msg.append(" Utilisez IMPR_FONCTION pour interpoler " \
"les valeurs sur la première liste d'abscisses.")
Tab.Impr(FICHIER=self.NomFich[0], FORMAT='TABLEAU')
# erreurs ?
if msg:
- print '\n'.join(msg)
+ UTMESS('A', 'Graph.TraceTableau', '\n'.join(msg))
return
# ------------------------------------------------------------------------------
Met en page l'entete, la description des courbes et les valeurs selon
le format et ferme le fichier.
"""
- g=self.Graph
- if self.PILOTE=='INTERACTIF':
- self.NomFich[0]='Trace_'+time.strftime('%y%m%d%H%M%S',time.localtime())+'.dat'
- self.Fich[0]=open(self.NomFich[0],'w')
+ g = self.Graph
+ if self.PILOTE == 'INTERACTIF':
+ self.NomFich[0] = 'Trace_%s.dat' % time.strftime('%y%m%d%H%M%S',time.localtime())
+ self.Fich[0] = open(self.NomFich[0],'w')
# initialise le graph
self._FermFich()
nbsets, x0, x1, y0, y1 = IniGrace(self.NomFich[0])
NumSetIni = nbsets+1
- g.SetExtrema(0.05, x0, x1, y0, y1)
+ g.SetExtrema(0.05, x0, x1, y0, y1, force=False)
# si Min/Max incohérents
- if g.Min_X < 0. and g.Echelle_X=='LOG':
- g.Min_X=g.MinP_X
- if g.Min_Y < 0. and g.Echelle_Y=='LOG':
- g.Min_Y=g.MinP_Y
+ if g.Echelle_X=='LOG':
+ g.Grille_X=10
+ if g.Min_X < 0.:
+ if g.BBXmin < 0.:
+ UTMESS('A', 'TraceXmgrace', 'On limite la fenetre aux abscisses positives.')
+ g.Min_X=g.MinP_X
+ if g.Echelle_Y=='LOG':
+ g.Grille_Y=10
+ if g.Min_Y < 0.:
+ if g.BBYmin < 0.:
+ UTMESS('A', 'TraceXmgrace', 'On limite la fenetre aux ordonnées positives.')
+ g.Min_Y=g.MinP_Y
- self._OuvrFich()
- fich=self.Fich[0]
if g.NbCourbe < 1:
self._FermFich()
return
g.Grille_X=int(round(g.Grille_X))
if deltaY>4:
g.Grille_Y=int(round(g.Grille_Y))
+ if g.Grille_X == 0.:
+ g.Grille_X = 1.e-6
+ if g.Grille_Y == 0.:
+ g.Grille_Y = 1.e-6
# entete
- fich.write('\n'.join(self.Entete()))
- fich.write('\n')
+ content = self.Entete()
+ content.append('')
# valeurs
it=-1
for i in range(g.NbCourbe):
for k in range(dCi['NbCol']-1):
it=it+1
dCi['NumSet'] = NumSetIni + it
- fich.write('\n'.join(self.DescrCourbe(**dCi)))
- fich.write('\n')
+ content.extend(self.DescrCourbe(**dCi))
+ content.append('')
# partie données (.dat)
- lig=[]
it=-1
for i in range(g.NbCourbe):
dCi=g.Courbe(i)
for k in range(dCi['NbCol']-1):
it=it+1
- lig.append('@target g0.s%d' % (NumSetIni + it))
- lig.append('@type xy')
+ content.append('@target g0.s%d' % (NumSetIni + it))
+ content.append('@type xy')
listX, listY = Tri(g.Tri, lx=dCi['Abs'], ly=dCi['Ord'][k])
for j in range(dCi['NbPts']):
- svX=self.DicForm['formR'] % listX[j]
- svY=self.DicForm['formR'] % listY[j]
- lig.append(self.DicForm['formR'] % listX[j] + \
+ svX = self.DicForm['formR'] % listX[j]
+ svY = self.DicForm['formR'] % listY[j]
+ content.append(self.DicForm['formR'] % listX[j] + \
' ' + self.DicForm['formR'] % listY[j])
- lig.append('&')
- fich.write('\n'.join(lig))
- fich.write('\n')
- self._FermFich()
+ content.append('&')
+ content.append('')
# Production du fichier postscript, jpeg ou lancement interactif
pilo=self.PILOTE
- if self.PILOTE<>'':
+ if pilo == '':
+ self._OuvrFich()
+ self.Fich[0].write('\n'.join(content))
+ self._FermFich()
+ else:
xmgr=os.path.join(aster.repout(),'xmgrace')
- nfhard=self.NomFich[0]+'.hardcopy'
+ nfwrk = self.NomFich[0]+'.wrk'
+ open(nfwrk, 'w').write('\n'.join(content))
+ nfhard = self.NomFich[0]+'.hardcopy'
# nom exact du pilote
- if pilo=='POSTSCRIPT':
- pilo='PostScript'
- elif pilo=='INTERACTIF':
- pilo='X11'
+ if pilo == 'POSTSCRIPT':
+ pilo = 'PostScript'
+ elif pilo == 'INTERACTIF':
+ pilo = 'X11'
# ligne de commande
- if pilo=='X11':
- lcmde=xmgr+' '+self.NomFich[0]
+ if pilo == 'X11':
+ lcmde = '%s %s' % (xmgr, nfwrk)
if not os.environ.has_key('DISPLAY') or os.environ['DISPLAY']=='':
os.environ['DISPLAY']=':0.0'
UTMESS('A','TraceXmgrace','Variable DISPLAY non définie')
UTMESS('I','TraceXmgrace','on fixe le DISPLAY à %s' % os.environ['DISPLAY'])
else:
if os.path.exists(os.path.join(aster.repout(),'gracebat')):
- xmgr=os.path.join(aster.repout(),'gracebat')
- lcmde=xmgr+' -hdevice '+pilo+' -hardcopy -printfile '+nfhard+' '+self.NomFich[0]
+ xmgr = os.path.join(aster.repout(),'gracebat')
+ lcmde = '%s -hdevice %s -hardcopy -printfile %s %s' % (xmgr, pilo, nfhard, nfwrk)
# appel xmgrace
UTMESS('I','TraceXmgrace','Lancement de : '+lcmde)
if not os.path.exists(xmgr):
UTMESS('S','TraceXmgrace','Fichier inexistant : '+xmgr)
- iret=os.system(lcmde)
- if iret==0 or os.path.exists(nfhard):
- if pilo not in ['','X11']:
- os.remove(self.NomFich[0]) # necessaire sous windows
- os.rename(nfhard,self.NomFich[0])
+ iret = os.system(lcmde)
+ if iret == 0 or os.path.exists(nfhard):
+ if pilo not in ('', 'X11'):
+ new = open(nfhard, 'r').read()
+ open(self.NomFich[0], 'a').write(new)
else:
- UTMESS('A','TraceXmgrace',"Erreur lors de l'utilisation du filtre "+pilo+"\nLe fichier retourné est le fichier '.agr'")
+ UTMESS('A','TraceXmgrace', "Erreur lors de l'utilisation du filtre %s" \
+ "\nLe fichier retourné est le fichier '.agr'" % pilo)
# menage
- if self.PILOTE=='INTERACTIF':
+ if self.PILOTE == 'INTERACTIF':
os.remove(self.NomFich[0])
return
fnew.write(line)
fpre.close()
fnew.close()
- print """
+ try:
+ UTMESS('I', 'Graph.IniGrace', """
<I> Informations sur le fichier '%s' :
Nombre de courbes : %3d
Bornes des abscisses : [ %13.6G , %13.6G ]
Bornes des ordonnées : [ %13.6G , %13.6G ]
-""" % (fich, ns, x0, x1, y0, y1)
+""" % (fich, ns, x0, x1, y0, y1))
+ except TypeError:
+ # pas un format xmgrace
+ pass
return ns, x0, x1, y0, y1
--- /dev/null
+#@ MODIF Sensibilite Utilitai DATE 07/03/2006 AUTEUR MCOURTOI M.COURTOIS
+# -*- coding: iso-8859-1 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+
+"""
+"""
+
+from types import StringTypes
+import aster
+from Utilitai.Utmess import UTMESS
+
+# Doit etre en accord avec semeco.f
+prefix = '&NOSENSI.MEMO'
+nommem = '%-24s' % (prefix + '.CORR')
+
+def NomCompose(nomsd, nomps, msg='A'):
+ """Utilitaire analogue à la routine fortran PSRENC.
+ Retourne le nom composé à partir du couple (SD de base, paramètre sensible).
+ `msg` : 'A', 'F' ou 'silence' (pas de message)
+ """
+ nomcomp = None
+ vect = aster.getvectjev(nommem)
+ if not type(nomsd) in StringTypes:
+ nomsd = nomsd.get_name()
+ if not type(nomps) in StringTypes:
+ nomps = nomps.get_name()
+ if vect:
+ trouv = False
+ for ch in vect[0:len(vect):2]:
+ if ch[0:8].strip() == nomsd and ch[8:16].strip() == nomps:
+ trouv=True
+ nomcomp = ch[16:24].strip()
+ if not trouv and msg != 'silence':
+ UTMESS(msg, 'NomCompose', 'Dérivée de %s par rapport à %s non disponible'\
+ % (nomsd, nomps))
+ elif msg != 'silence':
+ UTMESS(msg, 'NomCompose', 'Pas de calcul de sensibilité accessible.')
+ return nomcomp
+
+def SdPara(nomcomp, msg='A'):
+ """Retourne le couple (SD de base, paramètre sensible) correspondant au nom
+ composé `nomcomp`.
+ `msg` : 'A', 'F' ou 'silence' (pas de message)
+ """
+ nomsd = None
+ nomps = None
+ vect = aster.getvectjev(nommem)
+ if not type(nomcomp) in StringTypes:
+ UTMESS('F', 'SdPara', "Argument de type '%s' invalide" % type(nomcomp).__name__)
+ if vect:
+ trouv = False
+ for ch in vect[0:len(vect):2]:
+ if ch[16:24].strip() == nomcomp:
+ trouv = True
+ nomsd = ch[0:8].strip()
+ nomps = ch[8:16].strip()
+ if not trouv and msg != 'silence':
+ UTMESS(msg, 'SdPara', 'Dérivée de %s par rapport à %s non disponible'\
+ % (nomsd, nomps))
+ elif msg != 'silence':
+ UTMESS(msg, 'SdPara', 'Pas de calcul de sensibilité accessible.')
+ return nomsd, nomps
--- /dev/null
+#@ MODIF System Utilitai DATE 29/08/2006 AUTEUR MCOURTOI M.COURTOIS
+# -*- coding: iso-8859-1 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2006 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.
+# ======================================================================
+
+
+"""Ce module définit la classe `SYSTEM` et la fonction `ExecCommand`
+qui est présente uniquement pour commodité pour les Macros.
+
+La classe SYSTEM est semblable à celle utilisée dans ASTK_SERV.
+"""
+
+__all__ = ["SYSTEM", "ExecCommand"]
+
+import sys
+import os
+import popen2
+import re
+from sets import Set
+from types import FileType
+
+# ----- differ messages translation
+def _(mesg):
+ return mesg
+
+#-------------------------------------------------------------------------------
+def _exitcode(status, default=0):
+ """Extrait le code retour du status. Retourne `default` si le process
+ n'a pas fini pas exit.
+ """
+ iret = default
+ if os.WIFEXITED(status):
+ iret = os.WEXITSTATUS(status)
+ return iret
+
+#-------------------------------------------------------------------------------
+#-------------------------------------------------------------------------------
+#-------------------------------------------------------------------------------
+class SYSTEM:
+ """Class to encapsultate "system" commands (this a simplified version of
+ ASTER_SYSTEM class defined in ASTK_SERV part).
+ """
+ # this value should be set during installation step.
+ MaxCmdLen = 1024
+ # line length -9
+ _LineLen = 80-9
+
+#-------------------------------------------------------------------------------
+ def __init__(self, **kargs):
+ """Initialization.
+ Optionnal arguments : silent, verbose, debug, cc_files, maxcmdlen.
+ """
+ self.verbose = kargs.get('verbose', True)
+ self.debug = kargs.get('debug', False)
+ self.cc_files = kargs.get('cc_files', None)
+ if kargs.has_key('maxcmdlen'):
+ self.MaxCmdLen = kargs['maxcmdlen']
+
+#-------------------------------------------------------------------------------
+ def _mess(self, msg, cod=''):
+ """Just print a message
+ """
+ self._print('%-18s %s' % (cod, msg))
+
+#-------------------------------------------------------------------------------
+ def _print(self, *args, **kargs):
+ """print replacement.
+ Optionnal argument :
+ term : line terminator (default to os.linesep).
+ """
+ term = kargs.get('term', os.linesep)
+ files = Set([sys.stdout])
+ if self.cc_files:
+ files.add(self.cc_files)
+ for f in files:
+ if type(f) is FileType:
+ txt = ' '.join(['%s'%a for a in args])
+ f.write(txt.replace(os.linesep+' ', os.linesep)+term)
+ f.flush()
+ else:
+ print _('FileType object expected : %s / %s') % (type(f), repr(f))
+
+#-------------------------------------------------------------------------------
+ def VerbStart(self, cmd, verbose=None):
+ """Start message in verbose mode
+ """
+ Lm = self._LineLen
+ if verbose == None:
+ verbose = self.verbose
+ if verbose:
+ pcmd = cmd
+ if len(cmd) > Lm-2 or cmd.count('\n') > 0:
+ pcmd = pcmd+'\n'+' '*Lm
+ self._print(('%-'+str(Lm)+'s') % (pcmd,), term='')
+
+#-------------------------------------------------------------------------------
+ def VerbEnd(self, iret, output='', verbose=None):
+ """Ends message in verbose mode
+ """
+ if verbose == None:
+ verbose = self.verbose
+ if verbose:
+ if iret == 0:
+ self._print('[ OK ]')
+ else:
+ self._print(_('[FAILED]'))
+ self._print(_('Exit code : %d') % iret)
+ if (iret != 0 or self.debug) and output:
+ self._print(output)
+
+#-------------------------------------------------------------------------------
+ def VerbIgnore(self, verbose=None):
+ """Ends message in verbose mode
+ """
+ if verbose == None:
+ verbose = self.verbose
+ if verbose:
+ self._print(_('[ SKIP ]'))
+
+#-------------------------------------------------------------------------------
+ def Shell(self, cmd, bg=False, verbose=None, follow_output=False,
+ alt_comment=None, interact=False):
+ """Execute a command shell
+ cmd : command
+ bg : put command in background if True
+ verbose : print status messages during execution if True
+ follow_output : follow interactively output of command
+ alt_comment : print this "alternative comment" instead of "cmd"
+ interact : allow the user to interact with the process
+ (don't close stdin). bg=True implies interact=False.
+ Return :
+ iret : exit code if bg = False,
+ process id if bg = True
+ output : output lines (as string)
+ """
+ if not alt_comment:
+ alt_comment = cmd
+ if verbose == None:
+ verbose = self.verbose
+ if bg:
+ interact = False
+ if len(cmd) > self.MaxCmdLen:
+ self._mess((_('length of command shell greater '\
+ 'than %d characters.') % self.MaxCmdLen), _('<A>_ALARM'))
+ if self.debug:
+ self._print('<DBG> <local_shell>', cmd)
+ self._print('<DBG> <local_shell> background mode : ', bg)
+ # exec
+ self.VerbStart(alt_comment, verbose=verbose)
+ if follow_output and verbose:
+ self._print(_('\nCommand output :'))
+ # run interactive command
+ if interact:
+ iret = os.system(cmd)
+ return _exitcode(iret), ''
+ # use popen to manipulate stdout/stderr
+ output = []
+ p = popen2.Popen4(cmd)
+ p.tochild.close()
+ if not bg:
+ if not follow_output:
+ output = p.fromchild.readlines()
+ else:
+ while p.poll() == -1:
+ output.append(p.fromchild.readline())
+ # \n already here...
+ self._print(output[-1], term='')
+ # to be sure to empty the buffer
+ end = p.fromchild.readlines()
+ self._print(''.join(end))
+ output.extend(end)
+ iret = _exitcode(p.wait())
+ else:
+ iret = 0
+ p.fromchild.close()
+ output = ''.join(output)
+
+ # repeat header message
+ if follow_output:
+ self.VerbStart(alt_comment, verbose=verbose)
+ mat = re.search('EXIT_CODE=([0-9]+)', output)
+ if mat:
+ iret = int(mat.group(1))
+ self.VerbEnd(iret, output, verbose=verbose)
+ if bg:
+ iret = p.pid
+ if verbose:
+ self._print(_('Process ID : '), iret)
+ return iret, output
+
+#-------------------------------------------------------------------------------
+# Juste par commodité.
+system = SYSTEM()
+ExecCommand = system.Shell
+
+
+#-------------------------------------------------------------------------------
+#-------------------------------------------------------------------------------
+#-------------------------------------------------------------------------------
+if __name__ == '__main__':
+ iret, output = ExecCommand('ls', alt_comment='Lancement de la commande...')
+
-#@ MODIF Table Utilitai DATE 17/05/2005 AUTEUR DURAND C.DURAND
+#@ MODIF Table Utilitai DATE 06/11/2006 AUTEUR MCOURTOI M.COURTOIS
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# ======================================================================
# RESPONSABLE MCOURTOI M.COURTOIS
+__all__ = ['Table', 'merge']
import sys
-import string
import re
+from copy import copy
-from types import *
-EnumTypes=(ListType, TupleType)
-NumberTypes=(IntType, LongType, FloatType, ComplexType)
+from types import ListType, TupleType, IntType, LongType, FloatType, ComplexType, \
+ DictType, StringType, StringTypes, UnicodeType, NoneType
+EnumTypes = (ListType, TupleType)
+NumberTypes = (IntType, LongType, FloatType, ComplexType)
+
+import transpose
# try/except pour utiliser hors aster
try:
from Utilitai.Utmess import UTMESS
except ImportError:
def UTMESS(code,sprg,texte):
- fmt='\n <%s> <%s> %s\n\n'
- print fmt % (code,sprg,texte)
+ fmt = '\n <%s> <%s> %s\n\n'
+ if code == 'F':
+ raise StandardError, fmt % (code,sprg,texte)
+ else:
+ print fmt % (code,sprg,texte)
if not sys.modules.has_key('Graph'):
try:
import Graph
# formats de base (identiques à ceux du module Graph)
-DicForm={
+DicForm = {
'csep' : ' ', # séparateur
'ccom' : '#', # commentaire
'cdeb' : '', # début de ligne
'cfin' : '\n', # fin de ligne
+ 'sepch' : ';', # séparateur entre deux lignes d'une cellule
'formK' : '%-8s', # chaines
'formR' : '%12.5E', # réels
'formI' : '%8d' # entiers
}
+# type par défaut des chaines de caractères
+Kdef = 'K24'
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
(c'est surtout utile pour vérifier que l'extraction et les filtres sur les
colonnes sont corrects).
"""
+ def __init__(self):
+ """Constructeur.
+ """
+ self.rows=None
+ self.para=None
+ self.type=None
+ self.titr=None
+
def __repr__(self):
return self.ReprTable()
- def Croise(self,**kargs):
- raise StandardError, 'Must be defined in a derived class'
+ def Croise(self, **kargs):
+ raise NotImplementedError, 'Must be defined in a derived class'
+
+ def __len__(self):
+ """Retourne le nombre de ligne dans la Table/Colonne.
+ """
+ return len(self.rows)
# ------------------------------------------------------------------------------
- def Impr(self,FICHIER=None,FORMAT='TABLEAU',dform=None,**opts):
+ def Impr(self, FICHIER=None, FORMAT='TABLEAU', dform=None, **opts):
"""Impresssion de la Table selon le format spécifié.
FICHIER : nom du(des) fichier(s). Si None, on dirige vers stdout
dform : dictionnaire de formats d'impression (format des réels,
'dform' : DicForm.copy(),
'mode' : para[FORMAT]['mode'],
}
- if dform<>None and type(dform)==DictType:
+ if dform != None and type(dform) == DictType:
kargs['dform'].update(dform)
# ajout des options
kargs.update(opts)
else:
if not type(kargs['PAGINATION']) in EnumTypes:
- ppag=[kargs['PAGINATION'],]
+ ppag = [kargs['PAGINATION'],]
else:
- ppag=list(kargs['PAGINATION'])
+ ppag = list(kargs['PAGINATION'])
del kargs['PAGINATION']
- npag=len(ppag)
+ npag = len(ppag)
# paramètres hors ceux de la pagination
- lkeep=[p for p in self.para if ppag.count(p)==0]
+ lkeep = [p for p in self.para if ppag.count(p)==0]
# création des listes des valeurs distinctes
- lvd=[]
+ lvd = []
for p in ppag:
- lvp=getattr(self,p).values()
- lvn=[]
+ lvp = getattr(self,p).values()
+ lvn = []
for it in lvp:
- if it<>None and lvn.count(it)==0:
+ if it != None and lvn.count(it) == 0:
lvn.append(it)
lvn.sort()
lvd.append(lvn)
# création des n-uplets
- s = '[['+','.join(['x'+str(i) for i in range(npag)])+'] '
- s+= ' '.join(['for x'+str(i)+' in lvd['+str(i)+']' for i in range(npag)])+']'
+ s = '[['+','.join(['x'+str(i) for i in range(npag)])+'] '
+ s += ' '.join(['for x'+str(i)+' in lvd['+str(i)+']' for i in range(npag)])+']'
try:
- lnup=eval(s)
+ lnup = eval(s)
except SyntaxError, s:
UTMESS('F','Table','Erreur lors de la construction des n-uplets')
# pour chaque n-uplet, on imprime la sous-table
for nup in lnup:
- tab=self
+ tab = self
for i in range(npag):
tab = tab & (getattr(tab,ppag[i]) == nup[i])
- sl=''
+ sl = ''
if tab.titr: sl='\n'
tab.titr += sl+ppag[i]+': '+str(nup[i])
tab[lkeep].Impr(**kargs)
if kargs.get('FICHIER')<>None:
f.close()
- def ReprTable(self,FORMAT='TABLEAU',dform=DicForm,**ignore):
+# ------------------------------------------------------------------------------
+ def ReprTable(self,FORMAT='TABLEAU',dform=None,**ignore):
"""Représentation d'une Table ou d'une Colonne sous forme d'un tableau.
"""
rows=self.rows
if not type(para) in EnumTypes:
para=[self.para,]
typ =[self.type,]
+ if dform==None:
+ dform = DicForm.copy()
# est-ce que l'attribut .type est renseigné ?
typdef=typ<>[None]*len(typ)
txt=[]
if typdef:
stype=dform['csep'].join([''] + \
[FMT(dform,'formK',typ[i],lmax[i]) % typ[i] for i in range(len(para))])
- txt.append('')
- txt.append('-'*80)
- txt.append('')
+ txt.append(dform['ccom'])
+ txt.append(dform['ccom']+'-'*80)
+ txt.append(dform['ccom'])
ASTER=(FORMAT=='ASTER')
if ASTER:
txt.append('#DEBUT_TABLE')
if ASTER:
txt.extend(['#TITRE '+lig for lig in self.titr.split('\n')])
else:
- txt.append(self.titr)
+ txt.extend([dform['ccom']+lig for lig in self.titr.split('\n')])
txt.append(dform['csep'].join(lspa))
if ASTER and typdef:
txt.append(stype)
if type(rep) is FloatType:
lig.append(FMT(dform,'formR',t,lmax[i]) % rep)
empty=False
- elif type(rep) is IntType:
+ elif type(rep) in (IntType, LongType):
lig.append(FMT(dform,'formI',t,lmax[i]) % rep)
empty=False
else:
s='\\'+s
lig.append(s)
if not empty:
- txt.append(dform['csep'].join(lig))
+ lig2 = [dform['sepch'].join(ch.splitlines()) for ch in lig]
+ txt.append(dform['csep'].join(lig2))
if ASTER:
txt.append('#FIN_TABLE')
+ # ajout du debut de ligne
+ if dform['cdeb']<>'':
+ txt=[dform['cdeb']+t for t in txt]
+
return dform['cfin'].join(txt)
# ------------------------------------------------------------------------------
def ImprTabCroise(self,**kargs):
kargs['FORMAT']='TABLEAU'
tabc.Impr(**kargs)
# ------------------------------------------------------------------------------
- def ImprGraph(self,**kargs):
+ def ImprGraph(self, **kargs):
"""Impression au format XMGRACE : via le module Graph
"""
args=kargs.copy()
- if len(self.para)<>2:
- UTMESS('A','Table','La table doit avoir exactement deux paramètres.')
+ if len(self.para) != 2:
+ UTMESS('A','Table','La table doit avoir exactement deux paramètres '\
+ 'pour une impression au format XMGRACE.')
return
- lx, ly = [[v for v in getattr(self,p).values() if v<>None] for p in self.para]
+ # suppression des lignes contenant une cellule vide
+ tnv = getattr(self, self.para[0]).NON_VIDE() \
+ & getattr(self, self.para[1]).NON_VIDE()
# objet Graph
graph=Graph.Graph()
dicC={
- 'Val' : [lx, ly],
- 'Lab' : self.para,
+ 'Val' : [getattr(tnv, tnv.para[0]).values(),
+ getattr(tnv, tnv.para[1]).values()],
+ 'Lab' : tnv.para,
}
if args['LEGENDE']==None: del args['LEGENDE']
Graph.AjoutParaCourbe(dicC, args)
t.a retourne un objet intermédiaire de la classe Colonne qui mémorise
le nom de la colonne demandée (a, ici).
"""
+# ------------------------------------------------------------------------------
def __init__(self, rows=[], para=[], typ=[], titr=''):
"""Constructeur de la Table :
rows : liste des lignes (dict)
type : liste des types des paramètres
titr : titre de la table
"""
- self.rows=[r for r in rows if r.values()<>[None]*len(r.values())]
- self.para=list(para)
- if len(typ)==len(self.para):
- self.type=list(typ)
+ self.rows = [r for r in rows if r.values() != [None]*len(r.values())]
+ self.para = list(para)
+ for i in self.para :
+ if self.para.count(i) != 1 :
+ UTMESS('F','Table','Parametre en double: %s' %i)
+ if len(typ) == len(self.para):
+ self.type = list(typ)
else:
- self.type=[None]*len(self.para)
- self.titr=titr
+ self.type = [None]*len(self.para)
+ self.titr = titr
+
+# ------------------------------------------------------------------------------
+ def copy(self):
+ """Retourne une copie de la table.
+ """
+ rows = []
+ for r in self.rows:
+ rows.append(copy(r))
+ return Table(rows, self.para[:], self.type[:], self.titr)
+# ------------------------------------------------------------------------------
def append(self, obj):
- """Ajoute une ligne (type dict) à la Table"""
+ """Ajoute une ligne (type dict) qui peut éventuellement définir un
+ nouveau paramètre."""
+ para=obj.keys()
+ for p in para:
+ if not p in self.para:
+ self.para.append(p)
+ self.type.append(_typaster(obj[p]))
+ else:
+ ip=self.para.index(p)
+ self.type[ip]=_typaster(obj[p], self.type[ip])
self.rows.append(obj)
+# ------------------------------------------------------------------------------
+ def SansColonneVide(self):
+ """Retourne une copie de la table dans laquelle on a supprimé les colonnes
+ vides (les lignes vides sont automatiquement supprimées).
+ """
+ tab = self.copy()
+ lp = tab.para[:]
+ for para in lp:
+ if len(tab[para]) == 0:
+ bid = lp.pop(0)
+ return tab[lp]
+
+# ------------------------------------------------------------------------------
+ def __setitem__(self, k_para, k_value):
+ """Ajoute une colonne k_para dont les valeurs sont dans k_value"""
+ if len(k_value)==0:
+ return
+ if k_para in self.para :
+ UTMESS('F','Table','(setitem) Le parametre %s existe déjà.' % k_para)
+ self.para.append(k_para)
+ self.type.append(_typaster(k_value[0]))
+ i=0
+ for row in self:
+ if i<len(k_value):
+ row[k_para]=k_value[i]
+ self.type[-1]=_typaster(k_value[i], self.type[-1])
+ else:
+ row[k_para]=None
+ i+=1
+ for j in range(i,len(k_value)):
+ self.append({k_para:k_value[j]})
+
+# ------------------------------------------------------------------------------
+ def fromfunction(self, nom_para, funct, l_para=None, const=None):
+ """Ajoute une colonne `nom_para` en évaluant la fonction `funct` sur
+ la valeur des paramètres `l_para` (qui doivent exister dans la table).
+ Si `l_para` n'est pas fourni, on prend `funct`.nompar (FORMULE Aster).
+ On peut passer un dictionnaire de constantes dans `const`. Quand on
+ utilise une FORMULE Aster, les constantes sont prises dans le contexte
+ global.
+ """
+ # vérif préalables
+ if not hasattr(funct, '__call__'):
+ UTMESS('F', 'Table', "(fromfunction) '%s' n'a pas d'attribut '__call__'." \
+ % funct.__name__)
+ if nom_para in self.para :
+ UTMESS('F','Table','Le parametre %s existe déjà.' % nom_para)
+ if l_para == None:
+ if not hasattr(funct, 'nompar'):
+ UTMESS('F', 'Table', "(fromfunction) '%s' n'a pas d'attribut 'nompar'." \
+ % funct.__name__)
+ l_para = funct.nompar
+ if not type(l_para) in EnumTypes:
+ l_para = [l_para]
+ not_found = ', '.join([p for p in l_para if not p in self.para])
+ if not_found != '':
+ UTMESS('F','Table','Parametre(s) absent(s) de la table : %s' % not_found)
+ if const == None:
+ const = {}
+ if type(const) is not DictType:
+ UTMESS('F', 'Table', "L'argument 'const' doit etre de type 'dict'.")
+ # liste des valeurs des paramètres
+ tabpar = []
+ for para in l_para:
+ vals = getattr(self, para).values()
+ tabpar.append(vals)
+ tabpar = transpose.transpose(tabpar)
+ # évaluation de la fonction sur ces paramètres
+ vectval = []
+ for lpar in tabpar:
+ # si un paramètre est absent, on ne peut pas évaluer la formule
+ if None in lpar:
+ vectval.append(None)
+ else:
+ vectval.append(funct(*lpar, **const))
+ # ajout de la colonne
+ self[nom_para] = vectval
+
+# ------------------------------------------------------------------------------
def __iter__(self):
"""Itère sur les lignes de la Table"""
return iter(self.rows)
+# ------------------------------------------------------------------------------
def __getattr__(self, column):
"""Construit un objet intermediaire (couple table, colonne)"""
typ=None
typ=self.type[self.para.index(column)]
return Colonne(self, column, typ)
+# ------------------------------------------------------------------------------
def sort(self, CLES=None, ORDRE='CROISSANT'):
"""Tri de la table.
CLES : liste des clés de tri
- ORDRE : CROISSANT ou DECROISSANT (de longueur 1 ou len(keys))
+ ORDRE : CROISSANT ou DECROISSANT
"""
# par défaut, on prend tous les paramètres
- if CLES==None:
- CLES=self.para[:]
+ if CLES == None:
+ CLES = self.para[:]
+ # vérification des arguments
if not type(CLES) in EnumTypes:
- CLES=[CLES,]
+ CLES = [CLES]
else:
- CLES=list(CLES)
- self.rows=sort_table(self.rows, self.para, CLES, (ORDRE=='DECROISSANT'))
-# if not type(order) in EnumTypes:
-# order=[order,]
-# print 'TRI clés=%s, order=%s' % (keys,order)
-# # on ne garde que le premier si les longueurs sont différentes
-# if len(order)<>len(keys):
-# order=[order[0],]
-# else:
-# # si toutes les valeurs sont identiques, on peut ne garder que la 1ère
-# d={}
-# for o in order: d[o]=None
-# if len(order)<>len(keys) or len(d.keys())==1:
-# order=[order[0],]
-# if len(order)==1:
-# self.rows=sort_table(self.rows, self.para, keys, (order[0]=='DECROISSANT'))
-# else:
-# # de la dernière clé à la première
-# for k,o in [(keys[i],order[i]) for i in range(len(keys)-1,-1,-1)]:
-# print 'TRI : clé=%s, order=%s' % (k,o)
-# self.rows=sort_table(self.rows, self.para, [k], (o=='DECROISSANT'))
+ CLES = list(CLES)
+ not_found = ', '.join([p for p in CLES if not p in self.para])
+ if not_found != '':
+ UTMESS('F', 'Table', 'Parametre(s) absent(s) de la table : %s' % not_found)
+ if not ORDRE in ('CROISSANT', 'DECROISSANT'):
+ UTMESS('F', 'Table', 'Valeur incorrecte pour ORDRE : %s' % ORDRE)
+ # tri
+ self.rows = sort_table(self.rows, self.para, CLES, (ORDRE=='DECROISSANT'))
+# ------------------------------------------------------------------------------
def __delitem__(self, args):
"""Supprime les colonnes correspondantes aux éléments de args """
if not type(args) in EnumTypes:
for item in args:
del new_type[new_para.index(item)]
new_para.remove(item)
- for line in new_rows : del line[item]
+ for line in new_rows:
+ del line[item]
return Table(new_rows, new_para, new_type, self.titr)
+# ------------------------------------------------------------------------------
def __getitem__(self, args):
"""Extrait la sous table composée des colonnes dont les paramètres sont dans args """
if not type(args) in EnumTypes:
args=[args,]
else:
args=list(args)
- #print '<getitem> args=',args
new_rows=[]
new_para=args
new_type=[]
new_rows.append(new_line)
return Table(new_rows, new_para, new_type, self.titr)
+# ------------------------------------------------------------------------------
def __and__(self, other):
"""Intersection de deux tables (opérateur &)"""
if other.para<>self.para:
tmp = [ r for r in self if r in other.rows ]
return Table(tmp, self.para, self.type, self.titr)
+# ------------------------------------------------------------------------------
def __or__(self, other):
"""Union de deux tables (opérateur |)"""
if other.para<>self.para:
tmp.extend([ r for r in other if r not in self ])
return Table(tmp, self.para, self.type[:], self.titr)
+# ------------------------------------------------------------------------------
def values(self):
"""Renvoie la table sous la forme d'un dictionnaire de listes dont les
clés sont les paramètres.
dico[column]=Colonne(self, column).values()
return dico
+# ------------------------------------------------------------------------------
+ def dict_CREA_TABLE(self):
+ """Renvoie le dictionnaire des mots-clés à fournir à la commande CREA_TABLE
+ pour produire une table_sdaster.
+ """
+ dico={ 'TITRE' : ['%-80s' % lig for lig in self.titr.split('\n')],
+ 'LISTE' : [], }
+ # remplissage de chaque occurence (pour chaque paramètre) du mot-clé facteur LISTE
+ for i in range(len(self.para)):
+ # nom du paramètre et type si K*
+ d={ 'PARA' : self.para[i], }
+ typ=self.type[i]
+ if typ==None:
+ UTMESS('F', 'Table', 'Type du paramètre %s non défini.' %\
+ self.para[i])
+ elif typ[0]=='K':
+ mc='LISTE_K'
+ if not typ in ('K8', 'K16', 'K24'):
+ UTMESS('A','Table','Type du paramètre %s forcé à %s' % (self.para[i],Kdef))
+ typ=Kdef
+ d['TYPE_K']=typ
+ elif typ=='I':
+ mc='LISTE_I'
+ elif typ=='R':
+ mc='LISTE_R'
+ # valeurs sans trou / avec trou
+ vals=getattr(self, self.para[i]).values()
+ if vals.count(None)==0:
+ d[mc]=vals
+ else:
+ d['NUME_LIGN'] = [j+1 for j in range(len(vals)) if vals[j]<>None]
+ d[mc] = [v for v in vals if v <>None]
+ if len(d[mc])==0:
+ UTMESS('I','Table','Colonne %s vide' % self.para[i])
+ else:
+ dico['LISTE'].append(d)
+ if len(dico['LISTE'])==0:
+ UTMESS('F','Table','La table est vide')
+ return dico
+
+# ------------------------------------------------------------------------------
def Array(self,Para,Champ):
"""Renvoie sous forme de NumArray le résultat d'une extraction dans une table
méthode utile à macr_recal
"""
import Numeric
__Rep = self[Para,Champ].values()
- F=Numeric.zeros((len(__Rep[Para]),2),Numeric.Float)
+ F = Numeric.zeros((len(__Rep[Para]),2), Numeric.Float)
for i in range(len(__Rep[Para])):
- F[i][0] = __Rep[Para][i]
- F[i][1] = __Rep[Champ][i]
+ F[i][0] = __Rep[Para][i]
+ F[i][1] = __Rep[Champ][i]
del(__Rep)
return F
+# ------------------------------------------------------------------------------
def Croise(self):
"""Retourne un tableau croisé P3(P1,P2) à partir d'une table ayant
trois paramètres (P1, P2, P3).
"""
if len(self.para)<>3:
- UTMESS('A','Table','La table doit avoir exactement trois paramètres.')
+ UTMESS('A', 'Table', 'La table doit avoir exactement trois paramètres.')
return Table()
py, px, pz = self.para
ly, lx, lz = [getattr(self,p).values() for p in self.para]
new_titr+=pz + ' FONCTION DE ' + px + ' ET ' + py
return Table(new_rows, new_para, new_type, new_titr)
+# ------------------------------------------------------------------------------
+ def Renomme(self, pold, pnew):
+ """Renomme le paramètre `pold` en `pnew`.
+ """
+ if not pold in self.para:
+ raise KeyError, 'Paramètre %s inexistant dans cette table' % pold
+ elif self.para.count(pnew)>0:
+ raise KeyError, 'Le paramètre %s existe déjà dans la table' % pnew
+ else:
+ self.para[self.para.index(pold)] = pnew
+ for lig in self:
+ lig[pnew] = lig[pold]
+ del lig[pold]
+
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
Alors on peut écrire la requete simple :
soustable=t.a<10
Ainsi que des requetes plus complexes :
- soustable=t.a<10 & t.b <4
+ soustable=t.a<10 and t.b <4
ou
- soustable=t.a<10 | t.b <4
+ soustable=t.a<10 or t.b <4
Les "alias" EQ, NE, LE, LT, GE, GT permettent à la macro IMPR_TABLE
d'utiliser directement le mot-clé utilisateur CRIT_COMP défini dans le
catalogue : getattr(Table,CRIT_COMP).
"""
+# ------------------------------------------------------------------------------
def __init__(self, table, column, typ=None):
"""Constructeur (objet Table associé, paramètre de la colonne, type du
paramètre).
self.type=typ
self.titr=''
+# ------------------------------------------------------------------------------
def _extract(self, fun):
"""Construit une table avec les lignes de self.Table
dont l'élément de nom self.para satisfait le critère fun,
"""
return Table([row for row in self.Table if fun(row.get(self.para))], self.Table.para, self.Table.type, self.Table.titr)
+# ------------------------------------------------------------------------------
def __le__(self, VALE):
return self._extract(lambda v: v<>None and v<=VALE)
+# ------------------------------------------------------------------------------
def __lt__(self, VALE):
return self._extract(lambda v: v<>None and v<VALE)
+# ------------------------------------------------------------------------------
def __ge__(self, VALE):
return self._extract(lambda v: v<>None and v>=VALE)
+# ------------------------------------------------------------------------------
def __gt__(self, VALE):
return self._extract(lambda v: v<>None and v>VALE)
+# ------------------------------------------------------------------------------
def __eq__(self, VALE, CRITERE='RELATIF', PRECISION=0.):
if type(VALE) in EnumTypes :
return self._extract(lambda v: v in VALE)
vmax=(1.+PRECISION)*VALE
return self._extract(lambda v: v<>None and vmin<v<vmax)
+# ------------------------------------------------------------------------------
+ def REGEXP(self, regexp):
+ """Retient les lignes dont le paramètre satisfait l'expression
+ régulière `regexp`.
+ """
+ if not type(regexp) in StringTypes:
+ return self._extract(lambda v : False)
+ return self._extract(lambda v : v != None and re.search(regexp, v) != None)
+
+# ------------------------------------------------------------------------------
def __ne__(self, VALE, CRITERE='RELATIF', PRECISION=0.):
if type(VALE) in EnumTypes :
return self._extract(lambda v: v not in VALE)
vmax=(1.+PRECISION)*VALE
return self._extract(lambda v: v<>None and (v<vmin or vmax<v))
+# ------------------------------------------------------------------------------
def MAXI(self):
# important pour les performances de récupérer le max une fois pour toutes
maxi=max(self)
return self._extract(lambda v: v==maxi)
+# ------------------------------------------------------------------------------
def MINI(self):
# important pour les performances de récupérer le min une fois pour toutes
mini=min(self)
return self._extract(lambda v: v==mini)
+# ------------------------------------------------------------------------------
def ABS_MAXI(self):
# important pour les performances de récupérer le max une fois pour toutes
abs_maxi=max([abs(v) for v in self.values() if type(v) in NumberTypes])
return self._extract(lambda v: v==abs_maxi or v==-abs_maxi)
+# ------------------------------------------------------------------------------
def ABS_MINI(self):
# important pour les performances de récupérer le min une fois pour toutes
abs_mini=min([abs(v) for v in self.values() if type(v) in NumberTypes])
# tester le type de v est trop long donc pas de abs(v)
return self._extract(lambda v: v==abs_mini or v==-abs_mini)
+# ------------------------------------------------------------------------------
def __iter__(self):
"""Itère sur les éléments de la colonne"""
for row in self.Table:
yield row.get(self.para)
#yield row[self.para]
+# ------------------------------------------------------------------------------
def __getitem__(self, i):
"""Retourne la ième valeur d'une colonne"""
return self.values()[i]
+# ------------------------------------------------------------------------------
def values(self):
"""Renvoie la liste des valeurs"""
- return [r[self.para] for r in self.Table]
+ return [r.get(self.para,None) for r in self.Table]
+
+ def not_none_values(self):
+ """Renvoie la liste des valeurs non 'None'"""
+ return [val for val in self.values() if val != None]
+# ------------------------------------------------------------------------------
# équivalences avec les opérateurs dans Aster
LE=__le__
LT=__lt__
GT=__gt__
EQ=__eq__
NE=__ne__
- def VIDE(self) : return self.__eq__(None)
- def NON_VIDE(self): return self.__ne__(None)
+ def VIDE(self):
+ return self.__eq__(None)
+ def NON_VIDE(self):
+ return self.__ne__(None)
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
-def sort_table(rows,l_para,w_para,reverse=False):
+def sort_table(rows, l_para, w_para, reverse=False):
"""Sort list of dict.
rows : list of dict
l_para : list of the keys of dict
"""
c_para=[i for i in l_para if i not in w_para]
new_rows=rows
+ # rename sort keys by "__" + number + para
+ # ("__" to avoid conflict with existing parameters)
for i in w_para :
new_key= '__'+str(w_para.index(i))+i
for row in new_rows :
row[new_key]=row[i]
del row[i]
+ # rename others parameters by "___" + para
+ # ("___" to be after sort keys)
for i in c_para :
new_key= '___'+i
for row in new_rows :
row[new_key]=row[i]
del row[i]
+ # sort
new_rows.sort()
+ # reversed sort
if reverse:
new_rows.reverse()
for i in w_para :
if nform=='formK':
# convertit %12.5E en %-12s
fmt=re.sub('([0-9]+)[\.0-9]*[diueEfFgG]+','-\g<1>s',dform['form'+typAster])
- #print nform, typAster, fmt
else:
fmt=dform[nform]
else:
return fmt
# ------------------------------------------------------------------------------
+def merge(tab1, tab2, labels=[]):
+ """Assemble les deux tables tb1 et tb2 selon une liste de labels communs.
+ Si labels est vide:
+ - les lignes de tb2 sont ajoutés à celles de tb1,
+ sinon :
+ - si on trouve les valeurs de tb2 sur les labels dans tb1 (et une seule fois),
+ on surcharge tb1 avec les lignes de tb2 ;
+ - sinon on ajoute la ligne de tb2 à la fin de tb1.
+ """
+ tb1 = tab1.copy()
+ tb2 = tab2.copy()
+ if type(labels) not in EnumTypes:
+ labels=(labels,)
+ for key in labels :
+ if key not in tb1.para : UTMESS('F','Table','Erreur, label non présent %s' % key)
+ if key not in tb2.para : UTMESS('F','Table','Erreur, label non présent %s' % key)
+ # ensemble des paramètres et des types
+ n_para=tb1.para[:]
+ n_type=tb1.type[:]
+ for i in tb2.para:
+ if i not in tb1.para:
+ n_para.append(i)
+ n_type.append(tb2.type[tb2.para.index(i)])
+ # restriction des lignes aux labels communs (peu cher en cpu)
+ rows1 = tb1.rows
+ dlab1 = {}
+ for i1 in range(len(rows1)):
+ tu1 = tuple(map(rows1[i1].__getitem__, labels))
+ if dlab1.get(tu1, '') == '':
+ dlab1[tu1] = i1
+ else:
+ dlab1[tu1] = None
+ # restriction des lignes aux labels communs (peu cher en cpu)
+ rows2 = tb2.rows
+ dlab2 = {}
+ for i2 in range(len(rows2)):
+ tu2 = tuple(map(rows2[i2].__getitem__, labels))
+ if dlab2.get(tu2, '') == '':
+ dlab2[tu2] = i2
+ else:
+ dlab2[tu2] = None
+ # creation de dic1 : dictionnaire de correspondance entre les
+ # lignes a merger dans les deux tableaux
+ dic1 = {}
+ for cle in dlab1.keys():
+ if dlab1[cle] == None or cle == ():
+ bid = dlab1.pop(cle)
+ for cle in dlab2.keys():
+ if dlab2[cle] == None or cle == ():
+ bid = dlab2.pop(cle)
+ for cle in dlab2.keys():
+ if dlab1.has_key(cle):
+ dic1[dlab2[cle]] = dlab1[cle]
+ # insertion des valeurs de tb2 dans tb1 quand les labels sont communs
+ # (et uniques dans chaque table) OU ajout de la ligne de tb2 dans tb1
+ i2 = -1
+ for r2 in rows2:
+ i2 += 1
+ try:
+ rows1[dic1[i2]].update(r2)
+ except KeyError:
+ rows1.append(r2)
+ # concaténation des titres + info sur le merge
+ tit = '\n'.join([tb1.titr, tb2.titr, 'MERGE avec labels=%s' % repr(labels)])
+ return Table(rows1, n_para, n_type, tit)
+
# ------------------------------------------------------------------------------
-# ------------------------------------------------------------------------------
-if __name__ == "__main__":
- listdic = [
- {'NOEUD': 'N1' ,'NUME_ORDRE': 1 ,'INST': 0.5, 'DX': -0.00233, 'COOR_Y': 0.53033,},
- {'NOEUD': 'N1' ,'NUME_ORDRE': 2 ,'INST': 1.0, 'DX': -0.00467, 'COOR_Y': 0.53033,},
- {'NOEUD': 'N1' ,'NUME_ORDRE': 3 ,'INST': 1.5, 'DX': -0.00701, 'COOR_Y': 0.53033,},
- {'NOEUD': 'N1' ,'NUME_ORDRE': 4 ,'INST': 2.0, 'DX': -0.00934, 'COOR_Y': 0.53033,},
- {'NOEUD': 'N1' ,'NUME_ORDRE': 5 ,'INST': 2.5, 'DX': -0.01168, 'COOR_Y': 0.53033,},
- {'NOEUD': 'N2' ,'NUME_ORDRE': 11,'INST': 5.5, 'DX': -0.00233, 'COOR_Y': 0.53033,},
- {'NOEUD': 'N2' ,'NUME_ORDRE': 12,'INST': 6.0, 'DX': -0.00467, 'COOR_Y': 0.53033,},
- {'NOEUD': 'N2' ,'NUME_ORDRE': 13,'INST': 6.5, 'DX': -0.00701, 'COOR_Y': 0.53033,},
- {'NOEUD': 'N2' ,'NUME_ORDRE': 14,'INST': 7.0, 'DX': -0.00934, 'COOR_Y': 0.53033,},
- {'NOEUD': 'N2' ,'NUME_ORDRE': 15,'INST': 7.5, 'DX': -0.01168, 'COOR_Y': 0.53033,},
- ]
- import random
- random.shuffle(listdic)
- listpara=['NOEUD','NUME_ORDRE','INST','COOR_Y','DX']
- listtype=['K8','I','R','R','R']
- t=Table(listdic,listpara,listtype)
-
- tb=t[('NOEUD','DX')]
- print tb.para
- print tb.type
-
- print
- print "------Table initiale----"
- print t
- print
- print "--------- CRIT --------"
- print t.NUME_ORDRE <=5
- print
- print "------- CRIT & CRIT -----"
- print (t.NUME_ORDRE < 10) & (t.INST >=1.5)
- print
- print "----- EQ maxi / min(col), max(col) ------"
- print t.DX == max(t.DX)
- print min(t.DX)
- print max(t.DX)
- print "------ getitem sur 2 paramètres ------"
- print t.NUME_ORDRE
- print t.DX
- print t['DX','NUME_ORDRE']
- print "------ sort sur INST ------"
- t.sort('INST')
- print t
-
- print "------- TABLEAU_CROISE ------"
- tabc=t['NOEUD','INST','DX']
- tabc.Impr(FORMAT='TABLEAU_CROISE')
-
- N=5
- ldic=[]
- for i in range(N):
- ldic.append({'IND':float(i), 'VAL' : random.random()*i})
- para=['IND','VAL']
- t3=Table(ldic, para, titr='Table aléatoire')
- col=t3.VAL.ABS_MAXI()
- col=t3.VAL.MINI()
-
- t3.sort('VAL','IND')
-
- tg=tabc['INST','DX'].DX.NON_VIDE()
- #tg.Impr(FORMAT='XMGRACE')
-
- g=Graph.Graph()
- g.Titre="Tracé d'une fonction au format TABLEAU"
- g.AjoutCourbe(Val=[tg.INST.values(), tg.DX.values()], Lab=['INST','DX'])
- g.Trace(FORMAT='TABLEAU')
-
-# t.Impr(PAGINATION='NOEUD')
- t.Impr(PAGINATION=('NOEUD','INST'))
-
+def _typaster(obj, prev=None, strict=False):
+ """Retourne le type Aster ('R', 'I', Kdef) correspondant à l'objet obj.
+ Si prev est fourni, on vérifie que obj est du type prev.
+ Si strict=False, on autorise que obj ne soit pas du type prev s'ils sont
+ tous les deux numériques ; dans ce cas, on retourne le "type enveloppe" 'R'.
+ """
+ dtyp={
+ IntType : 'I',
+ FloatType : 'R',
+ StringType : Kdef, UnicodeType : Kdef,
+ NoneType : 'I',
+ }
+ if type(obj) in dtyp.keys():
+ typobj=dtyp[type(obj)]
+ if prev in [None, typobj]:
+ return typobj
+ elif strict: # prev<>None et typobj<>prev et strict
+ raise TypeError, "La valeur %s n'est pas de type %s" % (repr(obj),repr(prev))
+ elif prev in ('I','R') and typobj in ('I','R'):
+ return 'R'
+ else:
+ raise TypeError, "La valeur %s n'est pas compatible avec le type %s" \
+ % (repr(obj),repr(prev))
+ else:
+ raise TypeError, 'Une table ne peut contenir que des entiers, réels ' \
+ 'ou chaines de caractères.'
-#@ MODIF UniteAster Utilitai DATE 11/05/2005 AUTEUR MCOURTOI M.COURTOIS
+#@ MODIF UniteAster Utilitai DATE 29/08/2006 AUTEUR MCOURTOI M.COURTOIS
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
print __tab.EXTR_TABLE()
raise aster.FatalError,"<F> <UniteAster._setinfo> %s" % message
self.infos[unit]['nom'] = nomfich
- DETRUIRE(CONCEPT=_F(NOM=__tab))
+ #print 'DEBUG infos[unit] = ', self.infos[unit]
+ DETRUIRE(CONCEPT=_F(NOM=__tab),INFO=1)
#-------------------------------------------------------------------------------
- def Libre(self, nom=None):
- """Réserve et retourne une unité libre en y associant, s'il est fourni,
- le fichier 'nom'.
+ def Libre(self, nom=None, action='RESERVER'):
+ """Réserve/associe et retourne une unité libre en y associant, s'il est
+ fourni, le fichier 'nom'.
"""
__tab=INFO_EXEC_ASTER(LISTE_INFO=('UNITE_LIBRE'))
unit = __tab['UNITE_LIBRE',1]
- DETRUIRE(CONCEPT=_F(NOM=__tab))
+ DETRUIRE(CONCEPT=_F(NOM=__tab),INFO=1)
if nom==None:
nom='fort.'+str(unit)
self.infos[unit]['nom']
raise aster.FatalError,"<F> <UniteAster.Libre> %s" % message
- DEFI_FICHIER(ACTION='RESERVER', UNITE=unit , FICHIER=nom.strip())
+ DEFI_FICHIER(ACTION=action, UNITE=unit , FICHIER=nom.strip())
self.infos[unit] = {}
self.infos[unit]['nom'] = nom.strip()
self.infos[unit]['etat'] = 'R'
"""Retourne l'état de l'unité si 'etat' n'est pas fourni
et/ou change son état :
kargs['etat'] : nouvel état,
+ kargs['nom'] : nom du fichier,
kargs['TYPE'] : type du fichier à ouvrir ASCII/BINARY/LIBRE,
- kargs['ACCES'] : type d'accès NEW/APPEND/OLD.
+ kargs['ACCES'] : type d'accès NEW/APPEND/OLD (APPEND uniquement en ASCII).
"""
# ul peut etre un entier Aster
try:
DEFI_FICHIER(ACTION='LIBERER', UNITE=unit)
DEFI_FICHIER(ACTION = 'RESERVER',
UNITE = unit,
- FICHIER = self.infos[unit]['nom'])
+ FICHIER = kargs.get('nom', self.infos[unit]['nom']))
+ self._setinfo(unit)
elif new == 'F':
DEFI_FICHIER(ACTION='LIBERER', UNITE=unit)
elif new == 'O':
if self.infos[unit]['etat'] == 'R':
DEFI_FICHIER(ACTION='LIBERER', UNITE=unit)
+ # valeurs par défaut
+ typ = kargs.get('TYPE', 'ASCII')
+ if typ == 'ASCII':
+ acces = 'APPEND'
+ else:
+ acces = 'OLD'
+ acces = kargs.get('ACCES', acces)
DEFI_FICHIER(ACTION ='ASSOCIER',
UNITE = unit,
- FICHIER = self.infos[unit]['nom'],
- TYPE = kargs.get('TYPE', 'ASCII'),
- ACCES = kargs.get('ACCES', 'APPEND'),)
+ FICHIER = kargs.get('nom', self.infos[unit]['nom']),
+ TYPE = typ,
+ ACCES = acces,)
+ self._setinfo(unit)
self.infos[unit]['etat'] = new
return self.infos[unit]['etat']
-#@ MODIF Utmess Utilitai DATE 30/11/2004 AUTEUR MCOURTOI M.COURTOIS
+#@ MODIF Utmess Utilitai DATE 17/10/2005 AUTEUR MCOURTOI M.COURTOIS
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
def UTMESS(code, sprg, texte):
"""Utilitaire analogue à la routine fortran UTMESS.
- code : 'A', 'E', 'S', 'F'
+ code : 'A', 'E', 'S', 'F', 'I'
sprg : nom du module, classe ou fonction python où l'on se trouve
texte : contenu du message
"""
fmt='\n <%s> <%s> %s\n\n'
- UL={
- 'MESSAGE' : 6,
- 'RESULTAT' : 8,
- #'ERREUR' : 9,
- }
- # On importe la définition des commandes à utiliser dans la macro
-# if jdc:
-# DEFI_FICHIER = jdc.get_cmd('DEFI_FICHIER')
-# else:
-# # on se limite au print !
-# UL={ 'MESSAGE' : 6, }
- try:
- from Cata.cata import DEFI_FICHIER
- except ImportError:
- # on se limite au print !
- UL={ 'MESSAGE' : 6, }
-
- reason=fmt % (code, sprg, texte)
+ sanscode='\n <%s> %s\n\n'
+ UL=[
+ 'MESSAGE',
+ 'RESULTAT',
+ #'ERREUR',
+ ]
+#
+ # Comme l'UTMESS fortran, on supprime le code si on ne fait pas l'abort
+ if aster.onFatalError()=='EXCEPTION':
+ reason=sanscode % (sprg, texte)
+ else:
+ reason=fmt % (code, sprg, texte)
- for nom,ul in UL.items():
- if ul<>6:
- DEFI_FICHIER(ACTION='LIBERER', UNITE=ul, )
- f=open('fort.'+str(ul),'a')
- else:
- f=sys.stdout
+ for nom in UL:
# écriture du message
- f.write(reason)
-
- if ul<>6:
- f.close()
- DEFI_FICHIER(ACTION='ASSOCIER', UNITE=ul, TYPE='ASCII', ACCES='APPEND')
+ aster.affiche(nom,reason)
if code=='S':
raise aster.error, reason
--- /dev/null
+#@ MODIF liss_enveloppe Utilitai DATE 29/08/2005 AUTEUR THOMASSO D.THOMASSON
+# -*- 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.
+# ======================================================================
+"""
+ Maquette demande SEPTEN fonction de lissage enveloppe
+ Les données se présentent sous la forme d'un fichier texte comportant
+ un ensemble de groupe de lignes organisé comme suit :
+ - ligne 1 : Informations générales
+ - ligne 2 : une liste de valeur d'amortissement
+ - lignes 3...n : une liste de valeur commencant par une frequence suivit
+ des amplitudes du spectre pour chacun des amortissements
+ liste en ligne 2
+ Points importants :
+ - Le nombre de lignes définissant le spectre peut varier
+ - Le nombre de valeur d'amortissement peut varier ?
+
+ ==> On propose d'opérer ligne par ligne
+ ==> L'absence d'informations sur la variabilité du nombre d'éléments oblige à traiter le cas général
+
+
+
+ Etapes du développement :
+ 24/05/2005 : Test de lecture du fichier, choix d'une stratégie de gestion
+ 25/05/2005 : Objet itérable pour la lecture du fichier
+ 29/05/2005 : Créations de filtres pour les spectres
+"""
+
+import math
+
+def nearestKeys(k1, dct) :
+ """
+ retourne les clés (doublet) les plus proches de 'key' dans le dictionnaire dct
+ par valeur inférieure et supérieures
+ """
+ kr = min(dct.keys())
+ for k2 in dct.keys() :
+ if (k2<k1) and (k2>kr) : kr = k2
+ kinf = kr
+
+ kr = max(dct.keys())
+ for k2 in dct.keys() :
+ if (k2>k1) and (k2<kr) : kr = k2
+ ksup = kr
+
+ return (kinf, ksup)
+
+def interpole(x2, x0, y0, x1, y1) :
+ """
+ renvoie la valeur pour x2 interpolée (linéairement) entre x0 et x1
+ """
+ try :
+ a = (y1-y0) / (x1-x0)
+ except ZeroDivisionError :
+ return y0
+
+ return a * (x2-x0) + y0
+
+
+def listToDict(lst) :
+ """
+ Cette fonction recoit une liste et la transforme en un dictionnaire
+ """
+ dctRes = {}
+ for val in lst :
+ dctRes[val] = True
+ return dctRes
+
+def inclus(l1, l2) :
+ """
+ Teste si une liste (lst1) est incluse dans une autre (lst2)
+ Renvoie le premier élément de l1 qui n'est pas inclus ou None si l1 inclus dans l2)
+ """
+ for v in l1 :
+ try :
+ l2.index(v)
+ except ValueError :
+ return v
+ return None
+
+def exclus(i1, i2) :
+ """
+ Teste si deux listes ne partagent pas d'élément commun
+ Renvoie le premier élément de l1 qui n'est pas exclus ou None si l1 exclus de l2)
+ """
+ for v in i1 :
+ try :
+ i2.index(v)
+ return v
+ except ValueError :
+ continue
+ return None
+
+class NappeCreationError(Exception) :
+ def __init__(self) :
+ self.mess = "Un problème est survenu lors dla création d'une nappe"
+ self.otherExcept = Exception()
+
+ def getMess(self) :
+ """ Retourne le message associé à l'erreur """
+ # Analyse les différents cas d'erreurs
+ if self.otherExcept == IOError :
+ self.mess += "\nProblème à l'ouverture du fichier\n"
+
+ return self.mess
+
+class SpectreError(Exception) :
+ def __init__(self) :
+ self.mess = "Un problème est survenu lors de la construction du spectre"
+ self.otherExcept = Exception()
+
+ def getMess(self) :
+ """ Retourne le message associé à l'erreur """
+ # Analyse les différents cas d'erreurs
+ if self.otherExcept == IOError :
+ self.mess += "\nProblème à l'ouverture du fichier\n"
+
+ return self.mess
+
+class filtre :
+ """
+ La classe filtre est la classe de base des filtres applicables au spectre
+ Elle possède une fonction privée filtre qui prend un spectre en entrée et qui
+ retourne un spectre filtré en sortie et qui est appelée par la fonction __call__
+ """
+ def __init__(self): pass
+ def __call__(self, sp) :
+ return self._filtre(sp)
+
+ def _filtre(self, sp) :
+ spr = sp
+ return spr # la fonction filtre de la classe de base retourne le spectre sans le modifier
+
+class filtreExpand(filtre) :
+ """ effectue l'expansion du spectre selon spécif du SEPTEN """
+ def __init__(self, **listOpt) :
+ try :
+ self.expandCoef = listOpt['coef']
+ except KeyError :
+ self.expandCoef = 0.1
+
+ def _filtre(self, sp) :
+ spLower = spectre()
+ spUpper = spectre()
+ # Etape 1 : Construction du spectre inférieur sans considération des échelons de fréquence
+ for i in range(0, len(sp.listFreq)) :
+ spLower.listFreq = spLower.listFreq + [sp.listFreq[i] - abs(sp.listFreq[i]*self.expandCoef)]
+ spLower.dataVal = spLower.dataVal + [sp.dataVal[i]]
+ spUpper.listFreq = spUpper.listFreq + [sp.listFreq[i] + abs(sp.listFreq[i]*self.expandCoef)]
+ spUpper.dataVal = spUpper.dataVal + [sp.dataVal[i]]
+
+
+ # Etape 2 : Construction du spectre "élargi" sur la base de fréquence du spectre initial
+ # On tronque en deca de la fréquence minimale du spectre de référence
+ index = 0
+ while spLower.listFreq[index] < sp.listFreq[0] : index+=1
+
+ # Recopie des valeurs à conserver
+ spLower.dataVal = spLower.dataVal[index:]
+
+ index = 0
+ while spUpper.listFreq[index] < sp.listFreq[len(sp.listFreq)-1] : index+=1
+
+ # Recopie des valeurs à conserver
+ spUpper.dataVal = spUpper.dataVal[0:index]
+ # calcul du nombre d'éléments à rajouter
+ nb = len(sp.dataVal) - index
+ #Décalage le la liste de nb elements
+ for i in range(0, nb) : spUpper.dataVal.insert(0,-1.0e6)
+
+ #On remplace la base de fréquence 'décalée' de lower et upper par la base de fréquence 'standard'
+ spLower.listFreq = sp.listFreq
+ spUpper.listFreq = sp.listFreq
+
+ return self._selectVal(spLower, sp, spUpper)
+
+ def _selectVal(self,spLower, sp, spUpper) :
+ spr = sp
+ for i in range(0, len(sp.listFreq)) :
+ try :
+ v1 = spLower.dataVal[i]
+ except IndexError :
+ v1 = -200.0
+ try :
+ v2 = sp.dataVal[i]
+ except IndexError :
+ v2 = -200.0
+ try :
+ v3 = spUpper.dataVal[i]
+ except IndexError :
+ v3 = -200.0
+
+ spr.dataVal[i] = max([v1,v2,v3])
+
+ return spr
+
+class filtreLog(filtre) :
+ """
+ Convertit un spectre en LogLog (log base 10)
+ + Possibilité d'obtenir un linLog (abcsisses linéaires, ordonnées en log)
+ + Possibilité d'obtenir un logLin (abcsisses log, ordonnées en linéaires)
+ """
+ def __init__(self, **listOpt) :
+ try :
+ self.logAbc = listOpt['logAbc']
+ except KeyError :
+ self.logAbc = True
+ try :
+ self.logOrd = listOpt['logOrd']
+ except KeyError :
+ self.logOrd = True
+
+ def _filtre(self, sp) :
+ spr = spectre()
+ if self.logAbc :
+ spr.listFreq = [math.log10(i) for i in sp.listFreq]
+ else :
+ spr.listFreq = [i for i in sp.listFreq]
+ if self.logOrd :
+ spr.dataVal = [math.log10(i) for i in sp.dataVal]
+ else :
+ spr.dataVal = [i for i in sp.dataVal]
+
+ return spr
+
+class filtreLin(filtre) :
+ """
+ Convertit un spectre en LinLin (10^n) à partir d'un spectre en linLog,LogLin ou logLog
+ """
+ def __init__(self, **listOpt) :
+ try :
+ self.logAbc = listOpt['logAbc']
+ except KeyError :
+ self.logAbc = True
+ try :
+ self.logOrd = listOpt['logOrd']
+ except KeyError :
+ self.logOrd = True
+
+ def _filtre(self, sp) :
+ spr = spectre()
+ if self.logAbc :
+ spr.listFreq = [10**i for i in sp.listFreq]
+ else :
+ spr.listFreq = [i for i in sp.listFreq]
+ if self.logOrd :
+ spr.dataVal = [10**i for i in sp.dataVal]
+ else :
+ spr.dataVal = [i for i in sp.dataVal]
+
+ return spr
+
+class filtreBandWidth(filtre) :
+ def __init__(self, **listOpt) :
+ try :
+ self.lowerBound = listOpt['lower']
+ except KeyError :
+ self.lowerBound = 0.2
+ try :
+ self.upperBound = listOpt['upper']
+ except KeyError :
+ self.upperBound = 35.5
+
+ def _filtre(self, sp) :
+ spr = sp
+ toDel = []
+ for i in range(0, len(spr.listFreq)) :
+ if spr.listFreq[i] > self.upperBound :
+ toDel = toDel + [i]
+
+ # Nettoyage des fréquences à suppimer (on commence par les plus hautes)
+ for i in toDel[::-1] :
+ del spr.listFreq[i]
+ del spr.dataVal[i]
+
+ toDel = []
+ for i in range(0, len(spr.listFreq)) :
+ if spr.listFreq[i] < self.lowerBound :
+ toDel = toDel + [i]
+ else :
+ break
+
+ # Nettoyage des fréquences à suppimer (on finit par les plus basses)
+ for i in toDel[::-1] :
+ del spr.listFreq[i]
+ del spr.dataVal[i]
+
+ return spr
+
+class filtreCrible(filtre):
+ """
+ Criblage du spectre selon specif SEPTEN §C-5 (ce que j'en comprend)
+ """
+ def __init__(self, **listOpt):
+ try :
+ self.tolerance = listOpt['tolerance']
+ except KeyError :
+ self.tolerance = 0.25
+
+ self.listEtats = []
+
+ def _filtre(self, sp) :
+ self._initListeEtats(sp) # Création de la table des étsts des valeurs du spectre
+ coef = 1
+
+ # Parcours de la liste des fréquences
+ i1, i2, i3 = 0, 2, 1
+ bTest = True
+ while True :
+ try :
+ bTest = self._amplitude(sp, i1, i2, i3, coef)
+ if not(bTest) and ((i2-i1) > 2) :
+ # Le point a été éliminé, on réexamine le point précédent sauf si c'est le premier examiné
+ i3 -= 1
+ if self._amplitude(sp, i1, i2, i3, coef) :
+ # Le point a été "récupéré", il devient la nouvelle origine
+ i1 = i3
+ i2 = i2 # écrit quand meme pour la compréhension
+ i3 += 1
+ else :
+ # Le point reste désactivé, on avance au point suivant, le point d'origine est conservé
+ i1 = i1
+ i2 += 1
+ i3 += 2
+ elif not(bTest) and not((i2-i1) > 2) :
+ i1 = i1
+ i2 += 1
+ i3 += 1
+ else : # Le point est conservé, il devient la nouvelle origine
+ i1 = i3
+ i2 += 1
+ i3 += 1
+ except IndexError :
+ break
+
+ return self._crible(sp)
+
+ def _initListeEtats(self, sp) :
+ """
+ Crée une liste associant à chaque fréquence du spectre passé en paramètre, un état booléen
+ qui spécifie si ce couple fréquence-valeur est supprimé ou pas
+ NB : au départ toutes les valeur sont "True" car aucune valeur n'a été supprimée
+ """
+ self.listEtats = [True for x in sp.listFreq]
+
+ def _crible(self, sp) :
+ """
+ Supprime les points de fréquence qui sont marqué False dans listEtats
+ """
+ sp2 = spectre([], []) # On force car il y a un problème de persistance su spectre précédent
+ for x,y,z in zip(self.listEtats, sp.listFreq, sp.dataVal) :
+ if x :
+ sp2.listFreq.append(y)
+ sp2.dataVal.append(z)
+
+ return sp2
+
+ def _amplitude(self, sp, id1, id2, id3, coef=1) :
+ """
+ teste le point d'indice id3 par rapport aux points à sa gauche(p1 d'indice id1) et
+ à sa droite (p2 d'indice id2).
+ Le point est éliminé si sa valeur est en dessous de la droite reliant les points
+ d'indice id1 et id2 sauf si sa distance à cette droite est supérieure à :
+ tolerance*ordonnée
+ Le critère est purement sur l'amplitude du point indépendemment de l'intervalle
+ sur lequel il s'applique
+ """
+ x0 = sp.listFreq[id1]
+ y0 = sp.dataVal[id1]
+ x1 = sp.listFreq[id2]
+ y1 = sp.dataVal[id2]
+ x2 = sp.listFreq[id3]
+ y2 = sp.dataVal[id3]
+
+ yp2 = interpole(x2, x0, y0, x1, y1)
+
+ # Le point est il susceptible d'etre supprimé (est il en dessous de la droite p1-p2 ?)
+ # Faut-il le supprimer pour autant (distance y2 à yp2 > tolerance% de y2)
+ bSup = not((y2 < yp2) and (abs(yp2-y2)/y2 < self.tolerance))
+
+ # Changement de l'état du point
+ self.listEtats[id3] = bSup
+
+ return bSup
+
+class filtreChevauchement(filtre):
+ """
+ Compare un spectre à un spectre de référence fréquence par fréquence.
+ Si une fréquence n'existe pas, on cherche la valeur équivalent par interpolation
+ Pour éviter tout recouvrement, il est éventuellement nécessaire de rajouter
+ des informations à certaines fréquences
+ """
+ def __init__(self, **listOpt) :
+ try :
+ self.spRef = listOpt['ref']
+ except KeyError :
+ self.spRef = spectre()
+
+ try :
+ signe = listOpt['ordre']
+ self.ordre = signe/abs(signe) #coefficient +1 ou -1
+ except KeyError :
+ self.ordre = +1
+ except ZeroDivisionError :
+ self.ordre = +1
+
+ def _filtre(self, sp) :
+ spDict = sp.buildMap()
+ spRefDict = self.spRef.buildMap()
+ spTestDict = {}
+
+ # On commence par construire un dictionnaire des valeurs à tester comportant toutes les clés contenues
+ for k in spDict.keys() : spTestDict[k] = True
+ for k in spRefDict.keys() : spTestDict[k] = True
+
+ # On teste ensuite toutes les valeurs du dictionnaire
+ for k in spTestDict.keys() :
+ # Test d'existence dans le dictionnaire du spectre de référence
+ try :
+ vr = spRefDict[k]
+ except KeyError :
+ ki = nearestKeys(k, spRefDict)
+ vr = interpole(k, ki[0], spRefDict[ki[0]], ki[1], spRefDict[ki[1]])
+ # Test d'existence dans le dictionnaire du spectre à tester
+ try :
+ vt = spDict[k]
+ except KeyError :
+ ki = nearestKeys(k, spDict)
+ vt = interpole(k, ki[0], spDict[ki[0]], ki[1], spDict[ki[1]])
+
+ # Comparaison des deux valeurs. La clé est ajoutée si elle n'existe pas
+ if vt*self.ordre < vr*self.ordre : spDict[k] = vr
+
+ return spectre.sortSpectre(spDict)
+
+class spectre :
+ """
+ décrit un spectre composé d'un ensemble de résultat associé à un ensemble de fréquence
+ """
+ def __init__(self, listFreq = [], dataVal = []) :
+ self.listFreq = [v for v in listFreq]
+ self.dataVal = [v for v in dataVal]
+
+ def filtre(self, fi) :
+ """
+ Applique le filtre passé en paramètre au spectre et retourne un nouveau spectre
+ """
+ return fi(self)
+
+ def __staticSortSpectre(dict) :
+ """
+ Convertit un spectre présenté sous forme d'un dictionnaire en un spectre normal
+ Fonction créé parceque les clés du dictionnaire ne sont pas ordonnées
+ """
+ lstFrq = dict.keys()
+ lstFrq.sort()
+ lstVal = []
+ for fr in lstFrq :
+ try :
+ lstVal.append(dict[fr])
+ except KeyError : # Ne devrait jamais arriver
+ lstVal.append(-1E15)
+
+ return spectre(lstFrq, lstVal)
+
+ sortSpectre = staticmethod(__staticSortSpectre) # définition en tant que méthode statique
+
+ def getCoupleVal(self,indice) :
+ return (self.listFreq[indice], self.dataVal[indice])
+
+ def moyenne(self) :
+ """
+ Calcule la moyenne pondéré : somme(An* dfn) /F
+ """
+ somme = 0.0
+ X0 = self.listFreq[0]
+ X1 = self.listFreq[len(self.listFreq)-1]
+ for i in range(0,len(self.listFreq)-1) :
+ x0 = self.listFreq[i]
+ y0 = self.dataVal[i]
+ x1 = self.listFreq[i+1]
+ y1 = self.dataVal[i+1]
+
+ somme = somme + (y0+y1) * abs(x1-x0) / 2
+
+ return somme/abs(X1-X0)
+
+ def seuil(self, limit=75) :
+ """
+ retourne un couple d'index délimitant l'ensemble des valeurs du spectre
+ définissant "limit" pourcent du total cumulé des valeurs
+ [borne à gauche inclue, borne à droite exclue[
+ ATTENTION on fait l'hypothèse que le spectre a une forme en cloche.
+ """
+ resu = [0 for v in self.dataVal] # initialisation du tableau resultat
+
+ maxi = max(self.dataVal) # Valeur maxu du spectre
+ iMaxi = self.dataVal.index(maxi) # Index de la valeur max du spectre
+
+ # ETAPE 1 : SOMMATION
+ somme = 0.0
+ for v, i in zip(self.dataVal[0:iMaxi], range(0, iMaxi)) :
+ somme = somme + v
+ resu[i] = somme
+
+ somme = 0.0
+ for v, i in zip(self.dataVal[:iMaxi:-1], range(len(self.dataVal)-1, iMaxi, -1)) :
+ somme = somme + v
+ resu[i] = somme
+
+ resu[iMaxi] = resu[iMaxi-1] + self.dataVal[iMaxi] + resu[iMaxi+1]
+
+ #ETAPE 2 : POURCENTAGE (PAS NECESSAIRE MAIS PLUS LISIBLE)
+ for v, i in zip(self.dataVal[0:iMaxi], range(0, iMaxi)) :
+ resu[i] = (resu[i] + maxi/2) / resu[iMaxi] * 100
+
+ for v, i in zip(self.dataVal[iMaxi+1:], range(iMaxi+1, len(self.dataVal))) :
+ resu[i] = (resu[i] + maxi/2) / resu[iMaxi] * 100
+
+ resu[iMaxi] = resu[iMaxi-1] + resu[iMaxi+1]
+
+ # ETAPE 3 : RECHERCHE DES BORNES
+ limit = (100.0 - limit) / 2.0
+ b1 = b2 = True
+ for v1, v2 in zip(resu[:], resu[::-1]): # Parcours simultané dans les deux sens
+ if b1 and v1 >= limit : # Borne à gauche trouvée
+ i1 = resu.index(v1)
+ b1 = False
+ if b2 and v2 >= limit : # Borne à droite trouvée
+ i2 = resu.index(v2) + 1 # Borne à droit exclue de l'intervalle
+ b2 = False
+
+ return (i1, i2)
+
+ def cut(self, nuplet) :
+ """
+ Découpe un spectre en sous-spectres qui sont retournés en sortie de la fonction
+ sous la forme d'un tableau de spectres
+ """
+ # transformation du nuplet en tableau (permet de lui ajouter un élément)
+ tabNuplet = [v for v in nuplet]
+ tabNuplet.append(len(self.listFreq))
+
+ # Traitement
+ tableRes = list()
+ bGauche = 0
+ for borne in tabNuplet :
+ bDroite = borne
+ sp = spectre()
+ for i in range(bGauche, bDroite) :
+ sp.listFreq.append(self.listFreq[i])
+ sp.dataVal.append(self.dataVal[i])
+
+ tableRes.append(sp)
+ bGauche = bDroite
+
+ return tableRes
+
+ def __staticMerge(tabSpectre) :
+ """
+ A l'inverse de la fonction cut, construit un seul spectre à partir d'un ensemble de spectres
+ """
+ # On vérifie d'abord que les spectres ne partagent pas la meme bande de fréquence (fut ce partiellement)
+ for i in range(0, len(tabSpectre)-1) :
+ if exclus(tabSpectre[i].listFreq, tabSpectre[i+1].listFreq) : raise SpectreError
+ if exclus(tabSpectre[0].listFreq, tabSpectre[len(tabSpectre)-1].listFreq) : raise SpectreError
+
+ spRes = spectre()
+ #cumul des spectres
+ for sp in tabSpectre :
+ for f, v in zip(sp.listFreq, sp.dataVal) :
+ spRes.listFreq.append(f)
+ spRes.dataVal.append(v)
+
+ return spRes
+
+ merge = staticmethod(__staticMerge) # définition en tant que méthode statique
+
+ def buildMap(self) :
+ """
+ Construit un dictionnaire à partir d'un spectre
+ """
+ dict = {}
+ for i, j in zip(self.listFreq, self.dataVal) :
+ dict[i] = j
+
+ return dict
+
+class nappe :
+ """
+ décrit un objet nappe qui associe à un ensemble de fréquence à une enesmble de résultats
+ """
+ def __init__(self, listFreq = [], listeTable = [], listAmor = [], entete = ""):
+ self.listFreq = [v for v in listFreq] # recopie physique !
+ self.listTable = [list() for t in listeTable]
+ for t, st in zip(listeTable, self.listTable) :
+ for v in t : st.append(v)
+
+ self.listAmor = [l for l in listAmor]
+ self.entete = entete
+
+ def __staticBuildFromListSpectre(lsp) :
+ """
+ Construction d'une nappe à partir d'une liste de spectres
+ """
+ # On commence par vérifier que toutes les nappes on la meme base de fréquences
+ # A inclus dans B inclus dans C inclus dans .... et DERNIER inclus dans PREMIER ==> tous égaux
+ for i in range(0,len(lsp.listSp)-1) :
+ if inclus(lsp.listSp[i].listFreq, lsp.listSp[i+1].listFreq) : raise NappeCreationError
+ if inclus(lsp.listSp[i+1].listFreq, lsp.listSp[0].listFreq) : raise NappeCreationError
+
+ # Construction de la nappe à proprement parler
+ listeFreq = [fr for fr in lsp.listSp[0].listFreq]
+ listeTable = [list() for sp in lsp.listSp]
+ for sp, lv in zip(lsp.listSp, listeTable) :
+ for v in sp.dataVal :
+ lv.append(v)
+ return nappe(listeFreq, listeTable, [], 'toto')
+
+ buildFromListSpectre = staticmethod(__staticBuildFromListSpectre) # définition en tant que méthode statique
+
+ def getNbSpectres(self) :
+ """ Retourne le nombre d'éléments dans la nappe """
+ return len(self.listAmor)
+
+ def getNbFreq(self) :
+ """ Retourne le nombre d'éléments dans chaque spectre """
+ return len(self.listFreq)
+
+ def getSpectre(self, index) :
+ """
+ Retourne le spectre d'indice 'index' dans la nappe
+ """
+ return spectre(self.listFreq, self.listTable[index])
+
+ def filtreDoublons(self):
+ """
+ Supprime bandes de fréquences constantes
+ """
+ prevCpl = None
+ bCount = False
+ i=0
+ # Recherche des doublons
+ lstBor = list() # Liste de listes de bornes
+ lst = list()
+ for cpl in self.__getListFreq() :
+ if not(prevCpl) :
+ prevCpl = cpl
+ continue
+ bTest = True
+ for v1, v2 in zip(cpl[1], prevCpl[1]) :
+ bTest &= (v1==v2)
+ if bTest and not bCount : # Début d'une suite de valeurs égales
+ bCount = True
+ lst.append(i)
+ elif not bTest and bCount : # Fin d'une suite de valeurs égales
+ bCount = False
+ lst.append(i)
+ lstBor.append(lst)
+ lst = list() # Nouvelle liste
+
+ prevCpl = cpl
+ i += 1
+
+ # Suppression des doublons si plus de deux valeurs
+ for cpl in lstBor :
+ if (cpl[1]-cpl[0]) < 2 : continue
+ for i in range(cpl[1]-1, cpl[0], -1) :
+ del self.listFreq[i]
+ for j in range(0, len(self.listTable)) :
+ del self.listTable[j][i]
+
+
+
+
+ def __getListFreq(self) :
+ """
+ Fonction privé qui parcours la matrice ligne par ligne
+ Retourne à chaque itération un couple frequence, liste de valeurs
+ """
+ fr = 0.0
+
+ for i in range(0, self.getNbFreq()) :
+ fr = self.listFreq[i]
+ listVal = []
+ for j in range(0, len(self.listTable)):
+ listVal.append(self.listTable[j][i])
+ yield (fr, listVal)
+
+ raise StopIteration
+
+class listSpectre :
+ """
+ classe container d'une liste de spectre ne partageant pas la meme base de fréquence
+ cas des spectres à l'issue de la première passe de l'opération de filtrage d'enveloppe
+ """
+ def __init__(self, *listSp) :
+ self.listSp = []
+ for sp in listSp :
+ self.listSp = sp
+
+ def append(self, spectre) :
+ """ Ajoute un spectre à la liste """
+ self.listSp.append(spectre)
+
+ def __staticBuildFromNappe(uneNappe) :
+ """
+ Construit une liste de spectres (indépendants) à partir d'une nappe
+ """
+ res = listSpectre()
+ for i in range(0, len(uneNappe.listAmor)) :
+ res.append(uneNappe.getSpectre(i))
+
+ return res
+
+ buildFromNappe = staticmethod(__staticBuildFromNappe) #Définition en tant que méthode statique
+
+ def testChevauchement(self) :
+ """
+ Supprime les effets de chevauchement entre les spectres
+ """
+ for i in range(0, len(self.listSp)-1) :
+ filter = filtreChevauchement(ref=self.listSp[i+1])
+ self.listSp[i] = self.listSp[i].filtre(filter)
+
+ def createBase(self, lspRef = None) :
+ """
+ Crée une base de fréquence commune pour l'ensemble des spectres
+ En s'assurant que le l'on reste enveloppe des spectre de la liste lspRef
+ """
+ lspRes = listSpectre([spectre() for sp in self.listSp]) # Liste résultante
+
+ # Recherche des fréquences attribuées à 5 spectres, 4 spectres, ... classées dans un dictionnaire
+ dctOc = self.__sortByOccurence()
+
+ iOcc = max(dctOc.keys())
+ lst = dctOc[iOcc] # On comence par mettre les frequences communes à tous les spectres
+ lst.sort()
+ iOcc -= 1
+ test = 0
+ while True :
+ lspRes.__addFreqFromList(self, lst)
+ # On vérifie si on reste enveloppe du spectre initial
+ spTest = spectre()
+ lstComp = list()
+ for sp0, sp1 in zip(lspRes.listSp, self.listSp) :
+ filter = filtreChevauchement(ref=sp1)
+ spTest = sp0.filtre(filter)
+ # Crée une liste des fréquences ajoutées (s'il y en a...)
+ for fr in spTest.listFreq :
+ try :
+ idx = sp0.listFreq.index(fr)
+ except ValueError : # Valeur non trouvée dans le tableau
+ lstComp.append(fr)
+
+ if len(lstComp) > 0 : # Il est nécessaire de compléter les spectres
+ # on prend de préférence les fréquences définies sur le plus de spectre possible
+ while True :
+ lstFreq = dctOc[iOcc]
+ prevLst = lst # On sauvegarde la liste précédente pour comparaison
+ lst = self.__buildList(lstComp, lstFreq)
+ if not(inclus(lst, prevLst)) :
+ iOcc -= 1
+ else :
+ break
+ continue
+ else :
+ break # On peut sortir les spectres sont complets
+
+ self.listSp = lspRes.listSp # Remplacement de la liste des spectres
+
+ # On s'assure que le spectre reste enveloppe du spectre de référence rajoute des fréquences si nécessaire
+ # 1. filtre chevauchement
+ if lspRef : # Si une liste de spectre de référence a été définie, on vérifie le caractère enveloppe du résultat
+ listComp = list()
+
+ for sp1, sp2 in zip(self.listSp, lspRef.listSp) :
+ filter = filtreChevauchement(ref=sp2)
+ spTest = sp1.filtre(filter)
+ test = inclus(spTest.listFreq, sp1.listFreq)
+ if test : listComp.append(test)
+ # 3. Complément éventuel de l'ensemble des spectres
+ if listComp : lspRes.__addFreqFromList(self, listComp)
+
+ self.listSp = lspRes.listSp # Remplacement de la liste des spectres
+
+ def filtre(self, filter):
+ """
+ Applique un filtre à l'ensemble des spectres de la liste
+ """
+ self.listSp = [sp.filtre(filter) for sp in self.listSp]
+
+
+ def __sortByOccurence(self) :
+ """
+ Fonction qui trie les fréquences par leur occurence d'apparition dans la liste de spectre
+ """
+ dct = {}
+ for sp in self.listSp : # Boucle sur tous les spectres
+ for fr in sp.listFreq : # Boucle sur toutes les fréquences de chaque spectre
+ try :
+ dct[fr] += 1
+ except KeyError :
+ dct[fr] = 1
+
+ # "Inversion" du dictionnaire
+ dctOc = {} # Dictionnaire des occurences
+ for k in dct.keys() :
+ try :
+ dctOc[dct[k]].append(k)
+ except KeyError :
+ dctOc[dct[k]]=[k]
+
+
+ return dctOc
+
+ def __addFreqFromList(self, lstSp, lstFreq) :
+ """
+ Rajoute les fréquences contenues dans lstFreq aux spectres d'un listeSpectre
+ à partir des spectres fournis par le listeSpectre (lstSp) passé en paramètre
+ en procédant éventuellement à une interpolation linéaire
+ """
+ # Suppression des doublons de la liste des fréquences
+ lstFreq = listToDict(lstFreq).keys() # lst est la liste des points qu'il faudrait ajouter pour rester enveloppe
+ lstFreq.sort()
+
+ for i in range(0, len(self.listSp)) :
+ # Conversion des spectres en dictionnaire pour pouvoir les traiter
+ spDctSelf = self.listSp[i].buildMap()
+ spDctRef = lstSp.listSp[i].buildMap()
+ for fr in lstFreq :
+ # On cherche la valeur dans le spectre de référence
+ try :
+ vr = spDctRef[fr]
+ except KeyError :
+ ki = nearestKeys(fr, spDctRef)
+ vr = interpole(fr, ki[0], spDctRef[ki[0]], ki[1], spDctRef[ki[1]])
+
+ # On rajoute la valeur dans le spectre résultat
+ spDctSelf[fr] = vr
+
+ # Conversion du dictionnaire en spectre réel
+ self.listSp[i] = spectre.sortSpectre(spDctSelf)
+
+ def __buildList(self, lstComp, lstFreq) :
+ """
+ Construit une liste de fréquences à ajouter à partir d'une liste de fréquences
+ à ajouter (listComp) et d'une liste de référence, (listFreq)
+ retourne une liste
+ """
+ lst = list()
+ for fr in lstComp :
+ try :
+ idx = lstFreq.index(fr)
+ lst.append(fr)
+ except ValueError : # Fréquence non présente, recherche de la plus proche
+ couple = nearestKeys(fr, listToDict(lstFreq))
+ if abs(couple[0]-fr) > abs(couple[1]-fr) :
+ lst.append(couple[1])
+ else :
+ lst.append(couple[0])
+
+ lst = listToDict(lst).keys() # Suppression des doublons
+ lst.sort()
+ return lst
+
+
+def lissage(nappe=nappe,fmin=0.2,fmax=35.5,elarg=0.1,tole_liss=0.25) :
+ resultat = listSpectre() # Le résultat sera contenu dans une liste de spectre
+ lspBrut = listSpectre.buildFromNappe(nappe)
+ # Passage en LogLog
+ lspBrut.filtre(filtreLog())
+ for j in range(0,nappe.getNbSpectres()) :
+ # Spectre brut
+ sp = nappe.getSpectre(j)
+ # Limitation de la bande de fréquence
+ filter = filtreBandWidth(lower=fmin, upper=fmax)
+ sp = sp.filtre(filter)
+ # Expansion du spectre
+ filter = filtreExpand(coef=elarg)
+ sp = sp.filtre(filter)
+ # Passage en LogLin
+ filter = filtreLog(logOrd=False)
+ sp = sp.filtre(filter)
+ # éclatement du spectre en 3 sous-parties
+ tabSpectre = sp.cut(sp.seuil())
+ # traitement individuel des sous parties
+ filter = filtreCrible(tolerance=2.*tole_liss)
+ tabSpectre[0] = tabSpectre[0].filtre(filter)
+ tabSpectre[2] = tabSpectre[2].filtre(filter)
+ filter.tolerance = tole_liss
+ tabSpectre[1] = tabSpectre[1].filtre(filter)
+ # Fusion des sous-spectres
+ sp = spectre.merge(tabSpectre)
+
+ # Seconde passe de filtrage
+ sp = sp.filtre(filter)
+
+ # On passe en log-log pour les tests de chevauchement
+ filter = filtreLog(logAbc=False)
+ sp = sp.filtre(filter)
+ # Ecriture dans la liste de spectres résultat
+ resultat.append(sp) # Ajoute la spectre lissé à la liste des spectres
+
+ resultat.testChevauchement() # Test de chevauchement entre les spectre de la liste
+ resultat.createBase(lspBrut) # construction d'une base commune de fréquence
+
+ # Passage en lin
+ resultat.filtre(filtreLin())
+
+ # Construction de la nappe résultat
+ nappeRes = nappe.buildFromListSpectre(resultat)
+ nappeRes.listAmor=nappe.listAmor
+ nappeRes.filtreDoublons() # Suppression des valeurs identiques accolées
+
+ return nappeRes
--- /dev/null
+#@ MODIF optimize Utilitai DATE 31/10/2006 AUTEUR ASSIRE A.ASSIRE
+# -*- coding: iso-8859-1 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2006 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
+#
+
+# ******NOTICE***************
+# optimize.py module by Travis E. Oliphant
+#
+# You may copy and use this module as you see fit with no
+# guarantee implied provided you keep this notice in all copies.
+# *****END NOTICE************
+
+# A collection of optimization algorithms. Version 0.3.1
+
+# Minimization routines
+"""optimize.py
+
+A collection of general-purpose optimization routines using Numeric
+
+fmin --- Nelder-Mead Simplex algorithm (uses only function calls)
+fminBFGS --- Quasi-Newton method (uses function and gradient)
+fminNCG --- Line-search Newton Conjugate Gradient (uses function, gradient
+ and hessian (if it's provided))
+
+"""
+import Numeric
+import MLab
+Num = Numeric
+max = MLab.max
+min = MLab.min
+abs = Num.absolute
+__version__="0.3.1"
+
+def rosen(x): # The Rosenbrock function
+ return MLab.sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0)
+
+def rosen_der(x):
+ xm = x[1:-1]
+ xm_m1 = x[:-2]
+ xm_p1 = x[2:]
+ der = MLab.zeros(x.shape,x.typecode())
+ der[1:-1] = 200*(xm-xm_m1**2) - 400*(xm_p1 - xm**2)*xm - 2*(1-xm)
+ der[0] = -400*x[0]*(x[1]-x[0]**2) - 2*(1-x[0])
+ der[-1] = 200*(x[-1]-x[-2]**2)
+ return der
+
+def rosen3_hess_p(x,p):
+ assert(len(x)==3)
+ assert(len(p)==3)
+ hessp = Num.zeros((3,),x.typecode())
+ hessp[0] = (2 + 800*x[0]**2 - 400*(-x[0]**2 + x[1])) * p[0] \
+ - 400*x[0]*p[1] \
+ + 0
+ hessp[1] = - 400*x[0]*p[0] \
+ + (202 + 800*x[1]**2 - 400*(-x[1]**2 + x[2]))*p[1] \
+ - 400*x[1] * p[2]
+ hessp[2] = 0 \
+ - 400*x[1] * p[1] \
+ + 200 * p[2]
+
+ return hessp
+
+def rosen3_hess(x):
+ assert(len(x)==3)
+ hessp = Num.zeros((3,3),x.typecode())
+ hessp[0,:] = [2 + 800*x[0]**2 -400*(-x[0]**2 + x[1]), -400*x[0], 0]
+ hessp[1,:] = [-400*x[0], 202+800*x[1]**2 -400*(-x[1]**2 + x[2]), -400*x[1]]
+ hessp[2,:] = [0,-400*x[1], 200]
+ return hessp
+
+
+def fmin(func, x0, args=(), xtol=1e-4, ftol=1e-4, maxiter=None, maxfun=None, fulloutput=0, printmessg=1):
+ """xopt,{fval,warnflag} = fmin(function, x0, args=(), xtol=1e-4, ftol=1e-4,
+ maxiter=200*len(x0), maxfun=200*len(x0), fulloutput=0, printmessg=0)
+
+ Uses a Nelder-Mead Simplex algorithm to find the minimum of function
+ of one or more variables.
+ """
+ x0 = Num.asarray(x0)
+ assert (len(x0.shape)==1)
+ N = len(x0)
+ if maxiter is None:
+ maxiter = N * 200
+ if maxfun is None:
+ maxfun = N * 200
+
+ rho = 1; chi = 2; psi = 0.5; sigma = 0.5;
+ one2np1 = range(1,N+1)
+
+ sim = Num.zeros((N+1,N),x0.typecode())
+ fsim = Num.zeros((N+1,),'d')
+ sim[0] = x0
+ fsim[0] = apply(func,(x0,)+args)
+ nonzdelt = 0.05
+ zdelt = 0.00025
+ for k in range(0,N):
+ y = Num.array(x0,copy=1)
+ if y[k] != 0:
+ y[k] = (1+nonzdelt)*y[k]
+ else:
+ y[k] = zdelt
+
+ sim[k+1] = y
+ f = apply(func,(y,)+args)
+ fsim[k+1] = f
+
+ ind = Num.argsort(fsim)
+ fsim = Num.take(fsim,ind) # sort so sim[0,:] has the lowest function value
+ sim = Num.take(sim,ind,0)
+
+ iterations = 1
+ funcalls = N+1
+
+ while (funcalls < maxfun and iterations < maxiter):
+ if (max(Num.ravel(abs(sim[1:]-sim[0]))) <= xtol \
+ and max(abs(fsim[0]-fsim[1:])) <= ftol):
+ break
+
+ xbar = Num.add.reduce(sim[:-1],0) / N
+ xr = (1+rho)*xbar - rho*sim[-1]
+ fxr = apply(func,(xr,)+args)
+ funcalls = funcalls + 1
+ doshrink = 0
+
+ if fxr < fsim[0]:
+ xe = (1+rho*chi)*xbar - rho*chi*sim[-1]
+ fxe = apply(func,(xe,)+args)
+ funcalls = funcalls + 1
+
+ if fxe < fxr:
+ sim[-1] = xe
+ fsim[-1] = fxe
+ else:
+ sim[-1] = xr
+ fsim[-1] = fxr
+ else: # fsim[0] <= fxr
+ if fxr < fsim[-2]:
+ sim[-1] = xr
+ fsim[-1] = fxr
+ else: # fxr >= fsim[-2]
+ # Perform contraction
+ if fxr < fsim[-1]:
+ xc = (1+psi*rho)*xbar - psi*rho*sim[-1]
+ fxc = apply(func,(xc,)+args)
+ funcalls = funcalls + 1
+
+ if fxc <= fxr:
+ sim[-1] = xc
+ fsim[-1] = fxc
+ else:
+ doshrink=1
+ else:
+ # Perform an inside contraction
+ xcc = (1-psi)*xbar + psi*sim[-1]
+ fxcc = apply(func,(xcc,)+args)
+ funcalls = funcalls + 1
+
+ if fxcc < fsim[-1]:
+ sim[-1] = xcc
+ fsim[-1] = fxcc
+ else:
+ doshrink = 1
+
+ if doshrink:
+ for j in one2np1:
+ sim[j] = sim[0] + sigma*(sim[j] - sim[0])
+ fsim[j] = apply(func,(sim[j],)+args)
+ funcalls = funcalls + N
+
+ ind = Num.argsort(fsim)
+ sim = Num.take(sim,ind,0)
+ fsim = Num.take(fsim,ind)
+ iterations = iterations + 1
+
+ x = sim[0]
+ fval = min(fsim)
+ warnflag = 0
+
+ if funcalls >= maxfun:
+ warnflag = 1
+ if printmessg:
+ print "Warning: Maximum number of function evaluations has been exceeded."
+ elif iterations >= maxiter:
+ warnflag = 2
+ if printmessg:
+ print "Warning: Maximum number of iterations has been exceeded"
+ else:
+ if printmessg:
+ print "Optimization terminated successfully."
+ print " Current function value: %f" % fval
+ print " Iterations: %d" % iterations
+ print " Function evaluations: %d" % funcalls
+
+ if fulloutput:
+ return x, fval, warnflag
+ else:
+ return x
+
+
+def zoom(a_lo, a_hi):
+ pass
+
+
+
+def line_search(f, fprime, xk, pk, gfk, args=(), c1=1e-4, c2=0.9, amax=50):
+ """alpha, fc, gc = line_search(f, xk, pk, gfk,
+ args=(), c1=1e-4, c2=0.9, amax=1)
+
+ minimize the function f(xk+alpha pk) using the line search algorithm of
+ Wright and Nocedal in 'Numerical Optimization', 1999, pg. 59-60
+ """
+
+ fc = 0
+ gc = 0
+ alpha0 = 1.0
+ phi0 = apply(f,(xk,)+args)
+ phi_a0 = apply(f,(xk+alpha0*pk,)+args)
+ fc = fc + 2
+ derphi0 = Num.dot(gfk,pk)
+ derphi_a0 = Num.dot(apply(fprime,(xk+alpha0*pk,)+args),pk)
+ gc = gc + 1
+
+ # check to see if alpha0 = 1 satisfies Strong Wolfe conditions.
+ if (phi_a0 <= phi0 + c1*alpha0*derphi0) \
+ and (abs(derphi_a0) <= c2*abs(derphi0)):
+ return alpha0, fc, gc
+
+ alpha0 = 0
+ alpha1 = 1
+ phi_a1 = phi_a0
+ phi_a0 = phi0
+
+ i = 1
+ while 1:
+ if (phi_a1 > phi0 + c1*alpha1*derphi0) or \
+ ((phi_a1 >= phi_a0) and (i > 1)):
+ return zoom(alpha0, alpha1)
+
+ derphi_a1 = Num.dot(apply(fprime,(xk+alpha1*pk,)+args),pk)
+ gc = gc + 1
+ if (abs(derphi_a1) <= -c2*derphi0):
+ return alpha1
+
+ if (derphi_a1 >= 0):
+ return zoom(alpha1, alpha0)
+
+ alpha2 = (amax-alpha1)*0.25 + alpha1
+ i = i + 1
+ alpha0 = alpha1
+ alpha1 = alpha2
+ phi_a0 = phi_a1
+ phi_a1 = apply(f,(xk+alpha1*pk,)+args)
+
+
+
+def line_search_BFGS(f, xk, pk, gfk, args=(), c1=1e-4, alpha0=1):
+ """alpha, fc, gc = line_search(f, xk, pk, gfk,
+ args=(), c1=1e-4, alpha0=1)
+
+ minimize over alpha, the function f(xk+alpha pk) using the interpolation
+ algorithm (Armiijo backtracking) as suggested by
+ Wright and Nocedal in 'Numerical Optimization', 1999, pg. 56-57
+ """
+
+ fc = 0
+ phi0 = apply(f,(xk,)+args) # compute f(xk)
+ phi_a0 = apply(f,(xk+alpha0*pk,)+args) # compute f
+ fc = fc + 2
+ derphi0 = Num.dot(gfk,pk)
+
+ if (phi_a0 <= phi0 + c1*alpha0*derphi0):
+ return alpha0, fc, 0
+
+ # Otherwise compute the minimizer of a quadratic interpolant:
+
+ alpha1 = -(derphi0) * alpha0**2 / 2.0 / (phi_a0 - phi0 - derphi0 * alpha0)
+ phi_a1 = apply(f,(xk+alpha1*pk,)+args)
+ fc = fc + 1
+
+ if (phi_a1 <= phi0 + c1*alpha1*derphi0):
+ return alpha1, fc, 0
+
+ # Otherwise loop with cubic interpolation until we find an alpha which satifies
+ # the first Wolfe condition (since we are backtracking, we will assume that
+ # the value of alpha is not too small and satisfies the second condition.
+
+ while 1: # we are assuming pk is a descent direction
+ factor = alpha0**2 * alpha1**2 * (alpha1-alpha0)
+ a = alpha0**2 * (phi_a1 - phi0 - derphi0*alpha1) - \
+ alpha1**2 * (phi_a0 - phi0 - derphi0*alpha0)
+ a = a / factor
+ b = -alpha0**3 * (phi_a1 - phi0 - derphi0*alpha1) + \
+ alpha1**3 * (phi_a0 - phi0 - derphi0*alpha0)
+ b = b / factor
+
+ alpha2 = (-b + Num.sqrt(abs(b**2 - 3 * a * derphi0))) / (3.0*a)
+ phi_a2 = apply(f,(xk+alpha2*pk,)+args)
+ fc = fc + 1
+
+ if (phi_a2 <= phi0 + c1*alpha2*derphi0):
+ return alpha2, fc, 0
+
+ if (alpha1 - alpha2) > alpha1 / 2.0 or (1 - alpha2/alpha1) < 0.96:
+ alpha2 = alpha1 / 2.0
+
+ alpha0 = alpha1
+ alpha1 = alpha2
+ phi_a0 = phi_a1
+ phi_a1 = phi_a2
+
+epsilon = 1e-8
+
+def approx_fprime(xk,f,*args):
+ f0 = apply(f,(xk,)+args)
+ grad = Num.zeros((len(xk),),'d')
+ ei = Num.zeros((len(xk),),'d')
+ for k in range(len(xk)):
+ ei[k] = 1.0
+ grad[k] = (apply(f,(xk+epsilon*ei,)+args) - f0)/epsilon
+ ei[k] = 0.0
+ return grad
+
+def approx_fhess_p(x0,p,fprime,*args):
+ f2 = apply(fprime,(x0+epsilon*p,)+args)
+ f1 = apply(fprime,(x0,)+args)
+ return (f2 - f1)/epsilon
+
+
+def fminBFGS(f, x0, fprime=None, args=(), avegtol=1e-5, maxiter=None, fulloutput=0, printmessg=1):
+ """xopt = fminBFGS(f, x0, fprime=None, args=(), avegtol=1e-5,
+ maxiter=None, fulloutput=0, printmessg=1)
+
+ Optimize the function, f, whose gradient is given by fprime using the
+ quasi-Newton method of Broyden, Fletcher, Goldfarb, and Shanno (BFGS)
+ See Wright, and Nocedal 'Numerical Optimization', 1999, pg. 198.
+ """
+
+ app_fprime = 0
+ if fprime is None:
+ app_fprime = 1
+
+ x0 = Num.asarray(x0)
+ if maxiter is None:
+ maxiter = len(x0)*200
+ func_calls = 0
+ grad_calls = 0
+ k = 0
+ N = len(x0)
+ gtol = N*avegtol
+ I = MLab.eye(N)
+ Hk = I
+
+ if app_fprime:
+ gfk = apply(approx_fprime,(x0,f)+args)
+ func_calls = func_calls + len(x0) + 1
+ else:
+ gfk = apply(fprime,(x0,)+args)
+ grad_calls = grad_calls + 1
+ xk = x0
+ sk = [2*gtol]
+ while (Num.add.reduce(abs(gfk)) > gtol) and (k < maxiter):
+ pk = -Num.dot(Hk,gfk)
+ alpha_k, fc, gc = line_search_BFGS(f,xk,pk,gfk,args)
+ func_calls = func_calls + fc
+ xkp1 = xk + alpha_k * pk
+ sk = xkp1 - xk
+ xk = xkp1
+ if app_fprime:
+ gfkp1 = apply(approx_fprime,(xkp1,f)+args)
+ func_calls = func_calls + gc + len(x0) + 1
+ else:
+ gfkp1 = apply(fprime,(xkp1,)+args)
+ grad_calls = grad_calls + gc + 1
+
+ yk = gfkp1 - gfk
+ k = k + 1
+
+ rhok = 1 / Num.dot(yk,sk)
+ A1 = I - sk[:,Num.NewAxis] * yk[Num.NewAxis,:] * rhok
+ A2 = I - yk[:,Num.NewAxis] * sk[Num.NewAxis,:] * rhok
+ Hk = Num.dot(A1,Num.dot(Hk,A2)) + rhok * sk[:,Num.NewAxis] * sk[Num.NewAxis,:]
+ gfk = gfkp1
+
+
+ if printmessg or fulloutput:
+ fval = apply(f,(xk,)+args)
+ if k >= maxiter:
+ warnflag = 1
+ if printmessg:
+ print "Warning: Maximum number of iterations has been exceeded"
+ print " Current function value: %f" % fval
+ print " Iterations: %d" % k
+ print " Function evaluations: %d" % func_calls
+ print " Gradient evaluations: %d" % grad_calls
+ else:
+ warnflag = 0
+ if printmessg:
+ print "Optimization terminated successfully."
+ print " Current function value: %f" % fval
+ print " Iterations: %d" % k
+ print " Function evaluations: %d" % func_calls
+ print " Gradient evaluations: %d" % grad_calls
+
+ if fulloutput:
+ return xk, fval, func_calls, grad_calls, warnflag
+ else:
+ return xk
+
+
+def fminNCG(f, x0, fprime, fhess_p=None, fhess=None, args=(), avextol=1e-5, maxiter=None, fulloutput=0, printmessg=1):
+ """xopt = fminNCG(f, x0, fprime, fhess_p=None, fhess=None, args=(), avextol=1e-5,
+ maxiter=None, fulloutput=0, printmessg=1)
+
+ Optimize the function, f, whose gradient is given by fprime using the
+ Newton-CG method. fhess_p must compute the hessian times an arbitrary
+ vector. If it is not given, finite-differences on fprime are used to
+ compute it. See Wright, and Nocedal 'Numerical Optimization', 1999,
+ pg. 140.
+ """
+
+ x0 = Num.asarray(x0)
+ fcalls = 0
+ gcalls = 0
+ hcalls = 0
+ approx_hessp = 0
+ if fhess_p is None and fhess is None: # Define hessian product
+ approx_hessp = 1
+
+ xtol = len(x0)*avextol
+ update = [2*xtol]
+ xk = x0
+ k = 0
+ while (Num.add.reduce(abs(update)) > xtol) and (k < maxiter):
+ # Compute a search direction pk by applying the CG method to
+ # del2 f(xk) p = - grad f(xk) starting from 0.
+ b = -apply(fprime,(xk,)+args)
+ gcalls = gcalls + 1
+ maggrad = Num.add.reduce(abs(b))
+ eta = min([0.5,Num.sqrt(maggrad)])
+ termcond = eta * maggrad
+ xsupi = 0
+ ri = -b
+ psupi = -ri
+ i = 0
+ dri0 = Num.dot(ri,ri)
+
+ if fhess is not None: # you want to compute hessian once.
+ A = apply(fhess,(xk,)+args)
+ hcalls = hcalls + 1
+
+ while Num.add.reduce(abs(ri)) > termcond:
+ if fhess is None:
+ if approx_hessp:
+ Ap = apply(approx_fhess_p,(xk,psupi,fprime)+args)
+ gcalls = gcalls + 2
+ else:
+ Ap = apply(fhess_p,(xk,psupi)+args)
+ hcalls = hcalls + 1
+ else:
+ Ap = Num.dot(A,psupi)
+ # check curvature
+ curv = Num.dot(psupi,Ap)
+ if (curv <= 0):
+ if (i > 0):
+ break
+ else:
+ xsupi = xsupi + dri0/curv * psupi
+ break
+ alphai = dri0 / curv
+ xsupi = xsupi + alphai * psupi
+ ri = ri + alphai * Ap
+ dri1 = Num.dot(ri,ri)
+ betai = dri1 / dri0
+ psupi = -ri + betai * psupi
+ i = i + 1
+ dri0 = dri1 # update Num.dot(ri,ri) for next time.
+
+ pk = xsupi # search direction is solution to system.
+ gfk = -b # gradient at xk
+ alphak, fc, gc = line_search_BFGS(f,xk,pk,gfk,args)
+ fcalls = fcalls + fc
+ gcalls = gcalls + gc
+
+ update = alphak * pk
+ xk = xk + update
+ k = k + 1
+
+ if printmessg or fulloutput:
+ fval = apply(f,(xk,)+args)
+ if k >= maxiter:
+ warnflag = 1
+ if printmessg:
+ print "Warning: Maximum number of iterations has been exceeded"
+ print " Current function value: %f" % fval
+ print " Iterations: %d" % k
+ print " Function evaluations: %d" % fcalls
+ print " Gradient evaluations: %d" % gcalls
+ print " Hessian evaluations: %d" % hcalls
+ else:
+ warnflag = 0
+ if printmessg:
+ print "Optimization terminated successfully."
+ print " Current function value: %f" % fval
+ print " Iterations: %d" % k
+ print " Function evaluations: %d" % fcalls
+ print " Gradient evaluations: %d" % gcalls
+ print " Hessian evaluations: %d" % hcalls
+
+ if fulloutput:
+ return xk, fval, fcalls, gcalls, hcalls, warnflag
+ else:
+ return xk
+
+
+
+if __name__ == "__main__":
+ import string
+ import time
+
+
+ times = []
+ algor = []
+ x0 = [0.8,1.2,0.7]
+ start = time.time()
+ x = fmin(rosen,x0)
+ print x
+ times.append(time.time() - start)
+ algor.append('Nelder-Mead Simplex\t')
+
+ start = time.time()
+ x = fminBFGS(rosen, x0, fprime=rosen_der, maxiter=80)
+ print x
+ times.append(time.time() - start)
+ algor.append('BFGS Quasi-Newton\t')
+
+ start = time.time()
+ x = fminBFGS(rosen, x0, avegtol=1e-4, maxiter=100)
+ print x
+ times.append(time.time() - start)
+ algor.append('BFGS without gradient\t')
+
+
+ start = time.time()
+ x = fminNCG(rosen, x0, rosen_der, fhess_p=rosen3_hess_p, maxiter=80)
+ print x
+ times.append(time.time() - start)
+ algor.append('Newton-CG with hessian product')
+
+
+ start = time.time()
+ x = fminNCG(rosen, x0, rosen_der, fhess=rosen3_hess, maxiter=80)
+ print x
+ times.append(time.time() - start)
+ algor.append('Newton-CG with full hessian')
+
+ print "\nMinimizing the Rosenbrock function of order 3\n"
+ print " Algorithm \t\t\t Seconds"
+ print "===========\t\t\t ========="
+ for k in range(len(algor)):
+ print algor[k], "\t -- ", times[k]
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-#@ MODIF sup_gmsh Utilitai DATE 10/05/2005 AUTEUR GJBHHEL E.LORENTZ
+#@ MODIF sup_gmsh Utilitai DATE 08/11/2005 AUTEUR ASSIRE A.ASSIRE
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
def Create(self, file = 'fort.19') :
self.Save()
-# os.system('gmsh -3 fort.geo')
os.system(self.gmsh + ' -3 fort.geo')
+ try: os.remove(file)
+ except: pass
os.rename('fort.msh',file)
-#@ MODIF t_fonction Utilitai DATE 31/05/2005 AUTEUR DURAND C.DURAND
+#@ MODIF t_fonction Utilitai DATE 25/09/2006 AUTEUR MCOURTOI M.COURTOIS
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
from Numeric import *
import copy
import types
+from sets import Set
+
+class FonctionError(Exception):
+ pass
def interp(typ_i,val,x1,x2,y1,y2) :
+ """Interpolation linéaire/logarithmique entre un couple de valeurs
+ """
if typ_i==['LIN','LIN']: return y1+(y2-y1)*(val-x1)/(x2-x1)
if typ_i==['LIN','LOG']: return exp(log(y1)+(val-x1)*(log(y2)-log(y1))/(x2-x1))
if typ_i==['LOG','LOG']: return exp(log(y1)+(log(val)-log(x1))*(log(y2)-log(y1))/(log(x2)-log(x1)))
if typ_i[0]=='NON' :
if val==x1 : return y1
elif val==x2 : return y2
- else : raise StandardError, 'fonction : interpolation NON'
+ else : raise FonctionError, 'fonction : interpolation NON'
def is_ordo(liste) :
- listb=dict([(i,0) for i in liste]).keys()
+ listb=list(Set(liste))
listb.sort()
return liste==listb
class t_fonction :
- ### Classe pour fonctions réelles, équivalent au type aster = fonction_sdaster
+ """Classe pour fonctions réelles, équivalent au type aster = fonction_sdaster
+ """
def __init__(self,vale_x,vale_y,para) :
- # création d'un objet fonction
- # vale_x et vale_y sont des listes de réels de meme longueur
- # para est un dictionnaire contenant les entrées PROL_DROITE, PROL_GAUCHE et INTERPOL (cf sd ASTER)
+ """Création d'un objet fonction
+ - vale_x et vale_y sont des listes de réels de meme longueur
+ - para est un dictionnaire contenant les entrées PROL_DROITE, PROL_GAUCHE et INTERPOL (cf sd ASTER)
+ """
pk=para.keys()
pk.sort()
if pk!=['INTERPOL','NOM_PARA','NOM_RESU','PROL_DROITE','PROL_GAUCHE'] :
- raise StandardError, 'fonction : parametres incorrects'
+ raise FonctionError, 'fonction : parametres incorrects'
if para['INTERPOL'] not in [['NON','NON'],['LIN','LIN'],['LIN','LOG'],['LOG','LOG'],['LOG','LIN'],] :
- raise StandardError, 'fonction : parametre INTERPOL incorrect'
+ raise FonctionError, 'fonction : parametre INTERPOL incorrect'
if para['PROL_DROITE'] not in ['EXCLU','CONSTANT','LINEAIRE'] :
- raise StandardError, 'fonction : parametre PROL_DROITE incorrect'
+ raise FonctionError, 'fonction : parametre PROL_DROITE incorrect'
if para['PROL_GAUCHE'] not in ['EXCLU','CONSTANT','LINEAIRE'] :
- raise StandardError, 'fonction : parametre PROL_GAUCHE incorrect'
+ raise FonctionError, 'fonction : parametre PROL_GAUCHE incorrect'
self.vale_x = array(vale_x)
self.vale_y = array(vale_y)
self.para = para
if len(self.vale_x)!=len(self.vale_y) :
- raise StandardError, 'fonction : longueur abscisse <> longueur ordonnées'
+ raise FonctionError, 'fonction : longueur abscisse <> longueur ordonnées'
if not is_ordo(self.vale_x) :
- raise StandardError, 'fonction : abscisses non strictement croissantes'
+ raise FonctionError, 'fonction : abscisses non strictement croissantes'
def __add__(self,other) :
- # addition avec une autre fonction ou un nombre, par surcharge de l'opérateur +
+ """addition avec une autre fonction ou un nombre, par surcharge de l'opérateur +
+ """
if isinstance(other,t_fonction):
para=copy.copy(self.para)
vale_x,para['PROL_GAUCHE'],para['PROL_DROITE']=self.homo_support(other)
elif type(other) in [types.FloatType,types.IntType,types.ComplexType] :
if isinstance(self,t_fonction_c): return t_fonction_c(self.vale_x,self.vale_y+other,self.para)
else : return t_fonction(self.vale_x,self.vale_y+other,self.para)
- else: raise StandardError, 'fonctions : erreur de type dans __add__'
+ else: raise FonctionError, 'fonctions : erreur de type dans __add__'
def __mul__(self,other) :
- # multiplication avec une autre fonction ou un nombre, par surcharge de l'opérateur *
+ """multiplication avec une autre fonction ou un nombre, par surcharge de l'opérateur *
+ """
if isinstance(other,t_fonction):
para=copy.copy(self.para)
vale_x,para['PROL_GAUCHE'],para['PROL_DROITE']=self.homo_support(other)
return t_fonction(self.vale_x,self.vale_y*other,self.para)
elif type(other) ==types.ComplexType :
return t_fonction_c(self.vale_x,self.vale_y*other,self.para)
- else: raise StandardError, 'fonctions : erreur de type dans __mul__'
+ else: raise FonctionError, 'fonctions : erreur de type dans __mul__'
def __repr__(self) :
- # affichage de la fonction en double colonne
+ """affichage de la fonction en double colonne
+ """
texte=[]
for i in range(len(self.vale_x)) :
texte.append('%f %f' % (self.vale_x[i],self.vale_y[i]))
return '\n'.join(texte)
def __getitem__(self,other) :
- # composition de deux fonction F[G]=FoG=F(G(x))
+ """composition de deux fonction F[G]=FoG=F(G(x))
+ """
para=copy.copy(self.para)
if other.para['NOM_RESU']!=self.para['NOM_PARA'] :
- raise StandardError,'''composition de fonctions : NOM_RESU1 et NOM_PARA2 incohérents '''
+ raise FonctionError,'''composition de fonctions : NOM_RESU1 et NOM_PARA2 incohérents '''
para['NOM_PARA']==other.para['NOM_PARA']
return t_fonction(other.vale_x,map(self,other.vale_y),para)
def __call__(self,val,tol=1.e-6):
- # méthode pour évaluer f(x)
- # tolérance, par défaut 1.e-6 en relatif sur la longueur de l'intervalle
- # adjacent, pour capter les erreurs d'arrondi en cas de prolongement exclu
+ """méthode pour évaluer f(x)
+ - tolérance, par défaut 1.e-6 en relatif sur la longueur de l'intervalle
+ - adjacent, pour capter les erreurs d'arrondi en cas de prolongement exclu
+ """
i=searchsorted(self.vale_x,val)
n=len(self.vale_x)
if i==0 :
if self.para['PROL_GAUCHE']=='EXCLU' :
eps_g=(val-self.vale_x[0] )/(self.vale_x[1] -self.vale_x[0])
if abs(eps_g)<=tol : return self.vale_y[0]
- else : raise StandardError, 'fonction évaluée hors du domaine de définition'
+ else : raise FonctionError, 'fonction évaluée hors du domaine de définition'
else :
if self.para['PROL_GAUCHE']=='CONSTANT' : return self.vale_y[0]
if self.para['PROL_GAUCHE']=='LINEAIRE' : return interp(self.para['INTERPOL'],val,self.vale_x[0],
if self.para['PROL_DROITE']=='EXCLU' :
eps_d=(val-self.vale_x[-1])/(self.vale_x[-1]-self.vale_x[-2])
if abs(eps_d)<=tol : return self.vale_y[-1]
- else : raise StandardError, 'fonction évaluée hors du domaine de définition'
+ else : raise FonctionError, 'fonction évaluée hors du domaine de définition'
else :
if self.para['PROL_DROITE']=='CONSTANT' : return self.vale_y[-1]
if self.para['PROL_DROITE']=='LINEAIRE' : return interp(self.para['INTERPOL'],val,self.vale_x[-1],
self.vale_y[i])
def homo_support(self,other) :
- # renvoie le support d'abscisses homogénéisé entre self et other
- # i.e. si prolongement exclu, on retient plus grand min ou plus petit max, selon
- # si prolongement autorisé, on conserve les abscisses d'une fonction, extrapolantes
- # sur l'autre.
- # Pour les points intermédiaires : union et tri des valeurs des vale_x réunis.
+ """Renvoie le support d'abscisses homogénéisé entre self et other
+ i.e. si prolongement exclu, on retient plus grand min ou plus petit max, selon
+ si prolongement autorisé, on conserve les abscisses d'une fonction, extrapolantes
+ sur l'autre.
+ Pour les points intermédiaires : union et tri des valeurs des vale_x réunis.
+ """
if other.vale_x[0]>self.vale_x[0]:
if other.para['PROL_GAUCHE']!='EXCLU' : f_g=self
else : f_g=other
return vale_x,prol_gauche,prol_droite
def cut(self,rinf,rsup,prec,crit='RELATIF') :
- # renvoie la fonction self dont on a 'coupé' les extrémités en x=rinf et x=rsup
- # pour la recherche de rinf et rsup dans la liste d'abscisses :
- # prec=precision crit='absolu' ou 'relatif'
+ """Renvoie la fonction self dont on a 'coupé' les extrémités en x=rinf et x=rsup
+ pour la recherche de rinf et rsup dans la liste d'abscisses :
+ prec=precision crit='absolu' ou 'relatif'
+ """
para=copy.copy(self.para)
para['PROL_GAUCHE']='EXCLU'
para['PROL_DROITE']='EXCLU'
if crit=='ABSOLU' : rinf_tab=greater(abs(self.vale_x-rinf),prec)
elif crit=='RELATIF': rinf_tab=greater(abs(self.vale_x-rinf),prec*rinf)
- else : raise StandardError, 'fonction : cut : critère absolu ou relatif'
+ else : raise FonctionError, 'fonction : cut : critère absolu ou relatif'
if crit=='ABSOLU' : rsup_tab=greater(abs(self.vale_x-rsup),prec)
elif crit=='RELATIF': rsup_tab=greater(abs(self.vale_x-rsup),prec*rsup)
- else : raise StandardError, 'fonction : cut : critère absolu ou relatif'
+ else : raise FonctionError, 'fonction : cut : critère absolu ou relatif'
if alltrue(rinf_tab) : i=searchsorted(self.vale_x,rinf)
else : i=rinf_tab.tolist().index(0)+1
if alltrue(rsup_tab) : j=searchsorted(self.vale_x,rsup)
return t_fonction(vale_x,vale_y,para)
def cat(self,other,surcharge) :
- # renvoie une fonction concaténée avec une autre, avec règles de surcharge
+ """renvoie une fonction concaténée avec une autre, avec règles de surcharge
+ """
para=copy.copy(self.para)
- if self.para['INTERPOL']!=other.para['INTERPOL'] : raise StandardError, 'concaténation de fonctions à interpolations différentes'
+ if self.para['INTERPOL']!=other.para['INTERPOL'] : raise FonctionError, 'concaténation de fonctions à interpolations différentes'
if min(self.vale_x)<min(other.vale_x) :
f1=self
f2=other
return t_fonction(vale_x,vale_y,para)
def tabul(self) :
- # mise en forme de la fonction selon un vecteur unique (x1,y1,x2,y2,...)
+ """mise en forme de la fonction selon un vecteur unique (x1,y1,x2,y2,...)
+ """
__tab=array([self.vale_x,self.vale_y])
return ravel(transpose(__tab)).tolist()
def extreme(self) :
- # renvoie un dictionnaire des valeurs d'ordonnées min et max
+ """renvoie un dictionnaire des valeurs d'ordonnées min et max
+ """
val_min=min(self.vale_y)
val_max=max(self.vale_y)
vm={}
return vm
def trapeze(self,coef) :
- # renvoie la primitive de la fonction, calculée avec la constante d'intégration 'coef'
+ """renvoie la primitive de la fonction, calculée avec la constante d'intégration 'coef'
+ """
trapz = zeros(len(self.vale_y),Float)
trapz[0] = coef
trapz[1:] = (self.vale_y[1:]+self.vale_y[:-1])/2*(self.vale_x[1:]-self.vale_x[:-1])
return t_fonction(self.vale_x,prim_y,para)
def simpson(self,coef) :
- # renvoie la primitive de la fonction, calculée avec la constante d'intégration 'coef'
+ """renvoie la primitive de la fonction, calculée avec la constante d'intégration 'coef'
+ """
para=copy.copy(self.para)
para['PROL_GAUCHE']='EXCLU'
para['PROL_DROITE']='EXCLU'
return t_fonction(self.vale_x,prim_y,para)
def derive(self) :
- # renvoie la dérivée de la fonction
+ """renvoie la dérivée de la fonction
+ """
pas=self.vale_x[1:]-self.vale_x[:-1]
pentes=(self.vale_y[1:]-self.vale_y[:-1])/(self.vale_x[1:]-self.vale_x[:-1])
derive=(pentes[1:]*pas[1:]+pentes[:-1]*pas[:-1])/(pas[1:]+pas[:-1])
return t_fonction(self.vale_x,derv_y,para)
def inverse(self) :
- # renvoie l'inverse de la fonction
- # on intervertit vale_x et vale_y, on swape interpolation
+ """renvoie l'inverse de la fonction
+ on intervertit vale_x et vale_y, on swape interpolation
+ """
para=copy.copy(self.para)
para['NOM_RESU']='TOUTRESU'
para['NOM_PARA']=self.para['NOM_PARA']
return t_fonction(vale_x,vale_y,para)
def abs(self) :
- # renvoie la mm fonction avec valeur absolue des ordonnées
+ """renvoie la mm fonction avec valeur absolue des ordonnées
+ """
para=copy.copy(self.para)
if para['PROL_GAUCHE']=='LINEAIRE' : para['PROL_GAUCHE']='EXCLU'
if para['PROL_DROITE']=='LINEAIRE' : para['PROL_DROITE']='EXCLU'
return t_fonction(self.vale_x,absolute(self.vale_y),para)
def evalfonc(self,liste_val) :
- # renvoie la mm fonction interpolée aux points définis par la liste 'liste_val'
- return t_fonction(liste_val,map(self,liste_val),self.para)
+ """renvoie la mm fonction interpolée aux points définis par la liste 'liste_val'
+ """
+ return self.__class__(liste_val,map(self,liste_val),self.para)
def sup(self,other) :
- # renvoie l'enveloppe supérieure de self et other
+ """renvoie l'enveloppe supérieure de self et other
+ """
para=copy.copy(self.para)
-# commentaire : pour les prolongements et l'interpolation, c'est self
-# qui prime sur other
+ # commentaire : pour les prolongements et l'interpolation, c'est self
+ # qui prime sur other
vale_x=self.vale_x.tolist()+other.vale_x.tolist()
-# on ote les abscisses doublons
+ # on ote les abscisses doublons
vale_x=dict([(i,0) for i in vale_x]).keys()
vale_x.sort()
vale_x=array(vale_x)
return t_fonction(vale_x,vale_y,para)
def inf(self,other) :
- # renvoie l'enveloppe inférieure de self et other
+ """renvoie l'enveloppe inférieure de self et other
+ """
para=copy.copy(self.para)
-# commentaire : pour les prolongements et l'interpolation, c'est self
-# qui prime sur other
+ # commentaire : pour les prolongements et l'interpolation, c'est self
+ # qui prime sur other
vale_x=self.vale_x.tolist()+other.vale_x.tolist()
-# on ote les abscisses doublons
+ # on ote les abscisses doublons
vale_x=dict([(i,0) for i in vale_x]).keys()
vale_x.sort()
vale_x=array(vale_x)
return t_fonction(vale_x,vale_y,para)
def suppr_tend(self) :
- # pour les corrections d'accélérogrammes
- # suppression de la tendance moyenne d'une fonction
+ """pour les corrections d'accélérogrammes
+ suppression de la tendance moyenne d'une fonction
+ """
para=copy.copy(self.para)
xy=sum(self.vale_x*self.vale_y)
x0=sum(self.vale_x)
return t_fonction(self.vale_x,self.vale_y-a1*self.vale_x-a0,self.para)
def normel2(self) :
- # norme de la fonction
+ """norme de la fonction
+ """
__ex=self*self
__ex=__ex.trapeze(0.)
return sqrt(__ex.vale_y[-1])
def fft(self,methode) :
- # renvoie la transformée de Fourier rapide FFT
+ """renvoie la transformée de Fourier rapide FFT
+ """
import FFT
para=copy.copy(self.para)
para['NOM_PARA']='FREQ'
if self.para['NOM_PARA']!='INST' :
- raise StandardError, 'fonction réelle : FFT : NOM_PARA=INST pour une transformée directe'
+ raise FonctionError, 'fonction réelle : FFT : NOM_PARA=INST pour une transformée directe'
pas = self.vale_x[1]-self.vale_x[0]
for i in range(1,len(self.vale_x)) :
ecart = abs(((self.vale_x[i]-self.vale_x[i-1])-pas)/pas)
if ecart>1.e-2 :
- raise StandardError, 'fonction réelle : FFT : la fonction doit etre à pas constant'
+ raise FonctionError, 'fonction réelle : FFT : la fonction doit etre à pas constant'
n=int(log(len(self.vale_x))/log(2))
if methode=='TRONCATURE' :
vale_y=self.vale_y[:2**n]
return t_fonction_c(vale_x,vale_y,para)
class t_fonction_c(t_fonction) :
- ### Classe pour fonctions complexes, équivalent au type aster = fonction_c
+ """Classe pour fonctions complexes, équivalent au type aster = fonction_c
+ """
def tabul(self) :
- # mise en forme de la fonction selon un vecteur unique (x1,yr1,yi1,x2,yr2,yr2,...)
+ """mise en forme de la fonction selon un vecteur unique (x1,yr1,yi1,x2,yr2,yr2,...)
+ """
__tab=array([self.vale_x,self.vale_y.real,self.vale_y.imag])
return ravel(transpose(__tab)).tolist()
def __repr__(self) :
- # affichage de la fonction en double colonne
+ """affichage de la fonction en double colonne
+ """
texte=[]
for i in range(len(self.vale_x)) :
texte.append('%f %f + %f .j' % (self.vale_x[i],self.vale_y[i].real,self.vale_y[i].imag))
return '\n'.join(texte)
def fft(self,methode,syme) :
- # renvoie la transformée de Fourier rapide FFT (sens inverse)
+ """renvoie la transformée de Fourier rapide FFT (sens inverse)
+ """
import FFT
para=copy.copy(self.para)
para['NOM_PARA']='INST'
if self.para['NOM_PARA']!='FREQ' :
- raise StandardError, 'fonction complexe : FFT : NOM_PARA=FREQ pour une transformée directe'
+ raise FonctionError, 'fonction complexe : FFT : NOM_PARA=FREQ pour une transformée directe'
pas = self.vale_x[1]-self.vale_x[0]
for i in range(1,len(self.vale_x)) :
ecart = abs(((self.vale_x[i]-self.vale_x[i-1])-pas)/pas)
if ecart>1.e-3 :
- raise StandardError, 'fonction complexe : FFT : la fonction doit etre à pas constant'
+ raise FonctionError, 'fonction complexe : FFT : la fonction doit etre à pas constant'
n=int(log(len(self.vale_x))/log(2))
if syme=='OUI' and len(self.vale_x)==2**n :
vale_fonc=self.vale_y
vale_fonc=vale_fonc+vale_fon1
vale_fonc=array(vale_fonc)
if syme=='OUI' and len(self.vale_x)!=2**n :
- raise StandardError, 'fonction complexe : FFT : syme=OUI et nombre de points<>2**n'
+ raise FonctionError, 'fonction complexe : FFT : syme=OUI et nombre de points<>2**n'
part1=vale_fonc[:len(vale_fonc)/2+1]
part2=vale_fonc[1:len(vale_fonc)/2]
part2=conjugate(part2)
class t_nappe :
- ### Classe pour nappes, équivalent au type aster = nappe_sdaster
+ """Classe pour nappes, équivalent au type aster = nappe_sdaster
+ """
def __init__(self,vale_para,l_fonc,para) :
- # création d'un objet nappe
- # vale_para est la liste de valeur des parametres (mot clé PARA dans DEFI_NAPPE)
- # para est un dictionnaire contenant les entrées PROL_DROITE, PROL_GAUCHE et INTERPOL (cf sd ASTER)
- # l_fonc est la liste des fonctions, de cardinal égal à celui de vale_para
+ """Création d'un objet nappe
+ - vale_para est la liste de valeur des parametres (mot clé PARA dans DEFI_NAPPE)
+ - para est un dictionnaire contenant les entrées PROL_DROITE, PROL_GAUCHE et INTERPOL (cf sd ASTER)
+ - l_fonc est la liste des fonctions, de cardinal égal à celui de vale_para
+ """
pk=para.keys()
pk.sort()
if pk!=['INTERPOL','NOM_PARA','NOM_PARA_FONC','NOM_RESU','PROL_DROITE','PROL_GAUCHE'] :
- raise StandardError, 'nappe : parametres incorrects'
+ raise FonctionError, 'nappe : parametres incorrects'
if para['INTERPOL'] not in [['NON','NON'],['LIN','LIN'],
['LIN','LOG'],['LOG','LOG'],['LOG','LIN'],] :
- raise StandardError, 'nappe : parametre INTERPOL incorrect'
+ raise FonctionError, 'nappe : parametre INTERPOL incorrect'
if para['PROL_DROITE'] not in ['EXCLU','CONSTANT','LINEAIRE'] :
- raise StandardError, 'nappe : parametre PROL_DROITE incorrect'
+ raise FonctionError, 'nappe : parametre PROL_DROITE incorrect'
if para['PROL_GAUCHE'] not in ['EXCLU','CONSTANT','LINEAIRE'] :
- raise StandardError, 'nappe : parametre PROL_GAUCHE incorrect'
+ raise FonctionError, 'nappe : parametre PROL_GAUCHE incorrect'
self.vale_para = array(vale_para)
if type(l_fonc) not in (types.ListType,types.TupleType) :
- raise StandardError, 'nappe : la liste de fonctions fournie n est pas une liste'
+ raise FonctionError, 'nappe : la liste de fonctions fournie n est pas une liste'
if len(l_fonc)!=len(vale_para) :
- raise StandardError, 'nappe : nombre de fonctions différent du nombre de valeurs du paramètre'
+ raise FonctionError, 'nappe : nombre de fonctions différent du nombre de valeurs du paramètre'
for f in l_fonc :
if not isinstance(f,t_fonction) and not isinstance(f,t_fonction_c) :
- raise StandardError, 'nappe : les fonctions fournies ne sont pas du bon type'
+ raise FonctionError, 'nappe : les fonctions fournies ne sont pas du bon type'
self.l_fonc = l_fonc
self.para = para
def __call__(self,val1,val2):
- # méthode pour évaluer nappe(val1,val2)
+ """méthode pour évaluer nappe(val1,val2)
+ """
i=searchsorted(self.vale_para,val1)
n=len(self.vale_para)
if i==0 :
if val1==self.vale_para[0] : return self.l_fonc[0](val2)
if val1 <self.vale_para[0] :
- if self.para['PROL_GAUCHE']=='EXCLU' : raise StandardError, 'nappe évaluée hors du domaine de définition'
+ if self.para['PROL_GAUCHE']=='EXCLU' : raise FonctionError, 'nappe évaluée hors du domaine de définition'
if self.para['PROL_GAUCHE']=='CONSTANT' : return self.l_fonc[0](val2)
if self.para['PROL_GAUCHE']=='LINEAIRE' : return interp(self.para['INTERPOL'],val1,
self.vale_para[0],
elif i==n :
if val1==self.vale_para[-1] : return self.l_fonc[-1](val2)
if val1 >self.vale_para[-1] :
- if self.para['PROL_DROITE']=='EXCLU' : raise StandardError, 'nappe évaluée hors du domaine de définition'
+ if self.para['PROL_DROITE']=='EXCLU' : raise FonctionError, 'nappe évaluée hors du domaine de définition'
if self.para['PROL_DROITE']=='CONSTANT' : return self.l_fonc[-1](val2)
if self.para['PROL_DROITE']=='LINEAIRE' : return interp(self.para['INTERPOL'],val1,
self.vale_para[-1],
self.l_fonc[i-1](val2),
self.l_fonc[i](val2))
+ def evalfonc(self, liste_val) :
+ """Renvoie la mm nappe dont les fonctions sont interpolées aux points définis
+ par la liste 'liste_val'.
+ """
+ l_fonc = []
+ for f in self.l_fonc:
+ f2 = f.evalfonc(liste_val)
+ l_fonc.append(f2)
+ return t_nappe(self.vale_para, l_fonc, self.para)
+
def __add__(self,other) :
- # addition avec une autre nappe ou un nombre, par surcharge de l'opérateur +
+ """addition avec une autre nappe ou un nombre, par surcharge de l'opérateur +
+ """
l_fonc=[]
if isinstance(other,t_nappe):
- if self.vale_para!=other.vale_para : raise StandardError, 'nappes à valeurs de paramètres différentes'
+ if self.vale_para!=other.vale_para : raise FonctionError, 'nappes à valeurs de paramètres différentes'
for i in range(len(self.l_fonc)) : l_fonc.append(self.l_fonc[i]+other.l_fonc[i])
elif type(other) in [types.FloatType,types.IntType] :
for i in range(len(self.l_fonc)) : l_fonc.append(self.l_fonc[i]+other)
- else: raise StandardError, 't_nappe : erreur de type dans __add__'
+ else: raise FonctionError, 't_nappe : erreur de type dans __add__'
return t_nappe(self.vale_para,l_fonc,self.para)
def __mul__(self,other) :
- # multiplication avec une autre fonction ou un nombre, par surcharge de l'opérateur *
+ """multiplication avec une autre fonction ou un nombre, par surcharge de l'opérateur *
+ """
l_fonc=[]
if isinstance(other,t_nappe):
- if self.vale_para!=other.vale_para : raise StandardError, 'nappes à valeurs de paramètres différentes'
+ if self.vale_para!=other.vale_para : raise FonctionError, 'nappes à valeurs de paramètres différentes'
for i in range(len(self.l_fonc)) : l_fonc.append(self.l_fonc[i]*other.l_fonc[i])
elif type(other) in [types.FloatType,types.IntType] :
for i in range(len(self.l_fonc)) : l_fonc.append(self.l_fonc[i]*other)
- else: raise StandardError, 't_nappe : erreur de type dans __mul__'
+ else: raise FonctionError, 't_nappe : erreur de type dans __mul__'
return t_nappe(self.vale_para,l_fonc,self.para)
def __repr__(self) :
- # affichage de la nappe en double colonne
+ """affichage de la nappe en double colonne
+ """
texte=[]
for i in range(len(self.vale_para)) :
texte.append('paramètre : %f' % self.vale_para[i])
return '\n'.join(texte)
def homo_support(self,other) :
- # renvoie la nappe self avec un support union de celui de self et de other
- # le support est la discrétisation vale_para et les discrétisations des fonctions
+ """Renvoie la nappe self avec un support union de celui de self et de other
+ le support est la discrétisation vale_para et les discrétisations des fonctions
+ """
if self==other : return self
- if self.para!=other.para : raise StandardError, 'combinaison de nappes à caractéristiques interpolation et prolongement différentes'
+ if self.para!=other.para : raise FonctionError, 'combinaison de nappes à caractéristiques interpolation et prolongement différentes'
vale_para=self.vale_para.tolist()+other.vale_para.tolist()
vale_para=dict([(i,0) for i in vale_para]).keys()
vale_para.sort()
l_fonc.append(t_fonction(new_vale_x,new_vale_y,new_para))
if isinstance(other_fonc,t_fonction_c) :
l_fonc.append(t_fonction_c(new_vale_x,new_vale_y,new_para))
- else : raise StandardError, 'combinaison de nappes : incohérence'
+ else : raise FonctionError, 'combinaison de nappes : incohérence'
return t_nappe(vale_para,l_fonc,self.para)
def extreme(self) :
- # renvoie un dictionnaire des valeurs d'ordonnées min et max
+ """renvoie un dictionnaire des valeurs d'ordonnées min et max
+ """
val_min=min([min(fonc.vale_y) for fonc in self.l_fonc])
val_max=max([max(fonc.vale_y) for fonc in self.l_fonc])
vm={'min':[],'max':[]}
-#@ MODIF defi_cable_bp_ops Macro DATE 14/09/2004 AUTEUR MCOURTOI M.COURTOIS
+#@ MODIF defi_cable_bp_ops Macro DATE 14/11/2006 AUTEUR VIVAN L.VIVAN
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
Ecriture de la macro DEFI_CABLE_BP
"""
from Accas import _F
- import aster,string
+ import aster,string, types
ier=0
# On importe les definitions des commandes a utiliser dans la macro
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 type(GROUP_MA_BETON) in [types.TupleType, types.ListType]: gma = list(GROUP_MA_BETON)
+ else: gma = [ GROUP_MA_BETON ]
+ gma.insert(0, __CAB)
+
+ motscle2= {'CREA_GROUP_NO': [{'LONGUEUR': LONGUEUR, 'RAYON': RAYON, 'OPTION': 'TUNNEL', 'GROUP_MA': gma, 'GROUP_MA_AXE': __CAB, 'NOM': __NOM1}]}
if i.has_key('MAILLE') == 1:
print ' '
print ' # ---------------------------------------------------------------------------'
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 type(GROUP_MA_BETON) in [types.TupleType, types.ListType]: gma = list(GROUP_MA_BETON)
+ else: gma = [ GROUP_MA_BETON ]
+ gma.insert(0, __CAB)
+
+ motscle2= {'CREA_GROUP_NO': [{'LONGUEUR': LONGUEUR, 'RAYON': RAYON, 'OPTION': 'TUNNEL', 'GROUP_MA': gma, 'GROUP_MA_AXE': __CAB, 'NOM': __NOM2}]}
+
if i.has_key('MAILLE') == 1:
print ' '
print ' # ---------------------------------------------------------------------------'
-#@ MODIF macr_ascouf_mail_ops Macro DATE 24/05/2006 AUTEUR CIBHHLV L.VIVAN
+#@ MODIF macr_ascouf_mail_ops Macro DATE 06/09/2006 AUTEUR CIBHHLV L.VIVAN
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# GIBI
+ DEFI_FICHIER(ACTION='LIBERER',UNITE=19)
+ DEFI_FICHIER(ACTION='LIBERER',UNITE=20)
EXEC_LOGICIEL( LOGICIEL = logiel ,
ARGUMENT = ( _F(NOM_PARA=nomFichierDATG),
_F(NOM_PARA=nomFichierGIBI), ), )
# PRE_GIBI
PRE_GIBI()
- if SYME == 'QUART' : self.DeclareOut('nomres',self.sd)
# LIRE_MAILLAGE
- nomres=LIRE_MAILLAGE(INFO=INFO)
+ __nomres=LIRE_MAILLAGE(INFO=INFO)
# DEFI_GROUP 1
CRITERE = CRITER,),)
- nomres=DEFI_GROUP(reuse =nomres,
- MAILLAGE=nomres,
+ __nomres=DEFI_GROUP(reuse =__nomres,
+ MAILLAGE=__nomres,
**motscles )
#
# DEFI_GROUP 2
motscles['CREA_GROUP_NO'].append(_F(NOM = 'G_AXE_2',
INTERSEC = tuple(l_peau+l_intersec),),)
- nomres=DEFI_GROUP(reuse =nomres,
- MAILLAGE=nomres,
+ __nomres=DEFI_GROUP(reuse =__nomres,
+ MAILLAGE=__nomres,
**motscles )
# AFFE_MODELE
- __MODELE=AFFE_MODELE( MAILLAGE=nomres,
+ __MODELE=AFFE_MODELE( MAILLAGE=__nomres,
AFFE=_F( GROUP_MA = 'COUDE' ,
PHENOMENE = 'MECANIQUE' ,
MODELISATION = '3D' , )
D_PLAQ_TUBE['AZIMUT']=MCL_SOUS_EPAIS[0].IPHIC
else:pass
motscles['PLAQ_TUBE'].append(_F(**D_PLAQ_TUBE),)
- nomres=MODI_MAILLAGE( reuse =nomres,
- MAILLAGE=nomres,
+ __nomres=MODI_MAILLAGE( reuse =__nomres,
+ MAILLAGE=__nomres,
**motscles )
# MODI_MAILLAGE 2
if FISS_COUDE!=None:
if FISS_COUDE['FISSURE'] == 'DEB_INIT':
motscles['ORIE_PEAU_3D']=_F(GROUP_MA=('PEAUINT','EXTUBE','FACE1','FACE2'),)
- nomres=MODI_MAILLAGE(reuse =nomres,
- MAILLAGE=nomres,
+ __nomres=MODI_MAILLAGE(reuse =__nomres,
+ MAILLAGE=__nomres,
MODELE =__MODELE,
**motscles)
# CREA_MAILLAGE
- if SYME != 'QUART':
- self.DeclareOut('nomre2',self.sd)
- motscles={}
- motscles['CREA_POI1']=[]
- motscles['CREA_POI1'].append(_F(NOM_GROUP_MA='P1',
- GROUP_NO='P1'),)
- if TYPBOL == None :
- motscles['CREA_POI1'].append(_F(NOM_GROUP_MA='P2',
+ self.DeclareOut('nomre2',self.sd)
+ motscles={}
+ motscles['CREA_POI1']=[]
+ motscles['CREA_POI1'].append(_F(NOM_GROUP_MA='P1',
+ GROUP_NO='P1'),)
+ if TYPBOL == None :
+ motscles['CREA_POI1'].append(_F(NOM_GROUP_MA='P2',
GROUP_NO='P2'),)
- nomre2=CREA_MAILLAGE( MAILLAGE=nomres,
- **motscles)
- else:
- nomre2=nomres
-
-
+ nomre2=CREA_MAILLAGE( MAILLAGE=__nomres,
+ **motscles)
# IMPRESSSION
if IMPRESSION!=None:
if IMPRESSION.__class__.__name__ !='MCList' : IMPRESSION =[IMPRESSION,]
-#@ MODIF macr_aspic_mail_ops Macro DATE 31/05/2006 AUTEUR CIBHHLV L.VIVAN
+#@ MODIF macr_aspic_mail_ops Macro DATE 04/10/2006 AUTEUR CIBHHPD L.SALMONA
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
DN = sqrt( pow((XA - XN),2) + pow((YA - YN),2) + pow((ZA - ZN),2) )
RAPP = D0N0 / DN
ECART = (RAPP - 1.0) * D0N0
+ # Correction necessaire dans le cas theta grand (cf. AL9679)
+ if ( abs(STHETA) > 0.8) :
+ DXY = sqrt(pow(XD,2) + pow(YD,2) )
+ XN = XN * DXY/XD0
+ YN = YN * DXY/XD0
+ SGAMN = YN / ZN0
+ ZN = ZN0 * sqrt(1.0 - pow(SGAMN,2))
+ D0N0 = sqrt( pow((XA0 - XN0),2) + pow((ZA0 - ZN0),2) )
+ DN = sqrt( pow((XA - XN),2) + pow((YA - YN),2) + pow((ZA - ZN),2) )
+ RAPP = D0N0 / DN
+ ECART = (ECART + (RAPP - 1.0) * D0N0)/2
A = A + ECART
elif (ITYPSO == 2) :
AFFE_MODELE =self.get_cmd('AFFE_MODELE')
CREA_MAILLAGE =self.get_cmd('CREA_MAILLAGE')
IMPR_RESU =self.get_cmd('IMPR_RESU')
+ DEFI_FICHIER =self.get_cmd('DEFI_FICHIER')
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
ALP,BETA, NS, NC, NT, POSI ,NDT,NSDT,TFISS,
ZETA,ITYPSO,DPENE, NIVMAG,loc_datg)
#
+ DEFI_FICHIER(ACTION='LIBERER',UNITE=19)
+ DEFI_FICHIER(ACTION='LIBERER',UNITE=20)
EXEC_LOGICIEL( LOGICIEL = logiel ,
ARGUMENT = ( _F(NOM_PARA=nomFichierDATG),
_F(NOM_PARA=nomFichierGIBI), ), )
-#@ MODIF macro_matr_asse_ops Macro DATE 05/07/2005 AUTEUR DURAND C.DURAND
+#@ MODIF macro_matr_asse_ops Macro DATE 05/07/2006 AUTEUR CIBHHPD L.SALMONA
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
-
-
def macro_matr_asse_ops(self,MODELE,CHAM_MATER,CARA_ELEM,MATR_ASSE,
SOLVEUR,NUME_DDL,CHARGE,INST,**args):
"""
motscles={'OPTION':option}
+ if option == 'RIGI_MECA_HYST':
+ if (not lrigel):
+ UTMESS('F', "MACRO_MATR_ASSE", "POUR CALCULER RIGI_MECA_HYST, IL FAUT AVOIR CALCULE RIGI_MECA AUPARAVANT (DANS LE MEME APPEL)")
+ motscles['RIGI_MECA'] =rigel
if option == 'AMOR_MECA':
if (not lrigel or not lmasel):
ier=ier+1
-#@ MODIF reca_algo Macro DATE 31/01/2006 AUTEUR MCOURTOI M.COURTOIS
+#@ MODIF reca_algo Macro DATE 05/07/2006 AUTEUR CIBHHPD L.SALMONA
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
def test_convergence(gradient_init,erreur,A,s):
gradient = calcul_gradient(A,erreur)+s
- epsilon = Numeric.dot(gradient,gradient)/Numeric.dot(gradient_init,gradient_init)
+ try:
+ epsilon = Numeric.dot(gradient,gradient)/Numeric.dot(gradient_init,gradient_init)
+ except:
+ self.cr.fatal("<F> <MACR_RECAL> Erreur dans le test de convergence de MACR_RECAL")
+ return
epsilon = epsilon**0.5
return epsilon
-#@ MODIF recal Macro DATE 11/07/2005 AUTEUR PABHHHH N.TARDIEU
+#@ MODIF recal Macro DATE 05/07/2006 AUTEUR CIBHHPD L.SALMONA
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
txt="\nVous avez entré " +str(len(REPONSES))+ " réponses et "+str(len(RESU_EXP))+ " expériences ; On doit avoir autant de réponses que de résultats expérimentaux"
return txt
+def verif_RESU_EXP(RESU_EXP):
+ # RESU_EXP doit etre une liste de tableaux Numeric de taille Nx2
+ # pour éviter l'arret du programme
+ txt=""
+ for index,resu in enumerate(RESU_EXP):
+ if (isinstance(resu,Numeric.ArrayType)):
+ if (len(Numeric.shape(resu)) != 2):
+ txt="\nLa courbe experimentale no " +str(index+1)+ " n'est pas un tableau de N lignes et 2 colonnes."
+ else:
+ if (Numeric.shape(resu)[1] != 2):
+ txt="\nLa courbe experimentale no " +str(index+1)+ " n'est pas un tableau de N lignes et 2 colonnes."
+ else:
+ txt="\nLa courbe experimentale no " +str(index+1)+ " n'est pas un tableau Numeric."
+ return txt
+
def compare__dim_poids__dim_RESU_EXP(POIDS,RESU_EXP):
# POIDS et Y sont deux arguments qui doivent avoir la meme dimension
# pour éviter l'arret du programme
#et que la dimension d'une sous liste de REPONSES = 3
texte = texte + erreur_dimension(PARAMETRES,REPONSES)
+ #on verifie le type et la dimension des résultats expérimentaux
+ texte = texte + verif_RESU_EXP(RESU_EXP)
#on verifie que l'on a autant de réponses que de résultats expérimentaux
texte = texte + compare__dim_rep__dim_RESU_EXP(REPONSES,RESU_EXP)
#on verifie que l'on a autant de poids que de résultats expérimentaux
import os,sys
-import prefs
-import sys
-rep_macro = os.path.join(prefs.REPINI,'Cata/cataSTA7')
+rep_macro = os.path.dirname(__file__)
sys.path.insert(0,rep_macro)
from cata import *
pass
#
-__version__="$Name: BR_dev_mars_06 $"
-__Id__="$Id: cata.py,v 1.1.2.1 2006/06/20 12:13:41 pnoyret Exp $"
+__version__="$Name: $"
+__Id__="$Id: cata.py,v 1.2.4.1 2006/12/14 17:22:47 pnoyret Exp $"
#
JdC = JDC_CATA(code='ASTER',
execmodul=None,
# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
-ASSE_VECT_GENE=OPER(nom="ASSE_VECT_GENE",op= 140,sd_prod=vect_asse_gene,
- fr="Assemblage de vecteurs de chargement en coordonnées généralisées",
- reentrant='n',
+# RESPONSABLE VABHHTS J.PELLET
+def asse_vecteur_prod(VECT_ELEM,**args):
+ if AsType(VECT_ELEM) == vect_elem_depl_r : return cham_no_depl_r
+ if AsType(VECT_ELEM) == vect_elem_temp_r : return cham_no_temp_r
+ if AsType(VECT_ELEM) == vect_elem_pres_r : return cham_no_pres_r
+ if AsType(VECT_ELEM) == vect_elem_pres_c : return cham_no_pres_c
+ raise AsException("type de concept resultat non prevu ")
+
+ASSE_VECTEUR=OPER(nom="ASSE_VECTEUR",op=13,sd_prod=asse_vecteur_prod,
+ fr="Assemblage d un second membre",reentrant='n',
UIinfo={"groupes":("Matrices/vecteurs",)},
- NUME_DDL_GENE =SIMP(statut='o',typ=nume_ddl_gene ),
- CHAR_SOUS_STRUC =FACT(statut='o',max='**',
- SOUS_STRUC =SIMP(statut='o',typ='TXM' ),
- VECT_ASSE =SIMP(statut='o',typ=cham_no_depl_r ),
- ),
+ VECT_ELEM =SIMP(statut='o',typ=vect_elem,max='**'),
+ NUME_DDL =SIMP(statut='o',typ=nume_ddl_sdaster ),
+ INFO =SIMP(statut='f',typ='I',into=(1,2,) ),
) ;
#& MODIF COMMANDE DATE 10/06/2004 AUTEUR REZETTE C.REZETTE
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
-# RESPONSABLE VABHHTS J.PELLET
-def asse_vecteur_prod(VECT_ELEM,**args):
- if AsType(VECT_ELEM) == vect_elem_depl_r : return cham_no_depl_r
- if AsType(VECT_ELEM) == vect_elem_temp_r : return cham_no_temp_r
- if AsType(VECT_ELEM) == vect_elem_pres_r : return cham_no_pres_r
- if AsType(VECT_ELEM) == vect_elem_pres_c : return cham_no_pres_c
- raise AsException("type de concept resultat non prevu ")
-
-ASSE_VECTEUR=OPER(nom="ASSE_VECTEUR",op=13,sd_prod=asse_vecteur_prod,
- fr="Assemblage d un second membre",reentrant='n',
+ASSE_VECT_GENE=OPER(nom="ASSE_VECT_GENE",op= 140,sd_prod=vect_asse_gene,
+ fr="Assemblage de vecteurs de chargement en coordonnées généralisées",
+ reentrant='n',
UIinfo={"groupes":("Matrices/vecteurs",)},
- VECT_ELEM =SIMP(statut='o',typ=vect_elem,max='**'),
- NUME_DDL =SIMP(statut='o',typ=nume_ddl_sdaster ),
- INFO =SIMP(statut='f',typ='I',into=(1,2,) ),
+ NUME_DDL_GENE =SIMP(statut='o',typ=nume_ddl_gene ),
+ CHAR_SOUS_STRUC =FACT(statut='o',max='**',
+ SOUS_STRUC =SIMP(statut='o',typ='TXM' ),
+ VECT_ASSE =SIMP(statut='o',typ=cham_no_depl_r ),
+ ),
) ;
#& MODIF COMMANDE DATE 30/06/2004 AUTEUR MCOURTOI M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
TITRE =SIMP(statut='f',typ='TXM',max='**'),
INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2 ) ),
) ;
-#& MODIF COMMANDE DATE 10/10/2005 AUTEUR MCOURTOI M.COURTOIS
+#& MODIF COMMANDE DATE 09/11/2006 AUTEUR CIBHHLV L.VIVAN
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
AMOR_REDUIT =SIMP(statut='f',typ='R',max='**'),
LIST_FREQ =SIMP(statut='f',typ=listr8_sdaster ),
FREQ =SIMP(statut='f',typ='R',max='**'),
- NORME =SIMP(statut='o',typ='R',defaut= 9.81E+0,fr="Valeur de la norme du spectre d oscillateur" ),
+ NORME =SIMP(statut='o',typ='R',fr="Valeur de la norme du spectre d oscillateur" ),
NATURE =SIMP(statut='f',typ='TXM',defaut="ACCE",into=("DEPL","VITE","ACCE") ),
NATURE_FONC =SIMP(statut='f',typ='TXM',defaut="ACCE",into=("DEPL","VITE","ACCE") ),
),
# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
+DEFI_INTERF_DYNA=OPER(nom="DEFI_INTERF_DYNA",op= 98,sd_prod=interf_dyna_clas,
+ reentrant='n',
+ UIinfo={"groupes":("Matrices/vecteurs",)},
+ NUME_DDL =SIMP(statut='o',typ=nume_ddl_sdaster ),
+ INTERFACE =FACT(statut='o',max='**',
+ regles=(ENSEMBLE('NOM','TYPE'),
+# erreur doc U sur la condition qui suit
+ UN_PARMI('NOEUD','GROUP_NO'),),
+ NOM =SIMP(statut='f',typ='TXM' ),
+ TYPE =SIMP(statut='f',typ='TXM',into=("MNEAL","CRAIGB","CB_HARMO","AUCUN") ),
+ NOEUD =SIMP(statut='f',typ=no,max='**'),
+ GROUP_NO =SIMP(statut='f',typ=grno,max='**'),
+ DDL_ACTIF =SIMP(statut='f',typ='TXM',max='**'),
+ MASQUE =SIMP(statut='f',typ='TXM',max='**'),
+ ),
+ FREQ =SIMP(statut='f',typ='R',defaut= 1.),
+ INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+) ;
+#& MODIF COMMANDE DATE 10/06/2004 AUTEUR REZETTE C.REZETTE
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001 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.
+# ======================================================================
DEFI_INTE_SPEC=OPER(nom="DEFI_INTE_SPEC",op= 115,sd_prod=tabl_intsp,
reentrant='n',
UIinfo={"groupes":("Fonction",)},
# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
-DEFI_INTERF_DYNA=OPER(nom="DEFI_INTERF_DYNA",op= 98,sd_prod=interf_dyna_clas,
- reentrant='n',
- UIinfo={"groupes":("Matrices/vecteurs",)},
- NUME_DDL =SIMP(statut='o',typ=nume_ddl_sdaster ),
- INTERFACE =FACT(statut='o',max='**',
- regles=(ENSEMBLE('NOM','TYPE'),
-# erreur doc U sur la condition qui suit
- UN_PARMI('NOEUD','GROUP_NO'),),
- NOM =SIMP(statut='f',typ='TXM' ),
- TYPE =SIMP(statut='f',typ='TXM',into=("MNEAL","CRAIGB","CB_HARMO","AUCUN") ),
- NOEUD =SIMP(statut='f',typ=no,max='**'),
- GROUP_NO =SIMP(statut='f',typ=grno,max='**'),
- DDL_ACTIF =SIMP(statut='f',typ='TXM',max='**'),
- MASQUE =SIMP(statut='f',typ='TXM',max='**'),
- ),
- FREQ =SIMP(statut='f',typ='R',defaut= 1.),
- INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
-) ;
-#& MODIF COMMANDE DATE 10/06/2004 AUTEUR REZETTE C.REZETTE
-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2001 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 VABHHTS J.PELLET
DEFI_LIST_ENTI=OPER(nom="DEFI_LIST_ENTI",op=22,sd_prod=listis_sdaster,
fr="Définition d une suite croissante d entiers",
TITRE =SIMP(statut='f',typ='TXM',max='**'),
) ;
-#& MODIF COMMANDE DATE 03/11/2004 AUTEUR MCOURTOI M.COURTOIS
+#& MODIF COMMANDE DATE 05/12/2006 AUTEUR GNICOLAS G.NICOLAS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
#
# 2. Version de HOMARD
#
- VERSION_HOMARD = SIMP(statut='f',typ='TXM',defaut="V7_1",
- into=("V7_1", "V7_N", "V7_N_PERSO"),
+ VERSION_HOMARD = SIMP(statut='f',typ='TXM',defaut="V7_9",
+ into=("V7_9", "V7_N", "V7_N_PERSO"),
fr="Version de HOMARD",
ang="HOMARD release"),
#
INST =SIMP(statut='f',typ='R',defaut=0.E+0),
),
) ;
-#& MODIF COMMANDE DATE 07/10/2004 AUTEUR GNICOLAS G.NICOLAS
-# 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
-
-from Macro.macr_fiab_impr_ops import macr_fiab_impr_ops
-
-MACR_FIAB_IMPR=MACRO(nom="MACR_FIAB_IMPR",op=macr_fiab_impr_ops,
- docu="U7.04.41",
- fr="Imprimer les valeurs à transmettre au logiciel de fiabilité.",
- ang="Print values for the fiability software",
-#
-# 1. Le niveau d'information
-#
- INFO = SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
-#
-# 2. Impression de la valeur de la cible
-#
-# 2.1. ==> La table contenant la valeur à imprimer
-#
- TABLE_CIBLE = SIMP(statut='o',typ=table_sdaster,
- fr="Table contenant la valeur cible.",
- ang="Table which includes the target value."),
-#
-# 2.2. ==> Le nom du paramètre associé à la valeur cible dans cette table
-#
- NOM_PARA_CIBLE = SIMP(statut='o',typ='TXM',
- fr="Nom du paramètre associé à la valeur cible.",
- ang="Name of the parameter connected to the target value."),
-#
-# 3. Impressions des valeurs des éventuels gradients
-#
- GRADIENTS = FACT(statut='f',min=1,max='**',
-#
-# 3.1. ==> La table contenant la valeur à imprimer
-#
- TABLE = SIMP(statut='o',typ=table_sdaster,
- fr="Table contenant le gradient.",
- ang="Table which includes the gradient."),
-#
-# 3.2. ==> Le paramètre sensible
-#
- PARA_SENSI = SIMP(statut='o',typ=(para_sensi,theta_geom),
- fr="Paramètre sensible associé au gradient.",
- ang="Sensitivity parameter connected to the gradient."),
-#
-# 3.3. ==> Le nom du paramètre associé au gradient dans cette table
-#
- NOM_PARA = SIMP(statut='o',typ='TXM',
- fr="Nom du paramètre associé au gradient.",
- ang="Name of the parameter connected to the gradient."),
-#
- ),
-#
-);
#& MODIF COMMANDE DATE 14/09/2004 AUTEUR MCOURTOI M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
),
#
);
-#& MODIF COMMANDE DATE 03/11/2004 AUTEUR MCOURTOI M.COURTOIS
+#& MODIF COMMANDE DATE 07/10/2004 AUTEUR GNICOLAS G.NICOLAS
+# 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
+
+from Macro.macr_fiab_impr_ops import macr_fiab_impr_ops
+
+MACR_FIAB_IMPR=MACRO(nom="MACR_FIAB_IMPR",op=macr_fiab_impr_ops,
+ docu="U7.04.41",
+ fr="Imprimer les valeurs à transmettre au logiciel de fiabilité.",
+ ang="Print values for the fiability software",
+#
+# 1. Le niveau d'information
+#
+ INFO = SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+#
+# 2. Impression de la valeur de la cible
+#
+# 2.1. ==> La table contenant la valeur à imprimer
+#
+ TABLE_CIBLE = SIMP(statut='o',typ=table_sdaster,
+ fr="Table contenant la valeur cible.",
+ ang="Table which includes the target value."),
+#
+# 2.2. ==> Le nom du paramètre associé à la valeur cible dans cette table
+#
+ NOM_PARA_CIBLE = SIMP(statut='o',typ='TXM',
+ fr="Nom du paramètre associé à la valeur cible.",
+ ang="Name of the parameter connected to the target value."),
+#
+# 3. Impressions des valeurs des éventuels gradients
+#
+ GRADIENTS = FACT(statut='f',min=1,max='**',
+#
+# 3.1. ==> La table contenant la valeur à imprimer
+#
+ TABLE = SIMP(statut='o',typ=table_sdaster,
+ fr="Table contenant le gradient.",
+ ang="Table which includes the gradient."),
+#
+# 3.2. ==> Le paramètre sensible
+#
+ PARA_SENSI = SIMP(statut='o',typ=(para_sensi,theta_geom),
+ fr="Paramètre sensible associé au gradient.",
+ ang="Sensitivity parameter connected to the gradient."),
+#
+# 3.3. ==> Le nom du paramètre associé au gradient dans cette table
+#
+ NOM_PARA = SIMP(statut='o',typ='TXM',
+ fr="Nom du paramètre associé au gradient.",
+ ang="Name of the parameter connected to the gradient."),
+#
+ ),
+#
+);
+#& MODIF COMMANDE DATE 05/12/2006 AUTEUR GNICOLAS G.NICOLAS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
#
# 2. Version de HOMARD
#
- VERSION_HOMARD = SIMP(statut='f',typ='TXM',defaut="V7_1",
- into=("V7_1", "V7_N", "V7_N_PERSO"),
+ VERSION_HOMARD = SIMP(statut='f',typ='TXM',defaut="V7_9",
+ into=("V7_9", "V7_N", "V7_N_PERSO"),
fr="Version de HOMARD",
ang="HOMARD release"),
#
#& MODIF COMMANDE DATE 10/06/2004 AUTEUR REZETTE C.REZETTE
# 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.
-# ======================================================================
-
-from Macro.macr_recal_ops import macr_recal_ops
-
-def macr_recal_prod(self,**args ):
- return listr8_sdaster
-
-MACR_RECAL = MACRO(nom="MACR_RECAL",op=macr_recal_ops,
- UIinfo={"groupes":("Résultats et champs",)},
- sd_prod=macr_recal_prod,
- fr="Réalise le recalage de modèles Aster",
- UNITE_ESCL =SIMP(statut='o',typ='I'),
- RESU_EXP =SIMP(statut='o',typ=assd,max='**'),
- POIDS =SIMP(statut='f',typ=assd,max='**'),
- RESU_CALC =SIMP(statut='o',typ=assd,max='**'),
- LIST_PARA =SIMP(statut='o',typ=assd,max='**'),
- ITER_MAXI =SIMP(statut='f',typ='I',defaut=10),
- RESI_GLOB_RELA =SIMP(statut='f',typ='R',defaut=1.E-3),
- UNITE_RESU =SIMP(statut='f',typ='I',defaut=91),
- PARA_DIFF_FINI =SIMP(statut='f',typ='R',defaut=0.001),
- GRAPHIQUE =FACT(statut='d',
- UNITE =SIMP(statut='f',typ='I',defaut=90),
- INTERACTIF =SIMP(statut='f',typ='TXM',defaut='NON',into=("OUI","NON")),)
-) ;
-#& MODIF COMMANDE DATE 10/06/2004 AUTEUR REZETTE C.REZETTE
-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
# COPYRIGHT (C) 1991 - 2001 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
#& MODIF COMMANDE DATE 10/06/2004 AUTEUR REZETTE C.REZETTE
# 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.
+# ======================================================================
+
+from Macro.macr_recal_ops import macr_recal_ops
+
+def macr_recal_prod(self,**args ):
+ return listr8_sdaster
+
+MACR_RECAL = MACRO(nom="MACR_RECAL",op=macr_recal_ops,
+ UIinfo={"groupes":("Résultats et champs",)},
+ sd_prod=macr_recal_prod,
+ fr="Réalise le recalage de modèles Aster",
+ UNITE_ESCL =SIMP(statut='o',typ='I'),
+ RESU_EXP =SIMP(statut='o',typ=assd,max='**'),
+ POIDS =SIMP(statut='f',typ=assd,max='**'),
+ RESU_CALC =SIMP(statut='o',typ=assd,max='**'),
+ LIST_PARA =SIMP(statut='o',typ=assd,max='**'),
+ ITER_MAXI =SIMP(statut='f',typ='I',defaut=10),
+ RESI_GLOB_RELA =SIMP(statut='f',typ='R',defaut=1.E-3),
+ UNITE_RESU =SIMP(statut='f',typ='I',defaut=91),
+ PARA_DIFF_FINI =SIMP(statut='f',typ='R',defaut=0.001),
+ GRAPHIQUE =FACT(statut='d',
+ UNITE =SIMP(statut='f',typ='I',defaut=90),
+ INTERACTIF =SIMP(statut='f',typ='TXM',defaut='NON',into=("OUI","NON")),)
+) ;
+#& MODIF COMMANDE DATE 10/06/2004 AUTEUR REZETTE C.REZETTE
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
# COPYRIGHT (C) 1991 - 2001 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
-#@ MODIF ops Cata DATE 24/05/2005 AUTEUR DURAND C.DURAND
+#@ MODIF ops Cata DATE 04/10/2006 AUTEUR CIBHHPD L.SALMONA
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
for elem in pickle_context.keys():
if type(pickle_context[elem])==types.InstanceType :
pickle_class=pickle_context[elem].__class__
+ # on rattache chaque assd au nouveau jdc courant (en poursuite)
+ if isinstance(pickle_context[elem],ASSD) :
+ pickle_context[elem].jdc=self.jdc
+ pickle_context[elem].parent=self.jdc
if elem in self.g_context.keys():
poursu_class=self.g_context[elem].__class__
if poursu_class!=pickle_class :
-#@ MODIF calc_precont_ops Macro DATE 05/09/2005 AUTEUR DURAND C.DURAND
+#@ MODIF calc_precont_ops Macro DATE 10/10/2006 AUTEUR REZETTE C.REZETTE
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
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):
+ LAGR_NON_LOCAL,INFO,TITRE,**args):
"""
for i in dComp_incr[-1].keys():
if dComp_incr[-1][i]==None : del dComp_incr[-1][i]
+ PARM_THETA=0.
+ for j in range(len(COMP_INCR)) :
+ if dComp_incr[j]['RELATION'] == 'ELAS':
+ PARM_THETA=dComp_incr[j]['PARM_THETA']
+
+ if PARM_THETA == 0:
+ PARM_THETA=dComp_incr[0]['PARM_THETA']
+
dComp_incr0=copy.copy(dComp_incr)
dComp_incr1=copy.copy(dComp_incr)
- dComp_incr0.append(_F(RELATION='SANS',GROUP_MA=__GROUP_MA_CABLES) )
+ 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) )
+ dComp_incr1.append(_F(RELATION='SANS',GROUP_MA=__GROUP_MA_I,) )
# 1.5 Modele contenant uniquement les cables de precontrainte
_F(CHARGE = _C_CN),),
COMP_INCR =_F( RELATION = 'ELAS',
DEFORMATION = 'PETIT',
+ PARM_THETA = PARM_THETA,
TOUT = 'OUI'),
INCREMENT =_F(LIST_INST = __LST0,
PRECISION = __prec),
SOLVEUR = dSolveur,
- PARM_THETA = PARM_THETA,
INFO =INFO,
TITRE = TITRE, )
SOLV_NON_LOCAL = dSolv_nonloc,
LAGR_NON_LOCAL = dLagr_nonloc,
ARCHIVAGE = _F(INST = __TINT),
- PARM_THETA = PARM_THETA,
INFO =INFO,
TITRE = TITRE,
EXCIT = dExcit1,
LAGR_NON_LOCAL = dLagr_nonloc,
ARCHIVAGE = _F(NUME_INIT = __no,
DETR_NUME_SUIV = 'OUI' ),
- PARM_THETA = PARM_THETA,
INFO =INFO,
TITRE = TITRE,
EXCIT =dExcit2,
-#@ MODIF calc_table_ops Macro DATE 10/04/2006 AUTEUR MCOURTOI M.COURTOIS
+#@ MODIF calc_table_ops Macro DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
import aster
macro = 'CALC_TABLE'
- from Accas import _F
- from Cata.cata import table_jeveux
- from Utilitai.Utmess import UTMESS
- from Utilitai import transpose
- from Utilitai.Table import Table, merge
- from Utilitai.Sensibilite import NomCompose
+ from Accas import _F
+ from Cata.cata import table_sdaster, table_fonction, table_jeveux
+ from Utilitai.Utmess import UTMESS
+ from Utilitai import transpose
+ from Utilitai.Table import Table, merge
+ from Utilitai.Sensibilite import NomCompose
ier = 0
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
- # Le concept sortant (de type table_sdaster ou dérivé) est tab
+ # Le concept sortant (de type table_sdaster ou dérivé) est tabout
self.DeclareOut('tabout', self.sd)
+ if self.sd.__class__ == table_fonction:
+ typ_tabout = 'TABLE_FONCTION'
+ else:
+ typ_tabout = 'TABLE'
# On importe les definitions des commandes a utiliser dans la macro
# Le nom de la variable doit etre obligatoirement le nom de la commande
if occ['OPERATION'] == 'COMB':
tab2 = occ['TABLE'].EXTR_TABLE()
opts = [tab, tab2]
- if occ['NOM_PARA']<>None:
+ if occ.get('NOM_PARA') != None:
lpar = occ['NOM_PARA']
if not type(lpar) in EnumTypes:
lpar = [lpar]
tit = [tit]
dprod['TITRE'] = tuple(['%-80s' % lig for lig in tit])
# type de la table de sortie à passer à CREA_TABLE
- tabout = CREA_TABLE(**dprod)
+ tabout = CREA_TABLE(TYPE_TABLE=typ_tabout,
+ **dprod)
return ier
-#@ MODIF creation_donnees_homard Macro DATE 22/05/2006 AUTEUR MCOURTOI M.COURTOIS
+#@ MODIF creation_donnees_homard Macro DATE 30/10/2006 AUTEUR DURAND C.DURAND
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
# RESPONSABLE MCOURTOI M.COURTOIS
-__all__ = [ ]
"""
Cette classe crée le fichier de configuration permettant de lancer HOMARD depuis Code_Aster.
"""
-__revision__ = "V1.0"
+__revision__ = "V1.1"
+__all__ = [ ]
import os
import os.path
# print "\nArguments a l'entree de", __name__, ":", entier
#
try:
- la_chaine = '%02d' % entier
+ la_chaine = '%02d' % entier
except TypeError:
- la_chaine = None
+ la_chaine = None
#
return la_chaine
# ------------------------------------------------------------------------------
self.CCNoMNP1 = self.dico_configuration["NOM_MED_MAILLAGE_NP1"]
if self.dico_configuration.has_key("NOM_MED_MAILLAGE_NP1_ANNEXE") :
self.CCMaiAnn = self.dico_configuration["NOM_MED_MAILLAGE_NP1_ANNEXE"]
+ else :
+ self.CCMaiAnn = None
#
# 5. Les entrées/sorties au format HOMARD
#
s_aux_1 = "Zone numero "+str(iaux)+" : "
s_aux_2 = ", doit etre < au "
if zone.has_key("X_MINI") :
- if zone["X_MINI"] >= zone["X_MAXI"] :
+ if zone["X_MINI"] > zone["X_MAXI"] :
message_erreur = s_aux_1+"X mini ,"+str(zone["X_MINI"])+s_aux_2+"X maxi, "+str(zone["X_MAXI"])+"."
- if zone["Y_MINI"] >= zone["Y_MAXI"] :
+ if zone["Y_MINI"] > zone["Y_MAXI"] :
message_erreur = s_aux_1+"Y mini ,"+str(zone["Y_MINI"])+s_aux_2+"Y maxi, "+str(zone["Y_MAXI"])+"."
if zone.has_key("Z_MINI") :
- if zone["Z_MINI"] >= zone["Z_MAXI"] :
+ if zone["Z_MINI"] > zone["Z_MAXI"] :
message_erreur = s_aux_1+"Z mini ,"+str(zone["Z_MINI"])+s_aux_2+"Z maxi, "+str(zone["Z_MAXI"])+"."
#
break
self.ecrire_ligne_configuration_2("CCNoMNP1", self.CCNoMNP1)
self.ecrire_ligne_configuration_2("CCMaiNP1", self.dico_configuration["Fichier_HOMARD_vers_ASTER"])
#
- self.ecrire_ligne_configuration_0("Les fichiers de bilan")
- self.ecrire_ligne_configuration_2("PPBasFic", "info")
+ self.ecrire_ligne_configuration_0("Le répertoire des fichiers de bilan")
+ self.ecrire_ligne_configuration_2("RepeInfo", self.dico_configuration["Rep_Calc_HOMARD_global"])
#
# 4. Les fichiers HOMARD
#
if self.dico_configuration["Indicateur"].has_key("NUME_ORDRE") :
self.ecrire_ligne_configuration_2("CCNumOrI", self.dico_configuration["Indicateur"]["NUME_ORDRE"])
self.ecrire_ligne_configuration_2("CCNumPTI", self.dico_configuration["Indicateur"]["NUME_ORDRE"])
+ if self.mots_cles.has_key("TYPE_VALEUR_INDICA") :
+ self.ecrire_ligne_configuration_2("CCTyVaIn", self.mots_cles["TYPE_VALEUR_INDICA"])
+#
+# 5.3. Les éventuelles zones de raffinement
+#
+ if self.dico_configuration.has_key("Zones") :
+ iaux = 0
+ for zone in self.dico_configuration["Zones"] :
+ iaux = iaux + 1
+ self.ecrire_ligne_configuration_0("Zone de raffinement numéro "+str(iaux))
+ if zone.has_key("X_MINI") :
+ self.ecrire_ligne_configuration_3("ZoRaXmin", iaux, zone["X_MINI"])
+ self.ecrire_ligne_configuration_3("ZoRaXmax", iaux, zone["X_MAXI"])
+ self.ecrire_ligne_configuration_3("ZoRaYmin", iaux, zone["Y_MINI"])
+ self.ecrire_ligne_configuration_3("ZoRaYmax", iaux, zone["Y_MAXI"])
+ if zone.has_key("Z_MINI") :
+ self.ecrire_ligne_configuration_3("ZoRaZmin", iaux, zone["Z_MINI"])
+ self.ecrire_ligne_configuration_3("ZoRaZmax", iaux, zone["Z_MAXI"])
+ if zone.has_key("X_CENTRE") :
+ self.ecrire_ligne_configuration_3("ZoRaXCen", iaux, zone["X_CENTRE"])
+ self.ecrire_ligne_configuration_3("ZoRaYCen", iaux, zone["Y_CENTRE"])
+ self.ecrire_ligne_configuration_3("ZoRaRayo", iaux, zone["RAYON"])
+ if zone.has_key("Z_CENTRE") :
+ self.ecrire_ligne_configuration_3("ZoRaZCen", iaux, zone["Z_CENTRE"])
#
-# 5.3. Les niveaux extremes
+# 5.4. Les niveaux extremes
#
for aux in self.niveau :
self.ecrire_ligne_configuration_2(aux[0], aux[1])
#
-# 6. Les éventuelles zones de raffinement
-#
- if self.dico_configuration.has_key("Zones") :
- iaux = 0
- for zone in self.dico_configuration["Zones"] :
- iaux = iaux + 1
- self.ecrire_ligne_configuration_0("Zone de raffinement numéro "+str(iaux))
- if zone.has_key("X_MINI") :
- self.ecrire_ligne_configuration_3("ZoRaXmin", iaux, zone["X_MINI"])
- self.ecrire_ligne_configuration_3("ZoRaXmax", iaux, zone["X_MAXI"])
- self.ecrire_ligne_configuration_3("ZoRaYmin", iaux, zone["Y_MINI"])
- self.ecrire_ligne_configuration_3("ZoRaYmax", iaux, zone["Y_MAXI"])
- if zone.has_key("Z_MINI") :
- self.ecrire_ligne_configuration_3("ZoRaZmin", iaux, zone["Z_MINI"])
- self.ecrire_ligne_configuration_3("ZoRaZmax", iaux, zone["Z_MAXI"])
- if zone.has_key("X_CENTRE") :
- self.ecrire_ligne_configuration_3("ZoRaXCen", iaux, zone["X_CENTRE"])
- self.ecrire_ligne_configuration_3("ZoRaYCen", iaux, zone["Y_CENTRE"])
- self.ecrire_ligne_configuration_3("ZoRaRayo", iaux, zone["RAYON"])
- if zone.has_key("Z_CENTRE") :
- self.ecrire_ligne_configuration_3("ZoRaZCen", iaux, zone["Z_CENTRE"])
-#
-# 7. Les éventuels champs à mettre à jour
+# 6. Les éventuels champs à mettre à jour
#
if self.dico_configuration.has_key("Champs") :
self.ecrire_ligne_configuration_0("Champs à mettre à jour")
elif maj_champ.has_key("INST") :
self.ecrire_ligne_configuration_3("CCChaIns", iaux, maj_champ["INST"])
#
-# 8. L'éventuel maillage de frontière
+# 7. L'éventuel maillage de frontière
#
if self.dico_configuration.has_key("NOM_MED_MAILLAGE_FRONTIERE") :
self.ecrire_ligne_configuration_0("Maillage de frontière")
for group_ma in self.mots_cles["GROUP_MA"] :
self.ecrire_ligne_configuration_2("CCGroFro", group_ma)
#
-# 9. L'usage des éléments incompatibles avec HOMARD
+# 8. L'éventuel maillage annexe
#
- if self.elements_incompatibles is not None :
- self.ecrire_ligne_configuration_0("Les éléments incompatibles avec HOMARD")
- self.ecrire_ligne_configuration_2("TypeElem", self.elements_incompatibles)
+ if self.mode_homard == "ADAP" :
+ if self.CCMaiAnn is not None :
+ self.ecrire_ligne_configuration_0("Maillage d'autre degré")
+ self.ecrire_ligne_configuration_2("ModDegre", "oui")
+ self.ecrire_ligne_configuration_2("CCNoMAnn", self.CCMaiAnn)
+ self.ecrire_ligne_configuration_2("CCMaiAnn", self.dico_configuration["Fichier_HOMARD_vers_ASTER"])
#
-# 10. Options particulières
+# 9. Options particulières
#
self.ecrire_ligne_configuration_0("Autres options")
if self.mots_cles.has_key("LANGUE") :
VERSION_HOMARD = self.dico_configuration["VERSION_HOMARD"]
self.ecrire_ligne_configuration_2("DicoOSGM", "$HOMARD_USER/"+VERSION_HOMARD+"/CONFIG/typobj.stu")
#
+# 10. L'usage des éléments incompatibles avec HOMARD
+#
+ if self.elements_incompatibles is not None :
+ self.ecrire_ligne_configuration_0("Les éléments incompatibles avec HOMARD")
+ self.ecrire_ligne_configuration_2("TypeElem", self.elements_incompatibles)
+#
# 11. Fermeture du fichier
#
fichier.close()
-#@ MODIF defi_cable_bp_ops Macro DATE 05/09/2005 AUTEUR DURAND C.DURAND
+#@ MODIF defi_cable_bp_ops Macro DATE 14/11/2006 AUTEUR ASSIRE A.ASSIRE
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
Ecriture de la macro DEFI_CABLE_BP
"""
from Accas import _F
- import aster,string
+ import aster,string, types
from Utilitai.Utmess import UTMESS
ier=0
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 type(GROUP_MA_BETON) in [types.TupleType, types.ListType]: gma = list(GROUP_MA_BETON)
+ else: gma = [ GROUP_MA_BETON ]
+ gma.insert(0, __CAB)
+
+ motscle2= {'CREA_GROUP_NO': [{'LONGUEUR': LONGUEUR, 'RAYON': RAYON, 'OPTION': 'TUNNEL', 'GROUP_MA': gma, 'GROUP_MA_AXE': __CAB, 'NOM': __NOM1}]}
if i.has_key('MAILLE') == 1:
echo_mess=[]
echo_mess.append( ' \n' )
__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) )
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 type(GROUP_MA_BETON) in [types.TupleType, types.ListType]: gma = list(GROUP_MA_BETON)
+ else: gma = [ GROUP_MA_BETON ]
+ gma.insert(0, __CAB)
+
+ motscle2= {'CREA_GROUP_NO': [{'LONGUEUR': LONGUEUR, 'RAYON': RAYON, 'OPTION': 'TUNNEL', 'GROUP_MA': gma, 'GROUP_MA_AXE': __CAB, 'NOM': __NOM2}]}
if i.has_key('MAILLE') == 1:
echo_mess=[]
echo_mess.append( ' \n' )
--- /dev/null
+#@ MODIF defi_inte_spec_ops Macro DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS
+# -*- coding: iso-8859-1 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2006 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 defi_inte_spec_ops(self,DIMENSION,PAR_FONCTION,KANAI_TAJIMI,
+ CONSTANT,TITRE,INFO,**args):
+# ------------------------------------------------------------------
+# Définition d'une matrice interspectrale
+# à partir de fonctions complexes
+
+ import aster
+ from types import ListType, TupleType
+ EnumTypes = (ListType, TupleType)
+ from Accas import _F
+ from Utilitai.Utmess import UTMESS
+ import Numeric
+
+ commande='DEFI_INTE_SPEC'
+
+ ier = 0
+ # La macro compte pour 1 dans la numerotation des commandes
+ self.set_icmd(1)
+
+ # Le concept sortant (de type table_sdaster ou dérivé) est tab
+ self.DeclareOut('tabout', self.sd)
+
+ # On importe les definitions des commandes a utiliser dans la macro
+ # Le nom de la variable doit etre obligatoirement le nom de la commande
+ CREA_TABLE = self.get_cmd('CREA_TABLE')
+ CALC_TABLE = self.get_cmd('CALC_TABLE')
+ DEFI_FONCTION = self.get_cmd('DEFI_FONCTION')
+
+#--- Vérifications
+
+ if PAR_FONCTION==None : PAR_FONCTION=[]
+ if KANAI_TAJIMI==None : KANAI_TAJIMI=[]
+ if CONSTANT ==None : CONSTANT =[]
+
+ nfntot = len(PAR_FONCTION)+len(KANAI_TAJIMI)+len(CONSTANT)
+ dimh = (DIMENSION*(DIMENSION+1))/2
+ if dimh!=nfntot :
+ txt = "nombre de fonctions erroné pour une matrice hermitienne"
+ UTMESS('F',commande, txt)
+
+ l_f=[]
+ for occ in PAR_FONCTION : l_f.append(('PAR_FONCTION',occ))
+ for occ in KANAI_TAJIMI : l_f.append(('KANAI_TAJIMI',occ))
+ for occ in CONSTANT : l_f.append(('CONSTANT' ,occ))
+ for occ in l_f :
+ if occ[0]!='PAR_FONCTION' and occ[1]['FREQ_MAX']<occ[1]['FREQ_MIN'] :
+ txt = occ[0]+" : FREQ_MAX < FREQ_MIN"
+ UTMESS('F',commande, txt)
+ l_is=[occ[1]['NUME_ORDRE_I'] for occ in l_f]
+ l_js=[occ[1]['NUME_ORDRE_J'] for occ in l_f]
+ iis=sum(l_is)
+ ijs=sum(l_js)
+
+#--- pour une matrice hermitienne ---
+ l_ih=[k*(DIMENSION-k+1) for k in range(1,DIMENSION+1)]
+ l_jh=[k*k for k in range(1,DIMENSION+1)]
+ ih=sum(l_ih)
+ jh=sum(l_jh)
+ if ((iis!=ih) or (ijs!=jh)) :
+ txt = "erreur sur les indices"
+ UTMESS('F',commande, txt)
+
+#--- Construction de la liste de fonctions complexes
+ l_fc=[]
+ for occ in l_f :
+
+#--- PAR_FONCTION
+
+ if occ[0]=='PAR_FONCTION' :
+ l_fc.append(occ[1]['FONCTION'].nom)
+
+#--- KANAI_TAJIMI et CONSTANT
+
+ if occ[0] in ('KANAI_TAJIMI','CONSTANT') :
+ if occ[1]['VALE_R']!=None :
+ valr=occ[1]['VALE_R']
+ vali=0.
+ elif occ[1]['VALE_C']!=None :
+ cmpl=tocomplex(occ[1]['VALE_C'])
+ valr=cmpl.real
+ vali=cmpl.imag
+ else :
+ valr=1.
+ vali=0.
+ x1=Numeric.arange(occ[1]['FREQ_MIN'],occ[1]['FREQ_MAX'],occ[1]['PAS'])
+ x1=x1.tolist()+[occ[1]['FREQ_MAX'],]
+ valc=[]
+ for absc in x1 : valc=valc+[absc,valr,vali]
+
+#--- KANAI_TAJIMI
+
+ if occ[0]=='KANAI_TAJIMI' :
+ amor = occ[1]['AMOR_REDUIT']
+ frqmoy = occ[1]['FREQ_MOY']
+ x11 =Numeric.array([4*(amor**2)*(frqmoy**2)*FREQ**2 \
+ for FREQ in x1 ])
+ xnum =x11+frqmoy**4
+ denom=Numeric.array([ (frqmoy**2-FREQ**2)**2 \
+ for FREQ in x1 ])
+ denom=denom+x11
+ g0=Numeric.array([valr]*len(denom))
+ g0=g0*xnum/denom
+ valc=[]
+ for i in range(len(x1)): valc=valc+[x1[i],g0[i],0.]
+ if occ[0] in ('KANAI_TAJIMI','CONSTANT') :
+ _f=DEFI_FONCTION(PROL_GAUCHE=occ[1]['PROL_GAUCHE'],
+ PROL_DROITE=occ[1]['PROL_DROITE'],
+ INTERPOL =occ[1]['INTERPOL'],
+ VALE_C =valc,
+ NOM_PARA ='FREQ',
+ NOM_RESU ='DSP' )
+ l_fc.append(_f.nom)
+
+ mcfact=[]
+ mcfact.append(_F(PARA='NOM_CHAM' ,LISTE_K='DSP' ))
+ mcfact.append(_F(PARA='OPTION' ,LISTE_K='TOUT' ))
+ mcfact.append(_F(PARA='DIMENSION' ,LISTE_I=(DIMENSION,) ))
+ tabout=CREA_TABLE(LISTE=mcfact, TITRE='',
+ TYPE_TABLE='TABLE_FONCTION')
+ mcfact=[]
+ mcfact.append(_F(PARA='NUME_ORDRE_I' ,LISTE_I=l_is ))
+ mcfact.append(_F(PARA='NUME_ORDRE_J' ,LISTE_I=l_js ))
+ mcfact.append(_F(PARA='FONCTION_C' ,LISTE_K=l_fc ,TYPE_K='K24' ))
+ __l_fonc=CREA_TABLE(LISTE=mcfact, TITRE='')
+ tabout=CALC_TABLE(reuse=tabout,TABLE=tabout,
+ TITRE=self.sd.nom+' : interspectre obtenu par DEFI_INTE_SPEC',
+ ACTION=_F(OPERATION='COMB',TABLE=__l_fonc,))
+
+ return ier
--- /dev/null
+#@ MODIF exec_logiciel_ops Macro DATE 29/08/2006 AUTEUR MCOURTOI M.COURTOIS
+# -*- coding: iso-8859-1 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2006 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 os.path
+import traceback
+import shutil
+from types import ListType, TupleType
+EnumTypes = (ListType, TupleType)
+
+# ------------------------------------------------------------------------------
+def exec_logiciel_ops(self, LOGICIEL, ARGUMENT, MAILLAGE, CODE_RETOUR_MAXI, 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='EXEC_LOGICIEL'
+ import aster
+ from Utilitai.Utmess import UTMESS
+ from Utilitai.System import ExecCommand
+ from Utilitai.UniteAster import UniteAster
+
+ PRE_GMSH = self.get_cmd("PRE_GMSH")
+ PRE_GIBI = self.get_cmd("PRE_GIBI")
+ LIRE_MAILLAGE = self.get_cmd("LIRE_MAILLAGE")
+
+ ier=0
+ # La macro compte pour 1 dans la numerotation des commandes
+ self.set_icmd(1)
+
+ #----------------------------------------------
+ # constantes des modes d'exécution
+ CMD_EXTERNE = 1
+ EXECFILE = 2
+ mode_lancement = None
+
+ # paramètres nécessaires pour écrire la ligne de commande
+ # !! d_para['options'] est une liste !!
+ d_para = {'prog' : '', 'options' : ''}
+
+ l_args = []
+ if ARGUMENT != None:
+ l_args = ARGUMENT[:]
+ if type(l_args) not in EnumTypes:
+ l_args = [l_args,]
+
+ #----------------------------------------------
+ # 1. Préparation des données
+ # 1.1. EXEC_LOGICIEL standard
+ if MAILLAGE == None:
+ mode_lancement = CMD_EXTERNE
+ cmd = '%(prog)s %(options)s'
+
+ # 1.2. Cas "lancement d'un mailleur"
+ else:
+ mcf = MAILLAGE[0]
+ dMCF = mcf.cree_dict_valeurs(mcf.mc_liste)
+ d_para['fichIN'] = 'fort.%d' % dMCF['UNITE_GEOM']
+ d_para['fichOUT'] = 'fort.%d' % dMCF['UNITE']
+
+ if dMCF['FORMAT'] == 'GMSH':
+ mode_lancement = CMD_EXTERNE
+ cmd = '%(prog)s %(options)s -o %(fichOUT)s %(fichIN)s'
+ d_para['prog'] = os.path.join(aster.repout(), 'gmsh')
+ d_para['options'] = ('-3',)
+
+ elif dMCF['FORMAT'] == 'GIBI':
+ mode_lancement = CMD_EXTERNE
+ cmd = '%(prog)s %(options)s %(fichIN)s %(fichOUT)s'
+ d_para['prog'] = os.path.join(aster.repout(), 'gibi')
+
+ elif dMCF['FORMAT'] == 'SALOME':
+ mode_lancement = EXECFILE
+ if len(l_args) < 1:
+ UTMESS('F', macro, "FORMAT SALOME, L'ARGUMENT 1 DOIT ETRE " \
+ "LE NOM DU FICHIER MED PRODUIT PAR LE SCRIPT PYTHON.")
+ else:
+ d_para['fichMED'] = l_args[0]
+
+ else:
+ UTMESS('F', macro, "ON NE SAIT PAS TRAITER LE FORMAT '%s'" % dMCF['FORMAT'])
+
+ #----------------------------------------------
+ # 2. lecture des mots-clés
+ if LOGICIEL != None:
+ d_para['prog'] = LOGICIEL
+
+ if len(l_args) > 0:
+ d_para['options'] = l_args
+ d_para['options'] = ' '.join(d_para['options'])
+
+ #----------------------------------------------
+ # 3. Exécution
+ # 3a. Lancement d'une commande externe
+ if mode_lancement == CMD_EXTERNE:
+ scmd = cmd % d_para
+ comment = "Lancement de la commande :\n%s" % scmd
+ iret, output = ExecCommand(scmd,
+ alt_comment=comment)
+ # écrire l'output dans le .mess si demandé
+ if INFO == 2:
+ aster.affiche('MESSAGE', output)
+
+ if CODE_RETOUR_MAXI >= 0 and iret > CODE_RETOUR_MAXI:
+ UTMESS('F', macro, 'CODE RETOUR INCORRECT (MAXI %d) : %d' \
+ % (CODE_RETOUR_MAXI, iret))
+
+ #----------------------------------------------
+ # 3b. Exécution d'un fichier Python
+ elif mode_lancement == EXECFILE:
+ if d_para['prog'] != '':
+ UTMESS('A', macro, "LE MOT-CLE LOGICIEL N'EST PAS UTILISE AVEC CE FORMAT")
+ context={}
+ try:
+ execfile(d_para['fichIN'], context)
+ except:
+ traceback.print_exc()
+ txt = open(d_para['fichIN'], 'r').read()
+ UTMESS('F', macro, """ERREURS LORS DE L'EXECUTION DU FICHIER CI-DESSOUS :
+<<<<<<<<<<<<<<< DEBUT DU FICHIER >>>>>>>>>>>>>>>
+%s
+<<<<<<<<<<<<<<< FIN DU FICHIER >>>>>>>>>>>>>>>
+""" % txt)
+
+ if not os.path.exists(d_para['fichMED']):
+ UTMESS('F', macro, "LE FICHIER %s N'EXISTE PAS" % d_para['fichMED'])
+ else:
+ # copie fichMED vers fichOUT pour pouvoir le récupérer
+ shutil.copyfile(d_para['fichMED'], d_para['fichOUT'])
+
+ else:
+ UTMESS('F', macro, "Mode de lancement inconnu : %s" % mode_lancement)
+
+ #----------------------------------------------
+ # 4. Conversion du maillage
+ if MAILLAGE != None:
+ UL = UniteAster()
+ umail = UL.Libre(action='ASSOCIER',
+ nom='exec_logiciel.%s2mail' % dMCF['FORMAT'].lower())
+
+ # déclaration du concept maillage en sortie
+ self.DeclareOut('mail', dMCF['MAILLAGE'])
+
+ lire_mail_opts = {}
+ if dMCF['FORMAT'] == 'GMSH':
+ PRE_GMSH(UNITE_GMSH = dMCF['UNITE'],
+ UNITE_MAILLAGE = umail)
+
+ elif dMCF['FORMAT'] == 'GIBI':
+ PRE_GIBI(UNITE_GIBI = dMCF['UNITE'],
+ UNITE_MAILLAGE = umail)
+
+ elif dMCF['FORMAT'] == 'SALOME':
+ # ici l'unité en entrée de LIRE_MAILLAGE ne correspond pas au .mail
+ # mais au fichier MED en sortie du execfile.
+ umail = dMCF['UNITE']
+ etat = UL.Etat(umail, etat='O', TYPE='LIBRE', nom=d_para['fichMED'])
+ lire_mail_opts['FORMAT'] = 'MED'
+ lire_mail_opts['INFO_MED'] = INFO
+
+ mail = LIRE_MAILLAGE(UNITE = umail,
+ INFO = INFO,
+ **lire_mail_opts)
+
+ UL.EtatInit()
+ return ier
+
--- /dev/null
+#@ MODIF impr_oar_ops Macro DATE 07/11/2006 AUTEUR DURAND C.DURAND
+# -*- coding: iso-8859-1 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2006 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 aster
+from Utilitai.Utmess import UTMESS
+from Utilitai.Table import Table
+from Utilitai.partition import MAIL_PY
+
+def buildTabString(tabLevel):
+ """
+ Construit une chaine de tabulation
+ """
+ chaine = ''
+ for i in range(0, tabLevel) :
+ chaine += '\t'
+
+ return chaine
+
+def getBornes(listIn, valTest) :
+ """
+ Retourne un doublet de valeurs qui correspond aux valeurs de la liste qui encadrent la valeur (valTest)
+ Si val n'est pas encadrée par des valeurs de la liste, une des valeurs du doublet est None
+ """
+ v1 = None
+ v2 = None
+ for val in listIn :
+ if valTest > val : v1 = val
+ if valTest < val : v2 = val
+
+ # traitement des cas limites
+ if valTest == listIn[0] : v1 = listIn[0]
+ if valTest == listIn[len(listIn)-1] : v2 = listIn[len(listIn)-1]
+
+ return (v1, v2)
+
+def interpoleLin(listDoublet, X) :
+ """
+ Interpole linéairement entre deux bornes définies par listDoublets[(X0, Y0), (X1, Y1)] la valeur Y en X
+ """
+ X0 = listDoublet[0][0]
+ Y0 = listDoublet[0][1]
+ X1 = listDoublet[1][0]
+ Y1 = listDoublet[1][1]
+
+ return Y0 + (X - X0) * (Y1 - Y0) / (X1 - X0)
+
+class interpolationError(Exception) :
+ def __init__(self) :
+ self.mess = 'Interpolation sur une valeur hors bornes'
+ self.otherExcept = Exception()
+
+ def getMess(self) :
+ """
+ retourne le message associé à l'erreur
+ """
+ # Analyse les différents cas d'erreurs
+ if self.otherExcept == IOError :
+ self.mess += "\nProblème à l'ouverture du fichier\n"
+
+ return self.mess
+
+class XMLNode :
+ """
+ Classe gérant un noeud de l'arborescence XML
+ Un noeud possède :
+ - un nom de balise
+ - un commentaire (optionnel)
+ - un ensemble de "paramètres" (optionnels)
+ - une liste d'élément ou d'autres noeuds (optionnels/possibilité de balises vides) :
+
+ La classe propose :
+ - une méthode "buildTree" qui parcoure le liste de manière récursive pour
+ produire l'arborescence XML en vu de son enregistrement ou son impression
+ - (TO DO) une methode statique "loadTree" qui produit un arbre XML à partir d'un fichier
+ """
+ def __init__(self, nomBalise, valeur = None, commentaire = None, **listOpt) :
+ self.nomBalise = nomBalise
+ self.commentaire = commentaire
+ self.param = listOpt
+ self.arbre=list()
+ if valeur != None : self.addValue(valeur) # None n'est pas 0 !
+
+ def getCommentaire(self) : return self.commentaire
+
+ def setCommentaire(sel, commentaire) : self.commentaire = commentaire
+
+ def getParametres(self) : return self.param
+
+ def setParametres(self, parametres) : self.param = parametres
+
+ def append(self, nodeName, valeur=None, commentaire = None, **listOpt) :
+ """
+ Ajoute un noeud à l'arborescence et retourne une référence sur ce noeud
+ On peut ajouter directement la valeur, si simple, associée à la balise
+ """
+ node = XMLNode(nodeName, valeur, commentaire)
+
+ self.arbre.append(node)
+
+ return self.arbre[len(self.arbre)-1]
+
+ def addValue(self, valeur):
+ """
+ Ajoute un élément "simple" (nombre, texte) à l'arborescence
+ """
+ self.arbre.append(valeur)
+
+ def buildTree(self, tabLevel=0) :
+ """
+ Construit l'arborescence XML en parcourant récursivement la structure de donnée
+ et la retourne sous la forme d'une chaine de caractères
+
+ tabLevel permet de gérer l'indentation
+ """
+ # Construction de la chaine de tabulations nécessaire à une bonne lecture du fichier XML
+ tabString = buildTabString(tabLevel)
+
+ XMLString = ''
+
+ try :
+ # listOpt contient les paramètres optionnels de la balise
+ chaine = ''
+ for v in self.param.keys() :
+ chaine = chaine + ' ' + v + '=' + self.param[v]
+ except : pass
+
+ baliseOuverture=tabString + "<" + self.nomBalise + chaine +">\n"
+ XMLString += baliseOuverture
+
+ if self.commentaire :
+ XMLString = XMLString + tabString + "\t<!--"+self.commentaire+"-->\n"
+
+ for elem in self.arbre :
+ try :
+ XMLString += elem.buildTree(tabLevel+1)
+ except : # l'élément n'est pas un noeud
+ XMLString = XMLString + tabString + '\t' + str(elem) + '\n'
+
+ XMLString = XMLString + tabString + "</"+self.nomBalise+">\n"
+
+ return XMLString
+
+ def save(self, fileObj) :
+ """
+ Construit le l'arborescence XML et l'écrit dans un fichier
+ pointé par le handler passé en paramètres
+ """
+ try :
+ fileObj.write(self.buildTree())
+ except : pass
+
+class OAR_element :
+ """
+ Classe de base des éléments manipulés par IMPR_OAR
+ """
+ def __init__(self) :
+ self.nodeComp = None
+
+ def buildTree(self) : pass
+
+ def getNode(self) :
+ """
+ Renvoie le noeud XML construit par buildTree
+ """
+ return self.nodeComp
+
+
+class composant(OAR_element) :
+ """
+ Classe permettant de traiter les composants
+
+ NB :
+ 1. L utilisateur est suppose faire la meme coupe pour le calcul mecanique et le calcul thermo-mecanique
+ 2. Dans le cas d'un revetement, l'utilisateur est supposé définir son plan de coupe de telle sorte
+ que la coupe de la structure et la coupe du revetement se raccordent
+ """
+ def __init__(self, **args) :
+ self.nodeComp = XMLNode("COMPOSANT") # Racine de l'arborescence composant
+
+ self.diametre = args['DIAMETRE']
+ self.origine = args['ORIGINE']
+ self.coef_u = args['COEF_U']
+ self.angle_c = args['ANGLE_C']
+ self.revet = args['REVET']
+
+ self.lastAbscisse = None # Permet de gerer le recouvrement des points de coupe entre revetement et structure
+ self.num_char = -1
+ self.type_char = ''
+ self.tabAbscisses = list()
+ self.tabAbscisses_S = None
+ self.dictMeca = dict()
+ self.dictMeca_S = None # Pas créé car optionnel
+ self.epaisseur = 0.0
+ self.epaisseur_R = 0.0
+
+ # dictionnaire gérant le résultat contraintes en fonction des instants et des abscisses
+ self.dictInstAbscSig = dict()
+ self.dictInstAbscSig_S = None # Création si nécessaire
+ # dictionnaire gérant le résultat température en fonction des instants et des abscisses
+ self.dictInstAbscTemp = dict()
+ self.dictInstAbscTemp_S = None # facultatif
+ self.list_inst = None
+ self.num_tran = None
+
+ self.noResuMeca = False
+ self.noResuTher = False
+
+ # 1. resultat mecanique
+ try :
+ # On ne construit qu'une table des abscisses et une table des contraintes.
+ # Le revetement est obligatoirement en interne on commence par lui
+ para_resu_meca = args['RESU_MECA']
+ self.num_char = para_resu_meca['NUM_CHAR']
+ self.type_char = para_resu_meca['TYPE']
+
+ if self.revet == 'OUI' :
+ # Construction de la table complementaire si revetement
+ self.dictMeca_S = dict()
+ self.tabAbscisses_S = list()
+ self.buildTablesMeca('TABLE_S', para_resu_meca, self.tabAbscisses_S, self.dictMeca_S)
+ self.epaisseur_R = abs(self.tabAbscisses_S[len(self.tabAbscisses_S)-1] - self.tabAbscisses_S[0])
+
+ self.buildTablesMeca('TABLE', para_resu_meca, self.tabAbscisses, self.dictMeca, offset=self.epaisseur_R)
+
+ if self.revet == 'OUI' :
+ self.mergeDictMeca() # merge les tableaux resultats du revetement et de la structure
+
+ # Calcul de l'épaisseur de la coupe.
+ self.epaisseur = abs(self.tabAbscisses[len(self.tabAbscisses)-1] - self.tabAbscisses[0])
+
+ except :
+ self.noResuMeca = True
+
+ # 2. Résultat thermique
+ try :
+ para_resu_ther = RESU_THER
+ self.num_tran = para_resu_ther['NUM_TRAN']
+ self.tabAbscisses = list()
+ self.tabAbscisses_S = None
+
+ listInst = list()
+ if self.revet == 'OUI' :
+ # Le revetement est obligatoirement en interne on commence par lui
+ # 1. Construction champ temperature
+ self.dictInstAbscTemp_S = dict()
+ self.buildTemp('TABLE_ST', para_resu_ther, self.dictInstAbscTemp_S)
+
+ # 2. Construction de la "table" des contraintes
+ self.dictInstAbscSig_S = dict()
+ self.tabAbscisses_S = list()
+ self.buildTablesTher('TABLE_S', para_resu_ther, self.tabAbscisses_S, self.dictInstAbscSig_S)
+
+ # 3. calcul de l'épaisseur
+ self.epaisseur_R = abs(self.tabAbscisses_S[len(self.tabAbscisses_S)-1] - self.tabAbscisses_S[0])
+
+ # Pour la structure
+ # 1. Construction champ température
+ self.buildTemp('TABLE_TEMP', para_resu_ther, self.dictInstAbscTemp, self.epaisseur_R)
+
+ # 2. Construction de la table des contraintes
+ self.buildTablesTher('TABLE_T', para_resu_ther, self.tabAbscisses, self.dictInstAbscSig, offset=self.epaisseur_R)
+
+ if self.revet == 'OUI' :
+ self.mergeDictTher() # merge les tableaux resultats du revetement et de la structure
+
+ if not(self.compareListAbscTher()) :
+ UTMESS('F', 'IMPR_OAR', 'LES COUPES MECANIQUES ET THERMIQUE DOIVENT PARTAGER LES MEMES ABSCISSES')
+
+ try :
+ self.interpoleInstants() # Interpolation des instants de la table des température sur celle de la table mécanique
+ except interpolationError, err:
+ UTMESS('F', 'IMPR_OAR', err.getMess())
+
+ # 3. Calcul de l'épaisseur de la coupe.
+ self.epaisseur = abs(self.tabAbscisses[len(self.tabAbscisses)-1] - self.tabAbscisses[0])
+
+ except :
+ self.noResuTher = True
+
+ # Construction de l arborescence
+ self.buildTree()
+
+
+ def getAbscisses(self, dicoTable, tableAbsc, offset=0.0) :
+ """
+ Récupère la liste des abscisses
+ """
+ # récupération des abscisses
+ ABSCISSES = dicoTable['ABSC_CURV']
+
+ valeurAbsc = 0.0
+ for val in ABSCISSES :
+ valeurAbsc = val + offset
+ tableAbsc.append(valeurAbsc)
+
+ def buildTablesMeca(self, label, para_resu, tableAbsc, dictMeca, offset=0.0) :
+ """
+ Construction des tableaux mécanique
+ """
+ sigma_xml = ( 'S_RR', 'S_TT', 'S_ZZ', 'S_RT', 'S_TZ', 'S_ZR' )
+
+ table_meca = para_resu[label].EXTR_TABLE()
+
+ # Utilisation des méthodes de la classe table
+ dictTable = table_meca.values()
+
+ # récupération des abscisses
+ self.getAbscisses(dictTable, tableAbsc, offset)
+
+ # Construction de la table mécanique principale
+ for val in sigma_xml :
+ dictMeca[val] = list()
+
+ S_XX = dictTable['SIXX']
+ S_YY = dictTable['SIYY']
+ S_ZZ = dictTable['SIZZ']
+ S_XY = dictTable['SIXY']
+ S_YZ = dictTable['SIYZ']
+ S_XZ = dictTable['SIXZ']
+ for v1, v2, v3, v4, v5, v6 in zip(S_XX, S_YY, S_ZZ, S_XY, S_YZ, S_XZ) :
+ dictMeca['S_RR'].append(v1)
+ dictMeca['S_TT'].append(v2)
+ dictMeca['S_ZZ'].append(v3)
+ dictMeca['S_RT'].append(v4)
+ dictMeca['S_TZ'].append(v5)
+ dictMeca['S_ZR'].append(v6)
+
+ def mergeDictMeca(self) :
+ """
+ Merge des résultats mécaniques issus de la structure et du revetement
+ """
+ # Merge des listes d'abscisses
+ # Le revetement est interieur la derniere abscisse du revetement doit etre egal a la premiere de la structure
+ if self.tabAbscisses_S[len(self.tabAbscisses_S)-1] != self.tabAbscisses[0] :
+ UTMESS('F', 'IMPR_OAR', 'LES COUPES DU REVETEMENT ET DE LA STRUCTURE DOIVENT PARTAGER UNE ABSCISSE COMMUNE')
+
+ # On construit une table des abscisses tempopraire
+ tableAbscTemp = self.tabAbscisses_S
+
+ # On recopie la table des abscisses en sautant le premier
+ debut = True
+ for val in self.tabAbscisses :
+ if debut :
+ debut = False
+ continue
+ tableAbscTemp.append(val)
+
+ self.tabAbscisses = tableAbscTemp
+
+ # On construit des listes de travail intermédiaires que l'on commence par remplir avec les tables "supplémentaires"
+ dictMecaBis = self.dictMeca_S
+
+ # On recopie les éléments de la structure dans le tableau
+ debut = True
+ for v1, v2, v3, v4, v5, v6 in zip(self.dictMeca['S_RR'], self.dictMeca['S_TT'], self.dictMeca['S_ZZ'], self.dictMeca['S_RT'], self.dictMeca['S_TZ'], self.dictMeca['S_ZR']) :
+ if debut :
+ debut = False
+ continue
+ dictMecaBis['S_RR'].append(v1)
+ dictMecaBis['S_TT'].append(v2)
+ dictMecaBis['S_ZZ'].append(v3)
+ dictMecaBis['S_RT'].append(v4)
+ dictMecaBis['S_TZ'].append(v5)
+ dictMecaBis['S_ZR'].append(v6)
+
+ # On restitue ensuite la liste globale dans self.dictMeca
+ self.dictMeca = dictMecaBis
+
+
+ def buildTemp(self, label, para_resu, dictInstAbscTemp, offset=0.0):
+ """
+ Récupération du champ température aux noeuds avec interpolation sur les "instants" du calcul mécanique
+ """
+ table_temp = para_resu[label].EXTR_TABLE()
+
+ # Utilisation des méthodes de la classe table
+ dictTable = table_temp.values()
+
+ # On construit un dictionnaire associant un "instant" avec un couple ("abscisse", "température")
+
+ # 1. Récupération de la liste des instants
+ INSTANTS = dictTable['INST']
+ for val in INSTANTS :
+ dictInstAbscTemp[val] = 0 # On crée juste les clés du dictionnaire
+
+ listTables = list() # liste de tables contenant une table pas instant
+ for inst in dictInstAbscTemp.keys():
+ listTables.append(table_temp.INST == inst)
+
+ # 2. Récupération des abscisses
+ tableAbsc = list()
+ self.getAbscisses(listTables[0].values(), tableAbsc, offset)
+
+ # 3. Récupération des températures
+ tableTemp = list() # liste de liste de température (1 par instant)
+ for tb in listTables :
+ TEMPERATURE = tb.values()['TEMP']
+ tableTemp.append(TEMPERATURE)
+
+ # 4. Construction de dictInstAbscTemp
+ for i in range(0, len(dictInstAbscTemp.keys())):
+ listDoublets = list()
+ for absc, temp in zip(tableAbsc, tableTemp[i]) :
+ listDoublets.append((absc,temp))
+
+ inst = dictInstAbscTemp.keys()[i]
+ dictInstAbscTemp[inst] = listDoublets
+
+ def buildTablesTher(self, label, para_resu, tabAbscisses, dictInstAbscSig, offset=0.0) :
+ """
+ Construction des tableaux thermo-mécanique
+ listDictTher contient un dictionnaire par numéro d'ordre
+ """
+ table_temp = para_resu[label].EXTR_TABLE()
+
+ # On construit un dictionnaire associant un "instant" avec une liste de couples ("abscisse", liste de "sigma")
+
+ # Utilisation des méthodes de la classe table
+ dictTable = table_temp.values()
+
+ # On construit un dictionnaire associant un "instant" avec un couple ("abscisse", "température")
+
+ # 1. Récupération de la liste des instants
+ INSTANTS = dictTable['INST']
+ for val in INSTANTS :
+ dictInstAbscSig[val] = 0 # On crée juste les clés du dictionnaire
+
+ listTables = list() # liste de tables contenant une table pas instant
+ for inst in dictInstAbscSig.keys():
+ listTables.append(table_temp.INST == inst)
+
+ # 2. Récupération des abscisses
+ self.getAbscisses(listTables[0].values(), tabAbscisses, offset)
+
+ # 3. Récupération des listes de sigma
+ listListListSigAbscInst = list() # liste des sigma par abscisse par instant
+ for tbl in listTables:
+ listListSigAbscInst = list()
+
+ # On crée une table pour chaque instant
+ S_XX = tbl.values()['SIXX']
+ S_YY = tbl.values()['SIYY']
+ S_ZZ = tbl.values()['SIZZ']
+ S_XY = tbl.values()['SIXY']
+ S_YZ = tbl.values()['SIYZ']
+ S_XZ = tbl.values()['SIXZ']
+ for v1, v2, v3, v4, v5, v6 in zip(S_XX, S_YY, S_ZZ, S_XY, S_YZ, S_XZ) :
+ listSigAbsc = list() # Liste des sigmas pour une abscisse
+ listSigAbsc.append(v1)
+ listSigAbsc.append(v2)
+ listSigAbsc.append(v3)
+ listSigAbsc.append(v4)
+ listSigAbsc.append(v5)
+ listSigAbsc.append(v6)
+
+ listListSigAbscInst.append(listSigAbsc)
+
+ listListListSigAbscInst.append(listListSigAbscInst)
+
+ # 4. Assemblage du dictionnaire
+ for i in range(0, len(dictInstAbscSig.keys())) :
+ listDoublet = list()
+ for j in range(0, len(tabAbscisses)) :
+ listDoublet.append((tabAbscisses[j], listListListSigAbscInst[i][j]))
+
+ dictInstAbscSig[dictInstAbscSig.keys()[i]] = listDoublet
+
+ def mergeDictTher(self) :
+ """
+ Merge les resultats issus de la coupe du revetement avec ceux issus de la coupe de la structure
+ """
+ # Merge des listes d'abscisses
+ # Le revetement est interieur la derniere abscisse du revetement doit etre egal a la premiere de la structure
+ if self.tabAbscisses_S[len(self.tabAbscisses_S)-1] != self.tabAbscisses[0] :
+ UTMESS('F', 'IMPR_OAR', 'LES COUPES DU REVETEMENT ET DE LA STRUCTURE DOIVENT PARTAGER UNE ABSCISSE COMMUNE')
+
+ # On construit une table des abscisses tempopraire
+ tableAbscTemp = self.tabAbscisses_S
+
+ # On recopie la table des abscisses en sautant le premier
+ debut = True
+ for val in self.tabAbscisses :
+ if debut :
+ debut = False
+ continue
+ tableAbscTemp.append(val)
+
+ self.tabAbscisses = tableAbscTemp
+
+ # On construit des listes de travail intermédiaires que l'on commence par remplir avec les tables "supplémentaires"
+ dictInstAbscSigBis = self.dictInstAbscSig_S
+ dictInstAbscTempBis = self.dictInstAbscTemp_S
+
+ # On recopie les élément thermiques de la structure principale en sautant la première abscisse de la structure
+ for key in dictInstAbscTempBis.keys() : # Les dictionnaires partagent les memes instants
+ debut = True
+ for valTher in self.dictInstAbscTemp[key] :
+ if debut :
+ debut = False
+ continue
+ dictInstAbscTempBis[key].append(valTher)
+
+ # On recopie les élément mécaniques de la structure principale en sautant la première abscisse de la structure
+ for key in dictInstAbscSigBis.keys() : # Les dictionnaires partagent les memes instants
+ debut = True
+ for valSig in self.dictInstAbscSig[key] :
+ if debut :
+ debut = False
+ continue
+ dictInstAbscSigBis[key].append(valSig)
+
+ # On restitue ensuite la liste globale dans self.dictInstAbscSig
+ self.dictInstAbscSig = dictInstAbscSigBis
+ self.dictInstAbscTemp = dictInstAbscTempBis
+
+ def compareListAbscTher(self) :
+ """
+ Vérifie que la coupe du champ thermique et la coupe mécanique partagent les memes abscisses
+ """
+ # 1. Récupération des abscisses associées aux températures
+ listAbsc = list()
+ lstDoublet = self.dictInstAbscTemp[self.dictInstAbscTemp.keys()[0]]
+ for val in lstDoublet :
+ listAbsc.append(val[0])
+
+ # 2. Comparaison des deux listes
+ for A1, A2 in zip(self.tabAbscisses, listAbsc) :
+ if A1 != A2 : return False
+
+ return True
+
+ def interpoleInstants(self) :
+ """
+ Interpole les résultats thermique sur les instants des résultats mécaniques
+ """
+ # 1. récupération des instants des deux tables
+ listInstTher = self.dictInstAbscTemp.keys()
+ listInstMeca = self.dictInstAbscSig.keys()
+
+ # 2. calcul de la liste des bornes de la table thermique qui encadrent les résultats mécaniques
+ dictInstAbscTemp = dict()
+ listAbscTemp = list()
+ listBornes = list()
+ for inst in listInstMeca :
+ bornes = getBornes(listInstTher, inst)
+ # Si une des bornes n'est pas définie, on lance une exception
+ if not(bornes[0]) or not(bornes[1]) : raise interpolationError
+
+ abscTempInf = self.dictInstAbscTemp[bornes[0]] # Liste de doublet (abscisse, temperature) pour la borne inférieure
+ abscTempSup = self.dictInstAbscTemp[bornes[1]] # Liste de doublet (abscisse, temperature) pour la borne supérieure
+
+ listAbscTemp = list() # liste de couples abscisses/Température
+ for A1, A2 in zip(abscTempInf, abscTempSup) : # A1 et A2 sont des doublets abscisse/Temperature
+ temperature = interpoleLin( ((bornes[0], A1[1]), (bornes[1], A2[1])), inst)
+ listAbscTemp.append((A1[0], temperature)) # on aurait pu tout aussi bien prendre A2[0] (c est pareil ...)
+
+ dictInstAbscTemp[inst] = listAbscTemp
+
+ # remplacement de l'ancienne table par la nouvelle
+ self.dictInstAbscTemp = dictInstAbscTemp
+
+ def buildTree(self) :
+ """
+ Construction (en mémoire) de l'arborescence du document XML
+ """
+ sigma_xml = ( 'S_RR', 'S_TT', 'S_ZZ', 'S_RT', 'S_TZ', 'S_ZR' )
+
+ # Création de l'arborescence "géométrie"
+ nodeGeomComp = self.nodeComp.append("GEOM_COMPO")
+ nodeGeomComp.append("REVETEMENT", valeur=self.revet)
+ if self.revet == 'OUI' :
+ nodeGeomComp.append("EP_REVET", valeur=self.epaisseur_R)
+ nodeLigneCoupe = nodeGeomComp.append("LIGNE_COUPE")
+ nodeLigneCoupe.append("EPAISSEUR_EF", valeur=self.epaisseur)
+ nodeLigneCoupe.append("DIAM_EXT_EF", valeur=self.diametre)
+ nodeLigneCoupe.append("ORI_ABSC", valeur=self.origine)
+
+ if self.noResuMeca == False :
+ # Création des abscisses
+ for val in self.tabAbscisses :
+ nodeLigneCoupe.append("ABSCISSE", val)
+
+ nodeLigneCoupe.append('PSI', self.angle_c)
+
+ # Création des résultats mécaniques
+ nodeSigma_u = self.nodeComp.append("SIGMA_UNITE")
+ nodeSigma_u.append("NUM_MECA", valeur=self.num_char)
+ nodeSigma_u.append("NOM_MECA", valeur=self.type_char)
+ nodeSigma_meca = nodeSigma_u.append("SIGMA_MECA")
+
+ for i in range(0, len(self.tabAbscisses)) :
+ for val in self.dictMeca.keys() :
+ nodeSigma_meca.append(val, valeur = self.dictMeca[val][i])
+
+ # Création de l'arborescence "résultat thermo_mécanique"
+ if self.noResuTher == False :
+ # Création des abscisses
+ listDoublet = self.dictInstAbscTemp[self.dictInstAbscTemp.keys()[0]]
+ for val in listDoublet :
+ nodeLigneCoupe.append("ABSCISSE", val[0])
+
+ nodeLigneCoupe.append('PSI', self.angle_c)
+
+ # Création des résultats mécaniques
+ nodeSigma_ther_c = self.nodeComp.append("SIGMA_THER_C")
+ nodeSigma_ther_c.append("NUM_TRANSI_THER", valeur=self.num_tran)
+
+ for inst in self.dictInstAbscTemp.keys() : # boucle sur les instants
+ nodeSigma_ther = nodeSigma_ther_c.append("SIGMA_THER")
+ nodeSigma_ther.append("INSTANT", valeur=inst)
+
+ # boucle sur les abscisses
+ for doubletAbscSig, doubletAbscTemp in zip(self.dictInstAbscSig[inst], self.dictInstAbscTemp[inst]) :
+ nodeSigma_point = nodeSigma_ther.append("SIGMA_POINT")
+ for val, label in zip(doubletAbscSig[1], sigma_xml) :
+ nodeSigma_point.append(label, valeur = val)
+
+ nodeSigma_point.append("TEMPERATURE", doubletAbscTemp[1])
+
+class tuyauterie(OAR_element) :
+ """
+ Classe permettant de traiter les tuyauteries
+ """
+ def __init__(self, **args) :
+ self.nodeComp = XMLNode("TUYAUTERIE")
+ try :
+ self.para_resu_meca = args['RESU_MECA']
+ self.num_char = self.para_resu_meca['NUM_CHAR']
+
+ #Gestion du maillage
+ self.maillage = self.para_resu_meca['MAILLAGE']
+ mapy = MAIL_PY()
+ mapy.FromAster(self.maillage)
+
+ self.ma = [val.rstrip() for val in mapy.correspondance_mailles]
+ self.no = [val.rstrip() for val in mapy.correspondance_noeuds]
+
+ self.dictMailleNoeuds = dict()
+ for val in self.ma :
+ self.dictMailleNoeuds[val] = list()
+
+ for i in range(0, len(mapy.co)) :
+ self.dictMailleNoeuds[self.ma[i]].append(self.no[mapy.co[i][0]])
+ self.dictMailleNoeuds[self.ma[i]].append(self.no[mapy.co[i][1]])
+
+ self.dictNoeudValTorseur = dict()
+ self.buildTableTorseur()
+
+ except :
+ UTMESS('F', 'IMPR_OAR', "ERREUR D'ACCES AUX DONNEES")
+
+ # Construction de l arborescence
+ self.buildTree()
+
+
+ def buildTableTorseur(self) :
+ """
+ Construit un dictionnaire associant un noeud à un torseur exprimé sous la forme d'une liste de valeurs
+ """
+ table_temp = self.para_resu_meca['TABLE'].EXTR_TABLE()
+
+ # Utilisation des méthodes de la classe table
+ dictTable = table_temp.values()
+
+ # 1. Récupération de la liste des noeuds
+ NOEUDS = dictTable['NOEUD']
+ for val in NOEUDS :
+ self.dictNoeudValTorseur[val.rstrip()] = list() # On crée juste les clés du dictionnaire
+
+ N = dictTable['N']
+ VY = dictTable['VY']
+ VZ = dictTable['VZ']
+ MT = dictTable['MT']
+ MFY = dictTable['MFY']
+ MFZ = dictTable['MFZ']
+
+ for no, n, vy, vz, mt, mfy, mfz in zip(NOEUDS, N, VY, VZ, MT, MFY, MFZ):
+ no = no.rstrip()
+ self.dictNoeudValTorseur[no].append(n)
+ self.dictNoeudValTorseur[no].append(vy)
+ self.dictNoeudValTorseur[no].append(vz)
+ self.dictNoeudValTorseur[no].append(mt)
+ self.dictNoeudValTorseur[no].append(mfy)
+ self.dictNoeudValTorseur[no].append(mfz)
+
+
+ def buildTree(self) :
+ """
+ Construction (en mémoire) de l'arborescence du document XML
+ """
+ torseur_XML = ( 'FX', 'FY', 'FZ', 'MX', 'MY', 'MZ' )
+
+ # Création de l'arborescence "torseur"
+ nodeTMG = self.nodeComp.append("TORSEUR_MECA-GRP")
+ nodeTM = nodeTMG.append("TORSEUR_MECA")
+ nodeTM.append("oar:CHAR-REF", self.num_char)
+ nodeMTG = nodeTM.append("MAILLE_TORSEUR-GRP")
+ nodeMT = nodeMTG.append("MAILLE_TORSEUR")
+ for MA in self.dictMailleNoeuds.keys() : # Boucle sur les mailles
+ nodeMT.append("oar:MAILLE-REF", MA)
+ for NO in self.dictMailleNoeuds[MA] : # 2 noeuds
+ nodeTorseur = nodeMT.append("oar:TORSEUR")
+ for val, cle in zip(self.dictNoeudValTorseur[NO], torseur_XML) : # 6 valeurs
+ nodeTorseur.append(cle, val)
+
+
+
+def impr_oar_ops(self, TYPE_CALC, **args) :
+ """
+ Macro IMPR_OAR
+ Ecrit des fichiers au format XML selon la DTD OAR Fichier
+
+ IMPR_OAR va etre utilise en deux fois d abord calcul mecanique,
+ ensuite calcul thermique ce qui implique qu il ne peut y avoir qu'une seule des deux options a la fois
+ """
+ # La macro compte pour 1 dans la numérotation des commandes
+ self.set_icmd(1)
+
+ obj = None
+
+ if TYPE_CALC=='COMPOSANT' :
+ obj = composant(**args)
+ elif TYPE_CALC=='MEF' :
+ UTMESS('F', 'IMPR_OAR', 'FONCTION NON IMPLANTEE')
+ elif TYPE_CALC=='TUYAUTERIE' :
+ obj = tuyauterie(**args)
+ else :
+ UTMESS('F', 'IMPR_OAR', 'Mot clé facteur inconnu')
+
+ # Ecriture dans le fichier
+ # Récupération de la LU du fichier de sortie
+ try :
+ unite = args['UNITE']
+ except :
+ unite = 38
+
+ try :
+ ajout=args['AJOUT']
+ except :
+ ajout='NON'
+
+ name = 'fort.'+str(unite)
+ try :
+ if ajout=='NON' : # nouveau fichier
+ fileObj = open(name, 'wt')
+ else : # extension du fichier existant
+ fileObj = open(name, 'a+t')
+ except IOError :
+ UTMESS('F', 'IMPR_OAR', "Erreur à l'ouverture du fichier")
+ else :
+ obj.getNode().save(fileObj)
+ fileObj.close()
-#@ MODIF impr_table_ops Macro DATE 07/03/2006 AUTEUR MCOURTOI M.COURTOIS
+#@ MODIF impr_table_ops Macro DATE 06/11/2006 AUTEUR MCOURTOI M.COURTOIS
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
if not p in tab.para:
UTMESS('A', 'IMPR_TABLE', 'Paramètre absent de la table : %s' % p)
- # sélection des paramètres
- timp=tab[nom_para]
+ # sélection des paramètres et suppression des colonnes vides
+ timp = tab[nom_para]
+ timp = timp.SansColonneVide()
# passage des mots-clés de mise en forme à la méthode Impr
kargs=args.copy()
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 row in timp['FONCTION', 'FONCTION_C']:
for par,cell in row.items():
if type(cell) in StringTypes:
if aster.getvectjev(cell.strip().ljust(19)+'.PROL')<>None:
# 99. Traiter le cas des UL réservées
UL.EtatInit()
-
return ier
# ------------------------------------------------------------------------------
-#@ MODIF info_fonction_ops Macro DATE 02/05/2006 AUTEUR MCOURTOI M.COURTOIS
+#@ MODIF info_fonction_ops Macro DATE 24/10/2006 AUTEUR DURAND C.DURAND
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
import math
from Accas import _F
from Utilitai.Utmess import UTMESS
+ import types
+ from types import ListType, TupleType
+ EnumTypes = (ListType, TupleType)
### On importe les definitions des commandes a utiliser dans la macro
CREA_TABLE = self.get_cmd('CREA_TABLE')
+ CALC_TABLE = self.get_cmd('CALC_TABLE')
IMPR_TABLE = self.get_cmd('IMPR_TABLE')
CALC_FONCTION = self.get_cmd('CALC_FONCTION')
###
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 type(MAX['FONCTION']) not in EnumTypes : l_fonc=[MAX['FONCTION'],]
+ else : l_fonc=MAX['FONCTION']
+ __tmfonc=[None]*3
+ k=0
+ mfact=[]
+ ltyfo=[]
+ lpara=[]
+ lresu=[]
+ lfnom=[]
+ for fonc in l_fonc :
+ __ff=fonc.convert()
+ __ex=__ff.extreme()
+ ltyfo.append(__ff.__class__)
+ lpara.append(__ff.para['NOM_PARA'])
+ lresu.append(__ff.para['NOM_RESU'])
+ lfnom.append(fonc.nom)
+ n_mini=len(__ex['min'])
+ n_maxi=len(__ex['max'])
+ listeMCF=[_F(LISTE_K=[fonc.nom]*(n_mini+n_maxi),PARA='FONCTION'),
+ _F(LISTE_K=['MINI',]*n_mini+['MAXI',]*n_maxi,PARA='TYPE'),]
+ n_resu=__ff.para['NOM_RESU']
+ 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'])]
+ __tmfonc[k]=CREA_TABLE(LISTE=listeMCF)
+ if k!=0 :
+ mfact.append(_F(OPERATION = 'COMB',TABLE=__tmfonc[k]))
+ k=k+1
+ ltyfo=dict([(i,0) for i in ltyfo]).keys()
+ lpara=dict([(i,0) for i in lpara]).keys()
+ lresu=dict([(i,0) for i in lresu]).keys()
+ if len(ltyfo)>1 :
+ UTMESS('F','INFO_FONCTION',''' calcul du MAX, la liste de fonctions\
+ n'est pas homogène en type (fonctions et nappes) ''')
+ if len(lpara)>1 :
+ UTMESS('F','INFO_FONCTION',''' calcul du MAX, la liste de fonctions\
+ n'est pas homogène en label NOM_PARA :'''+' '.join(lpara))
+ if len(lresu)>1 :
+ UTMESS('F','INFO_FONCTION',''' calcul du MAX, la liste de fonctions\
+ n'est pas homogène en label NOM_RESU : '''+' '.join(lresu))
+ __tab=CALC_TABLE(TABLE = __tmfonc[0],
+ ACTION = mfact )
+ __min=CALC_TABLE(TABLE = __tab,
+ ACTION = _F(OPERATION = 'FILTRE',
+ CRIT_COMP = 'MINI',
+ NOM_PARA = lresu[0] ), )
+ __max=CALC_TABLE(TABLE = __tab,
+ ACTION = _F(OPERATION = 'FILTRE',
+ CRIT_COMP = 'MAXI',
+ NOM_PARA = lresu[0] ), )
+ print __min.EXTR_TABLE()
+ print __max.EXTR_TABLE()
+ C_out=CALC_TABLE(TABLE = __min,
+ TITRE = 'Calcul des extrema sur fonction '+' '.join(lfnom),
+ ACTION = _F(OPERATION = 'COMB',
+ TABLE=__max ), )
+ print C_out.EXTR_TABLE()
###
if (ECART_TYPE != None):
-#@ MODIF lire_inte_spec_ops Macro DATE 03/01/2006 AUTEUR REZETTE C.REZETTE
+#@ MODIF lire_inte_spec_ops Macro DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
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)))
+ mcfact.append(_F(PARA='FONCTION_C' ,LISTE_K=l_fonc ,NUME_LIGN=range(2,len(list_fonc)+2)))
self.DeclareOut('tab_inte',self.sd)
tab_inte=CREA_TABLE(LISTE=mcfact,
- TITRE=TITRE,)
+ TITRE=TITRE,
+ TYPE_TABLE='TABLE_FONCTION')
# remet UNITE dans son état initial
UL.EtatInit()
-#@ MODIF lire_table_ops Macro DATE 03/01/2006 AUTEUR REZETTE C.REZETTE
+#@ MODIF lire_table_ops Macro DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
-import string
+import os
+import re
# ------------------------------------------------------------------------------
-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 msplit(chaine, separ):
+ """Equivalent de chaine.split(separ) en acceptant une ou plusieurs
+ occurrences du séparateur.
+ """
+ return re.split('%s+' % re.escape(separ), chaine.strip(separ))
# ------------------------------------------------------------------------------
-def lire_table_ops(self,UNITE,FORMAT,NUME_TABLE,SEPARATEUR,
- PARA,TITRE,**args):
- """Méthode corps de la macro LIRE_TABLE
- """
- import os
- from Accas import _F
- from Utilitai.Utmess import UTMESS
- from Utilitai.UniteAster import UniteAster
-
- ier=0
- nompro='LIRE_TABLE'
- ### On importe les definitions des commandes a utiliser dans la macro
- CREA_TABLE =self.get_cmd('CREA_TABLE')
+def lecture_table(texte, nume, separ):
+ """Méthode de construction de l'objet Table à partir d'un texte d'une table
+ au format ASTER.
+ """
+ from Utilitai.transpose import transpose
+ from Utilitai.Table import Table
+
+ tab_lue = {}
+ nume_lign = []
+ idt_deb = '#DEBUT_TABLE\n'
+ idt_fin = '#FIN_TABLE\n'
+ idt_tit = '#TITRE'
+ id_vide = '-'
+
+ # expression régulière pour découper les N tables du fichier
+ exp = re.compile(re.escape(idt_deb) + '(.*?)' + re.escape(idt_fin),
+ re.MULTILINE | re.DOTALL)
+ l_txt = exp.findall(texte)
+ nbbloc = len(l_txt)
+ if nume > nbbloc:
+ message = """NUME_TABLE=%d incorrect : il n'y a que %d blocs de tables""" \
+ """ dans le fichier""" % (nume, nbbloc)
+ return 1, message, None
+ txttab = l_txt[nume - 1]
+
+ # expression régulière pour extraire le titre
+ exp = re.compile(re.escape(idt_tit) + '(.*)$', re.MULTILINE)
+ titre_tab = os.linesep.join([s.strip(separ) for s in exp.findall(txttab)])
+
+ # restent dans la table les lignes non vides qui ne sont pas des titres
+ txttab = [line for line in txttab.splitlines() \
+ if line.strip(separ) != '' and not line.startswith(idt_tit)]
+
+ # ligne des paramètres et des types
+ list_para = msplit(txttab.pop(0), separ)
+ list_type = msplit(txttab.pop(0), separ)
+ nb_para = len(list_type)
+
+ # format de lecture
+ fmt = {
+ 'I' : '([0-9\-\+]+)',
+ 'R' : '([0-9\.,\-\+eEdD]+)',
+ 'K' : '(.{%(len)s})'
+ }
+ lfmt = ('%s+' % re.escape(separ)).join(
+ [fmt[typ[0]] % { 'len' : typ[1:] } for typ in list_type]
+ )
+
+ # construction des lignes de la Table
+ l_rows = []
+ for i, line in enumerate(txttab):
+ mat = re.search(lfmt, line)
+ if mat is None or nb_para != len(mat.groups()):
+ message = """Nombre de champs incorrect ligne %d.
+Il y a %d paramètres""" % (i + 1, nb_para)
+ if hasattr(mat, 'groups'):
+ message += """, on a lu %d champs.""" % len(mat.groups())
+ return 1, message, None
+ dico = {}
+ for para, typ, ch in zip(list_para, list_type, mat.groups()):
+ ch = ch.strip()
+ if ch != id_vide:
+ if typ == 'I':
+ val = int(ch)
+ elif typ == 'R':
+ val = float(ch)
+ else:
+ val = ch
+ dico[para] = val
+ l_rows.append(dico)
+
+ tab = Table(l_rows, list_para, list_type, titre_tab)
+ return 0, '', tab
- ### 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
- UL = UniteAster()
- nomfich=UL.Nom(UNITE)
- if not os.path.isfile(nomfich):
- UTMESS('F', nompro, "le fichier '%s' est introuvable" % nomfich)
-
- file=open(nomfich,'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 :
- UTMESS('F', nompro, message)
- 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,**motscles)
-
- # remet UNITE dans son état initial
- UL.EtatInit()
- return ier
+# ------------------------------------------------------------------------------
+def lire_table_ops(self, **args):
+ """Méthode corps de la macro LIRE_TABLE
+ """
+ from Utilitai.Utmess import UTMESS
+ from Utilitai.UniteAster import UniteAster
+
+ ier = 0
+ nompro = 'LIRE_TABLE'
+ ### On importe les definitions des commandes a utiliser dans la macro
+ CREA_TABLE = self.get_cmd('CREA_TABLE')
+ UNITE = self['UNITE']
+ FORMAT = self['FORMAT']
+ NUME_TABLE = self['NUME_TABLE']
+ SEPARATEUR = self['SEPARATEUR']
+ PARA = self['PARA']
+ TITRE = self['TITRE']
+
+ ### 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
+ UL = UniteAster()
+ nomfich=UL.Nom(UNITE)
+ if not os.path.isfile(nomfich):
+ UTMESS('F', nompro, "le fichier '%s' est introuvable" % nomfich)
+
+ texte = open(nomfich,'r').read()
+ # remet UNITE dans son état initial
+ UL.EtatInit()
+
+ ### mise en forme de la liste de valeurs suivant le format choisi :
+ # pour le moment uniquement ASTER
+ if FORMAT=='ASTER':
+ ier, message, tab_lue = lecture_table(texte, NUME_TABLE, SEPARATEUR)
+ if ier != 0 :
+ UTMESS('F', nompro, message)
+ else:
+ pass
+
+ ### création de la table ASTER :
+ self.DeclareOut('ut_tab', self.sd)
+ motscles = tab_lue.dict_CREA_TABLE()
+ ut_tab=CREA_TABLE(**motscles)
+
+ return ier
-#@ MODIF macr_adap_mail_ops Macro DATE 22/05/2006 AUTEUR MCOURTOI M.COURTOIS
+#@ MODIF macr_adap_mail_ops Macro DATE 30/10/2006 AUTEUR DURAND C.DURAND
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# ======================================================================
# RESPONSABLE GNICOLAS G.NICOLAS
#
+"""
+Traitement des macros MACR_ADAP_MAIL/MACR_INFO_MAIL
+"""
+__revision__ = "V1.1"
+#
def macr_adap_mail_ops ( self,
INFO, VERSION_HOMARD, MAILLAGE_FRONTIERE,
**args):
#
# 3. Les caractéristiques d'un maillage sont conservées dans un dictionnaire. Il y a autant de
# dictionnaires que de maillages manipulés. L'ensemble de ces dictionnaires est conservé
-# dans la liste Liste_Maillages.
+# dans la liste liste_maillages.
# Description du dictionnaire de maillages :
# dico["Type_Maillage"] = o ; string ; "MAILLAGE_N", "MAILLAGE_NP1", "MAILLAGE_NP1_ANNEXE" ou "MAILLAGE_FRONTIERE"
# dico["Nom_ASTER"] = o ; concept ASTER associé
#
# 4. Les caractéristiques d'un champ sont conservées dans un dictionnaire. Il y a autant de
# dictionnaires que de champs manipulés. L'ensemble de ces dictionnaires est conservé
-# dans la liste Liste_Champs.
+# dans la liste liste_champs.
# Description du dictionnaire de champs :
# dico["Type_Champ"] = o ; string ; "INDICATEUR" ou "CHAMP_MAJ"
# dico["RESULTAT"] = f ; concept ASTER du résutat associé
# dico["CRITERE"] = f ; entier ; Critère de précision sur l'instant du champ
# dico["CHAM_MAJ"] = f ; string ; Nom ASTER du champ interpolé sur le nouveau maillage
# dico["NOM_MED"] = o ; string ; Nom MED du champ
+# dico["SENSIBILITE"] = f ; string ; Nom du paramètre sensible associé
#
from Accas import _F
from Macro import creation_donnees_homard
import aster
import string
import os
-#gn import shutil
+ import shutil
#
global Liste_Passages
#
codret_partiel = [0]
Rep_Calc_ASTER = os.getcwd()
#
- Liste_Maillages = []
- Liste_Champs = []
- Liste_Zones = []
+ liste_maillages = []
+ liste_champs = []
+ liste_zones = []
dico_indi = {}
#
LISTE_ADAPTATION_LIBRE = ("RAFF_DERA" , "RAFFINEMENT" , "DERAFFINEMENT")
else :
dico["Action"] = "Rien"
#gn print "dico = ",dico
- Liste_Maillages.append(dico)
+ liste_maillages.append(dico)
#
# 2.1.2. ==> L'éventuel indicateur d'erreur
#
-#gn print "\n.. Debut de 2.1.2"
+#gn print "\n.. Debut de 2.1.2"
+#gn print "args = ", args
if args["ADAPTATION"] in LISTE_ADAPTATION_LIBRE :
dico = {}
dico["Type_Champ"] = "INDICATEUR"
for cle in [ "PRECISION", "CRITERE" ] :
if ( args[cle] != None ) :
dico[cle] = args[cle]
+ if ( args["SENSIBILITE"] != None ) :
+ dico["SENSIBILITE"] = args["SENSIBILITE"]
else :
lresu = 0
dico["CHAM_GD"] = args["CHAM_GD"]
noresu = dico["CHAM_GD"].nom
nomsym = " "
- nopase = " "
+#gn print "dico = ", dico
#
-### print "Avant appel a aster.mdnoch, lresu = ",lresu,", noresu =", noresu ,", nomsym = ", nomsym ,", nopase = ", nopase
+ if dico.has_key("SENSIBILITE") :
+ nopase = dico["SENSIBILITE"].nom
+ else :
+ nopase = " "
+#gn print "Avant appel a aster.mdnoch, lresu = ",lresu,", noresu =", noresu ,", nomsym = ", nomsym ,", nopase = ", nopase
dico["NOM_MED"] = aster.mdnoch ( lresu, noresu, nomsym, nopase )
-### print "dico[\"NOM_MED\"] = ", dico["NOM_MED"]
+#gn print "==> dico[\"NOM_MED\"] = ", dico["NOM_MED"]
dico["COMPOSANTE"] = args["NOM_CMP_INDICA"]
- Liste_Champs.append(dico)
+ liste_champs.append(dico)
dico_indi = dico
### print dico
#
#
dico = {}
dico["Type_Champ"] = "CHAMP_MAJ"
- Liste_aux = [ "CHAM_MAJ", "TYPE_CHAM", "NOM_CHAM" ]
+ liste_aux = [ "CHAM_MAJ", "TYPE_CHAM" ]
if ( maj_cham["RESULTAT"] != None ) :
lresu = 1
- Liste_aux.append("RESULTAT")
+ liste_aux.append("RESULTAT")
+ liste_aux.append("NOM_CHAM")
if ( maj_cham["NUME_ORDRE"] != None ) :
dico["NUME_ORDRE"] = maj_cham["NUME_ORDRE"]
elif ( maj_cham["INST"] != None ) :
dico[cle] = maj_cham[cle]
noresu = maj_cham["RESULTAT"].nom
nomsym = maj_cham["NOM_CHAM"]
+ if ( maj_cham["SENSIBILITE"] != None ) :
+ dico["SENSIBILITE"] = maj_cham["SENSIBILITE"]
else :
lresu = 0
- Liste_aux.append("CHAM_GD")
+ liste_aux.append("CHAM_GD")
noresu = maj_cham["CHAM_GD"].nom
nomsym = " "
- for cle in Liste_aux :
+ for cle in liste_aux :
dico[cle] = maj_cham[cle]
- nopase = " "
-### print "Avant appel a aster.mdnoch, lresu = ",lresu,", noresu =", noresu ,", nomsym = ", nomsym ,", nopase = ", nopase
+#gn print "dico = ", dico
+#
+ if dico.has_key("SENSIBILITE") :
+ nopase = dico["SENSIBILITE"].nom
+ else :
+ nopase = " "
+#gn print "Avant appel a aster.mdnoch, lresu = ",lresu,", noresu =", noresu ,", nomsym = ", nomsym ,", nopase = ", nopase
dico["NOM_MED"] = aster.mdnoch ( lresu, noresu, nomsym, nopase )
+#gn print "==> dico[\"NOM_MED\"] = ", dico["NOM_MED"]
#
### print dico
- Liste_Champs.append(dico)
+ liste_champs.append(dico)
#
# 2.1.4. ==> Les zones de raffinement
#
### print zone
### print type(zone)
dico = {}
- for aux in ['X_MINI','X_MAXI','Y_MINI','Y_MAXI','Z_MINI','Z_MAXI','X_CENTRE','Y_CENTRE','Z_CENTRE','RAYON'] :
+ for aux in ['X_MINI', 'X_MAXI', 'Y_MINI', 'Y_MAXI', 'Z_MINI', 'Z_MAXI', 'X_CENTRE', 'Y_CENTRE', 'Z_CENTRE', 'RAYON'] :
if ( zone[aux] != None ) :
dico[aux] = zone[aux]
### print dico
- Liste_Zones.append(dico)
+ liste_zones.append(dico)
#
-### print Liste_Zones
+### print liste_zones
#
# 2.2. ==> Données de pilotage de l'information
#
dico["Type_Maillage"] = "MAILLAGE_N"
dico["Nom_ASTER"] = args["MAILLAGE"]
dico["Action"] = "A_ecrire"
- Liste_Maillages.append(dico)
+ liste_maillages.append(dico)
#
# 2.3. ==> Suivi de frontière
#
dico["Type_Maillage"] = "MAILLAGE_FRONTIERE"
dico["Nom_ASTER"] = MAILLAGE_FRONTIERE
dico["Action"] = "A_ecrire"
- Liste_Maillages.append(dico)
+ liste_maillages.append(dico)
#
# 2.4. ==> Le numéro de version de HOMARD
# Remarque : dans la donnée de la version de HOMARD, il faut remplacer
#
Nom_Concept_Maillage_NP1_ANNEXE = None
l_aux = []
- for dico in Liste_Maillages :
-#gn print "\ndico avant = ",dico
+ for dico in liste_maillages :
+#gn print "\ndico avant = ",dico
if ( dico["Action"] != "Rien" ) :
dico["NOM_MED"] = aster.mdnoma(dico["Nom_ASTER"].nom)
l_aux.append(dico)
Nom_Concept_Maillage_NP1 = dico["Nom_ASTER"].nom
elif ( dico["Type_Maillage"] == "MAILLAGE_NP1_ANNEXE" ) :
Nom_Concept_Maillage_NP1_ANNEXE = dico["Nom_ASTER"].nom
-#gn print "\ndico apres = ",dico
- Liste_Maillages = l_aux
+#gn print "\ndico apres = ",dico
+ liste_maillages = l_aux
#
# 3.2. ==> Recherche du numéro d'itération et du répertoire de travail
#
##
# 4.1.1. ==> D'ASTER vers HOMARD
#
- Unite_Fichier_ASTER_vers_HOMARD = 1787 + 2*numero_passage_fonction
- Fichier_ASTER_vers_HOMARD = os.path.join(Rep_Calc_ASTER,"fort." + str(Unite_Fichier_ASTER_vers_HOMARD))
-### print "Fichier_ASTER_vers_HOMARD = ",Fichier_ASTER_vers_HOMARD
+ unite_fichier_aster_vers_homard = 1787 + 2*numero_passage_fonction
+ fichier_aster_vers_homard = os.path.join(Rep_Calc_ASTER,"fort." + str(unite_fichier_aster_vers_homard))
+### print "fichier_aster_vers_homard = ",fichier_aster_vers_homard
#
# 4.1.2. ==> De HOMARD vers ASTER
#
if ( mode_homard == "ADAP" ) :
- Unite_Fichier_HOMARD_vers_ASTER = Unite_Fichier_ASTER_vers_HOMARD + 1
- Fichier_HOMARD_vers_ASTER = os.path.join(Rep_Calc_ASTER,"fort." + str(Unite_Fichier_HOMARD_vers_ASTER))
-### print "Fichier_HOMARD_vers_ASTER = ",Fichier_HOMARD_vers_ASTER
+ unite_fichier_homard_vers_aster = unite_fichier_aster_vers_homard + 1
+ fichier_homard_vers_aster = os.path.join(Rep_Calc_ASTER,"fort." + str(unite_fichier_homard_vers_aster))
+### print "fichier_homard_vers_aster = ",fichier_homard_vers_aster
#
# 4.2. La définition du fichier de ASTER vers HOMARD
#
DEFI_FICHIER ( ACTION= "ASSOCIER",
- UNITE = Unite_Fichier_ASTER_vers_HOMARD,
+ UNITE = unite_fichier_aster_vers_homard,
TYPE = "LIBRE",
INFO = INFO )
#
# les conventions MED imposent la présence du maillage dans le fichier.
# Donc on va toujours écrire.
#
- for dico in Liste_Maillages :
+ for dico in liste_maillages :
if ( dico["Action"] == "A_ecrire" ) :
motscsi = {}
motscsi["MAILLAGE"] = dico["Nom_ASTER"]
**motscsi )
#
IMPR_RESU ( INFO = INFO,
- FORMAT ='MED', UNITE = Unite_Fichier_ASTER_vers_HOMARD,
+ FORMAT ='MED', UNITE = unite_fichier_aster_vers_homard,
**motscfa )
#
# 4.4. Le(s) champ(s)
# dico["CRITERE"] = f ; entier ; Critère de précision sur l'instant du champ
# dico["CHAM_MAJ"] = f ; string ; Nom ASTER du champ interpolé sur le nouveau maillage
# dico["NOM_MED"] = o ; string ; Nom MED du champ
+# dico["SENSIBILITE"] = f ; string ; Nom du paramètre sensible associé
#
# 4.4.1. Recherche d'un doublon éventuel sur le champ d'indicateur d'erreur
#
-### print "dico_indi = ",dico_indi
+#gn print "dico_indi = ",dico_indi
if len(dico_indi) > 0 :
indic_est_deja_imprime = 0
if dico_indi.has_key("RESULTAT") :
- Liste_aux = [ "RESULTAT", "NOM_CHAM" ]
+ liste_aux = [ "RESULTAT", "NOM_CHAM" ]
else :
- Liste_aux = [ "CHAM_GD" ]
+ liste_aux = [ "CHAM_GD" ]
else :
indic_est_deja_imprime = 1
- Liste_aux = [ ]
-### print ".. Au debut de la boucle, Liste_aux = ",Liste_aux
-### print ".. Au debut de la boucle, indic_est_deja_imprime = ",indic_est_deja_imprime
+ liste_aux = [ ]
+#gn print ".. Au debut de la boucle, liste_aux = ",liste_aux
+#gn print ".. Au debut de la boucle, indic_est_deja_imprime = ",indic_est_deja_imprime
#
- Liste_Champs_imprime = []
- for dico in Liste_Champs :
+ liste_champs_imprime = []
+ for dico in liste_champs :
### print "\n.... dico = ",dico
# Pour un champ à mettre à jour, on a toujours impression
if ( dico["Type_Champ"] == "CHAMP_MAJ" ) :
- Liste_Champs_imprime.append(dico)
+ liste_champs_imprime.append(dico)
# Si le champ d'indicateur n'a toujours pas été repéré comme champ à mettre à jour :
if not indic_est_deja_imprime :
# Est-ce le meme champ ?
on_a_le_champ = 1
- for cle in Liste_aux :
+ for cle in liste_aux :
if ( dico.has_key(cle) ) :
### print "...... dico_indi[cle] = ",dico_indi[cle]
### print "...... dico[cle] = ",dico[cle]
else :
on_a_le_champ = 0
break
+# Si oui, est-ce un champ sensible ou non ?
+ if on_a_le_champ :
+ cle = "SENSIBILITE"
+ if dico.has_key(cle) :
+ if ( dico[cle] != None ) :
+ if dico_indi.has_key(cle) :
+ if ( dico_indi[cle] != dico[cle] ) :
+ on_a_le_champ = 0
+ break
+ else :
+ on_a_le_champ = 0
+ break
# Si oui, est-ce au meme moment ? (remarque : si rien n'est désigné, c'est qu'il n'y a qu'un
# seul instant ... donc c'est le meme ! En revanche, on ne sait pas comparer une donnée
# en numéro d'ordre et une donnée en instant. On croise les doigts.)
# Si le champ d'indicateur n'a pas été repéré comme champ à mettre à jour, il faut
# l'inclure dans les champs à imprimer
if not indic_est_deja_imprime :
- Liste_Champs_imprime.append(dico_indi)
+ liste_champs_imprime.append(dico_indi)
#
# 4.4.2. Impressions après le filtrage précédent
#gn print "\n.... Debut de 4.2.4.2."
#
- for dico in Liste_Champs_imprime :
+ for dico in liste_champs_imprime :
motscsi = {}
for cle in [ "RESULTAT", "NOM_CHAM", "CHAM_GD", "NUME_ORDRE", "INST", "PRECISION", "CRITERE" ] :
if dico.has_key(cle) :
motscsi[cle] = dico[cle]
if dico.has_key("COMPOSANTE") :
motscsi["NOM_CMP"] = dico["COMPOSANTE"]
+ if dico.has_key("SENSIBILITE") :
+ motscsi["SENSIBILITE"] = dico["SENSIBILITE"]
motscfa = {}
motscfa["RESU"] = _F( INFO_MAILLAGE=infomail,
**motscsi
)
-### print ".. motscfa = ",motscfa
+#gn print ".. motscfa = ",motscfa
#
IMPR_RESU ( INFO = INFO,
- FORMAT ='MED', UNITE = Unite_Fichier_ASTER_vers_HOMARD,
+ FORMAT ='MED', UNITE = unite_fichier_aster_vers_homard,
**motscfa )
#
#====================================================================
dico_configuration["version_perso"] = version_perso
#
dico_configuration["niter"] = niter
- dico_configuration["Fichier_ASTER_vers_HOMARD"] = Fichier_ASTER_vers_HOMARD
+ dico_configuration["Fichier_ASTER_vers_HOMARD"] = fichier_aster_vers_homard
if ( mode_homard == "ADAP" ) :
- dico_configuration["Fichier_HOMARD_vers_ASTER"] = Fichier_HOMARD_vers_ASTER
+ dico_configuration["Fichier_HOMARD_vers_ASTER"] = fichier_homard_vers_aster
#
# 5.2. ==> Les noms med des maillages
#
- for dico in Liste_Maillages :
+ for dico in liste_maillages :
#gn print "Nom MED de " + dico["Type_Maillage"] + " = " + dico["NOM_MED"]
dico_configuration[ "NOM_MED_"+dico["Type_Maillage"] ] = dico["NOM_MED"]
+#gn print dico_configuration
#
# 5.3. ==> Les caracteristiques de l'éventuel indicateur d'erreur
#
- for dico in Liste_Champs :
+ for dico in liste_champs :
dico_aux = {}
if ( dico["Type_Champ"] == "INDICATEUR" ) :
- Liste_aux = [ "NOM_MED", "COMPOSANTE" ]
+ liste_aux = [ "NOM_MED", "COMPOSANTE" ]
if dico.has_key("NUME_ORDRE") :
- Liste_aux.append("NUME_ORDRE")
- for cle in Liste_aux :
+ liste_aux.append("NUME_ORDRE")
+ for cle in liste_aux :
if ( dico[cle] != None ) :
dico_aux[cle] = dico[cle]
dico_configuration["Indicateur"] = dico_aux
# 5.4. ==> Les zones de raffinement
#
prem = 1
- for dico in Liste_Zones :
+ for dico in liste_zones :
if prem :
l_aux = [dico]
prem = 0
# 5.5. ==> La mise à jour de champs
#
prem = 1
- for dico in Liste_Champs :
+ for dico in liste_champs :
dico_aux = {}
if ( dico["Type_Champ"] == "CHAMP_MAJ" ) :
- Liste_aux = [ "NOM_MED", "COMPOSANTE" ]
+ liste_aux = [ "NOM_MED", "COMPOSANTE" ]
if dico.has_key("NUME_ORDRE") :
- Liste_aux.append("NUME_ORDRE")
+ liste_aux.append("NUME_ORDRE")
else :
for cle in [ "RESULTAT", "NOM_CHAM", "INST", "PRECISION", "CRITERE" ] :
- Liste_aux.append(cle)
- for cle in Liste_aux :
+ liste_aux.append(cle)
+ for cle in liste_aux :
if dico.has_key(cle) :
if ( dico[cle] != None ) :
dico_aux[cle] = dico[cle]
#
# 5.7. ==> Impression eventuelle des fichiers créés
#
-#gn#gn print "Répertoire ",Rep_Calc_HOMARD_global
- os.system("ls -la "+Rep_Calc_HOMARD_global)
+#gn print "Répertoire ",Rep_Calc_HOMARD_global
+#gn os.system("ls -la "+Rep_Calc_HOMARD_global)
if ( INFO > 1 ) :
- L_aux = ["HOMARD.Donnees" , "HOMARD.Configuration"]
+ l_aux = ["HOMARD.Donnees" , "HOMARD.Configuration"]
else :
- L_aux = [ ]
- for nomfic in L_aux :
+ l_aux = [ ]
+ for nomfic in l_aux :
fic = os.path.join(Rep_Calc_HOMARD_global, nomfic)
if os.path.isfile (fic) :
print "\n\n=============================================================="
#====================================================================
#
#
-#gn print "\.. Debut de 7."
-### Fichier_ASTER_vers_HOMARD_2 = os.path.join("/home/gnicolas" , "fort." + str(Unite_Fichier_ASTER_vers_HOMARD))
-### shutil.copyfile(Fichier_ASTER_vers_HOMARD,Fichier_ASTER_vers_HOMARD_2)
+#gn print "\.. Debut de 6."
+#gn fichier_aster_vers_homard_2 = os.path.join("/tmp" , "fort." + str(unite_fichier_aster_vers_homard))
+#gn shutil.copyfile(fichier_aster_vers_homard, fichier_aster_vers_homard_2)
#
- EXEC_LOGICIEL ( ARGUMENT = (_F(NOM_PARA=Rep_Calc_HOMARD_global), # nom du repertoire
- _F(NOM_PARA=VERSION_HOMARD), # version de homard
- _F(NOM_PARA=str(INFO)), # niveau d information
- _F(NOM_PARA=Nom_Fichier_Donnees), # fichier de données HOMARD
+ EXEC_LOGICIEL ( ARGUMENT = (Rep_Calc_HOMARD_global, # nom du repertoire
+ VERSION_HOMARD, # version de homard
+ str(INFO), # niveau d information
+ Nom_Fichier_Donnees, # fichier de données HOMARD
+ str(version_perso), # version personnelle de homard ?
),
LOGICIEL = homard
)
+# os.system("sleep 3600")
#
-### if ( mode_homard == "ADAP" ) :
-### Fichier_HOMARD_vers_ASTER_2 = os.path.join("/home/gnicolas" , "fort." + str(Unite_Fichier_HOMARD_vers_ASTER))
-### shutil.copyfile(Fichier_HOMARD_vers_ASTER,Fichier_HOMARD_vers_ASTER_2)
+ #gn if ( mode_homard == "ADAP" ) :
+#gn fichier_homard_vers_aster_2 = os.path.join("/tmp" , "fort." + str(unite_fichier_homard_vers_aster))
+#gn shutil.copyfile(fichier_homard_vers_aster, fichier_homard_vers_aster_2)
+#gn fichier_homard_vers_aster_2_1 = os.path.join("/tmp" , "fort." + str(unite_fichier_homard_vers_aster)+".1")
+#gn os.system("/local00/Logiciels/med-2.3.1/Linux/bin/mdump "+fichier_homard_vers_aster_2+">"+fichier_homard_vers_aster_2_1+"</tmp/donn1")
+#gn fichier_homard_vers_aster_2_2 = os.path.join("/tmp" , "fort." + str(unite_fichier_homard_vers_aster)+".2")
+#gn os.system("/local00/Logiciels/med-2.3.1/Linux/bin/mdump "+fichier_homard_vers_aster_2+">"+fichier_homard_vers_aster_2_2+"</tmp/donn2")
#
#====================================================================
# 7. ==> Ecriture de la commande de lecture des resultats med
# 7.1. ==> Le maillage
#
#gn print "args = ",args
- for dico in Liste_Maillages :
+ for dico in liste_maillages :
#gn print dico
if ( dico["Action"] == "A_lire" ) :
self.DeclareOut("maillage_a_lire", dico["Nom_ASTER"])
- maillage_a_lire = LIRE_MAILLAGE ( UNITE = Unite_Fichier_HOMARD_vers_ASTER,
+ maillage_a_lire = LIRE_MAILLAGE ( UNITE = unite_fichier_homard_vers_aster,
FORMAT = "MED",
NOM_MED = dico["NOM_MED"],
VERI_MAIL = _F(VERIF="NON"), INFO_MED = INFO, INFO = INFO )
+#gn print "MAILLAGE = ",maillage_a_lire
+#gn print "NOM_MED = ",dico["NOM_MED"]
if ( dico["Type_Maillage"] == "MAILLAGE_NP1" ) :
maillage_np1 = maillage_a_lire
+ maillage_np1_nom_med = dico["NOM_MED"]
#
# 7.2. ==> Les champs
+#gn os.system("sleep 100")
#
- for dico in Liste_Champs :
+ for dico in liste_champs :
if ( dico["Type_Champ"] == "CHAMP_MAJ" ) :
#gn print dico
self.DeclareOut("champ_maj", dico["CHAM_MAJ"])
motscsi[cle] = dico[cle]
if dico.has_key("NUME_ORDRE") :
motscsi["NUME_PT"] = dico["NUME_ORDRE"]
- champ_maj = LIRE_CHAMP ( UNITE = Unite_Fichier_HOMARD_vers_ASTER, FORMAT = "MED",
- MAILLAGE = maillage_np1,
+#gn print "MAILLAGE = ",maillage_np1
+#gn print "NOM_MAIL_MED = ",maillage_np1_nom_med
+#gn print "NOM_MED = ",dico["NOM_MED"]
+#gn print "TYPE_CHAM =", dico["TYPE_CHAM"]
+ champ_maj = LIRE_CHAMP ( UNITE = unite_fichier_homard_vers_aster, FORMAT = "MED",
+ MAILLAGE = maillage_np1, NOM_MAIL_MED=maillage_np1_nom_med,
NOM_MED = dico["NOM_MED"], NOM_CMP_IDEM = "OUI", TYPE_CHAM = dico["TYPE_CHAM"],
INFO = INFO, **motscsi )
#
# 8. Menage des fichiers MED et HOMARD devenus inutiles
#====================================================================
#
- Liste_aux = [ Fichier_ASTER_vers_HOMARD ]
+ liste_aux = [ fichier_aster_vers_homard ]
if ( mode_homard == "ADAP" ) :
- Liste_aux.append(Fichier_HOMARD_vers_ASTER)
+ liste_aux.append(fichier_homard_vers_aster)
fic = os.path.join(Rep_Calc_HOMARD_global, fic_homard_niter)
- Liste_aux.append(fic)
-#gn print "Liste_aux = ",Liste_aux
+ liste_aux.append(fic)
+#gn print "liste_aux = ",liste_aux
#
- for fic in Liste_aux :
+ for fic in liste_aux :
if ( INFO > 1 ) :
print "Destruction du fichier ", fic
if os.path.isfile(fic) :
-#@ MODIF macr_ascouf_calc_ops Macro DATE 22/05/2006 AUTEUR MCOURTOI M.COURTOIS
+#@ MODIF macr_ascouf_calc_ops Macro DATE 31/10/2006 AUTEUR REZETTE C.REZETTE
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
motscles['LISSAGE']=_F(LISSAGE_THETA='LAGRANGE',
LISSAGE_G='LAGRANGE',
DEGRE=4,)
- _nogloc=CALC_G (MODELE =modele,
- RESULTAT =nomres,
+ _nogloc=CALC_G (RESULTAT =nomres,
TOUT_ORDRE ='OUI',
- CHAM_MATER =affmat,
THETA=_F( FOND_FISS =fonfis,
R_INF = thet['R_INF'],
R_SUP = thet['R_SUP'],),**motscles);
-#@ MODIF macr_ascouf_mail_ops Macro DATE 22/05/2006 AUTEUR MCOURTOI M.COURTOIS
+#@ MODIF macr_ascouf_mail_ops Macro DATE 29/08/2006 AUTEUR MCOURTOI M.COURTOIS
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
#
texte_final=string.join(echo_mess)
aster.affiche('MESSAGE',texte_final)
- return ier
+ return ier,AZIMC
# ------------------------------------------------------------------------------
def ASCTCI(MCL_SOUS_EPAIS,RM):
# NBEP = NOMBRE D'ELEMENTS DANS LE COUDE
# NLX = NOMBRE D'ELEMENTS CIRCONF. DE LA SOUS-EPAISSEUR
# NLY = NOMBRE D'ELEMENTS LONGI DE LA SOUS-EPAISSEUR
+# SUREP = SUR EPAISSEUR
# ------------------------------------------------------------------------------
def write_file_dgib_ASCSQO(nomFichierDATG,TYPELE,RM,RC,ALPHA,NBTRAN,EP1,EP2,
EPI,TETA1,MCL_SOUS_EPAIS,TETA2,LTRAN,LTCHAR,LTCLIM,GEOM,
- SYME,NBEP,NLX,NLY,NIVMAG,loc_datg) :
+ SYME,NBEP,NLX,NLY,NIVMAG,SUREP,AZIMC,loc_datg) :
- ssep= MCL_SOUS_EPAIS[0]
+ ssep= MCL_SOUS_EPAIS[0]
+ print 'AZIMC', AZIMC;
POIVIR = ' ;\n'
texte=' nivmag = '+str(NIVMAG) +POIVIR
texte=texte+' option dime 3 elem '+TYPELE+' nive nivmag echo 0'+POIVIR
texte=texte+' epI = '+str(EPI) +POIVIR
texte=texte+' teta1 = '+str(TETA1) +POIVIR
texte=texte+' teta2 = '+str(TETA2) +POIVIR
- texte=texte+' ltran = '+repr(LTRAN) +POIVIR
+ texte=texte+' ltran = '+repr(LTRAN) +POIVIR
+ texte=texte+' surep = '+str(SUREP) +POIVIR
if GEOM == 'COUDE':
texte=texte+" zcoude = 'oui' "+POIVIR
else:
texte=texte+'*\n'
texte=texte+'* Caracteristiques de la sous-epaisseur\n'
texte=texte+'*\n'
+ texte=texte+' azimc = '+str(AZIMC) +POIVIR
texte=texte+' tysep = '+str(ssep.ICIRP) +POIVIR
texte=texte+' tzsep = '+str(ssep.ILONP) +POIVIR
texte=texte+' prof . 1 = '+str(ssep['PROFONDEUR']) +POIVIR
texte=texte+'nbelz = table '+POIVIR
texte=texte+'axisym = table '+POIVIR
texte=texte+'sousep = table '+POIVIR
- texte=texte+'* \n'
+ texte=texte+'* \n'
texte = texte + open(os.path.join(loc_datg, 'ascouf_ssep_mult_v1.datg'), 'r').read()
fdgib=open(nomFichierDATG,'w')
fdgib.write(texte)
# NZONEY = NOMBRE DE ZONES LONGITUDINALES
#
# ------------------------------------------------------------------------------
-def write_file_pgib_ASCSDO(RM,RC,ALPHA,EP,LTCLIM,LTCHAR,NBEP,
+def write_file_pgib_ASCSDO(RM,RC,ALPHA,EP,LTCLIM,LTCHAR,NBEP,SUREP,
NZONEX,NZONEY,BG,BD,BI,BS,INDBG,INDBD,INDBI,INDBS,
DNX,DNY,MCL_SOUS_EPAIS,GEOM,SYME):
texte=texte+'sousep .'+str(issep).rjust(23)+" = 'oui'"+POIVIR
else:
texte=texte+'sousep .'+str(issep).rjust(23)+" = 'non'"+POIVIR
+ texte=texte+'*\n'
+
+ texte=texte+'* Caracteristique de sur-epaisseur\n'
+ texte=texte+'surep = '+str(SUREP) +POIVIR
texte=texte+'* \n'
texte=texte+'* FIN PARAMETRES UTILISATEUR\n'
fpgib=open('fort.71','w')
fpgib.close()
-
################################################################################
################################################################################
################################################################################
texte=texte+'= PLAQSEP bg bd bi bs indbg indbd indbi indbs rm rc\n'
texte=texte+'alphac pirad epc lt lgv coory coorz axecir axelon prof zsyme posit\n'
texte=texte+'lcoude nxep sousep deny nbely denz nbelz axelonc coorzc axisym\n'
- texte=texte+'daxhtu daxhgv nzt nzgv zcoude'+POIVIR
+ texte=texte+'daxhtu daxhgv nzt nzgv zcoude surep'+POIVIR
texte=texte+'fdromi = ligmed . 1'+POIVIR
texte=texte+'exdrmi = ligmed . 2'+POIVIR
texte=texte+'extrmi = ligmed . 3'+POIVIR
LIRE_MAILLAGE =self.get_cmd('LIRE_MAILLAGE')
DEFI_GROUP =self.get_cmd('DEFI_GROUP')
MODI_MAILLAGE =self.get_cmd('MODI_MAILLAGE')
- AFFE_MODELE =self.get_cmd('AFFE_MODELE')
CREA_MAILLAGE =self.get_cmd('CREA_MAILLAGE')
DEFI_FICHIER =self.get_cmd('DEFI_FICHIER')
IMPR_RESU =self.get_cmd('IMPR_RESU')
AXEAP,AXECP,SFP = ASCFIS(ALPHA, RM, RC, EP1, SUREP, GEOM, FPROF,
DGAXEC, AZIM, POSIT, SF, DSF, BETA, ORIEN)
elif MCL_SOUS_EPAIS!=None :
- ier= ASCSEP(MCL_SOUS_EPAIS,ALPHA,RM,RC,EP1,GEOM,SYME)
+ ier,AZIMC= ASCSEP(MCL_SOUS_EPAIS,ALPHA,RM,RC,EP1,GEOM,SYME)
for ssep in MCL_SOUS_EPAIS:
ssep.IDENL = ssep.ILONP/ssep['NB_ELEM_LONGI']*180./(pi*RC)
ssep.IDENC = ssep.ICIRP/ssep['NB_ELEM_CIRC']*180./(pi*RM)
UNITP = EXEC_MAILLAGE['UNITE_MGIB']
if logiel=='GIBI98' : logiel = loc_gibi+'gibi98'
elif logiel=='GIBI2000': logiel = loc_gibi+'gibi2000'
+
else :
UTMESS('F', "MACR_ASCOUF_MAIL", "seuls gibi98 et gibi2000 sont appelables")
#
# procedure coude sous-ep.: (MOT-CLE SOUS_EPAIS_COUDE)
write_file_dgib_ASCSQO(nomFichierDATG,TYPELE,RM,RC,ALPHA,NBTRAN,EP1,EP2,
EPI,TETA1,MCL_SOUS_EPAIS,TETA2,LTRAN,LTCHAR,LTCLIM,GEOM,
- SYME,NBEP,NLX,NLY,NIVMAG,loc_datg)
+ SYME,NBEP,NLX,NLY,NIVMAG,SUREP,AZIMC,loc_datg)
write_file_pgib_ASCSQ2(MCL_SOUS_EPAIS,NLX,NLY)
else:
# procedure coude sous-ep.:(MOT-CLE SOUS_EPAIS_MULTI)
write_file_dgib_ASCSP1(nomFichierDATG,TYPELE,MCL_SOUS_EPAIS,NIVMAG,loc_datg)
- write_file_pgib_ASCSDO(RM,RC,ALPHA,EP1,LTCLIM,LTCHAR,NBEP,
+ write_file_pgib_ASCSDO(RM,RC,ALPHA,EP1,LTCLIM,LTCHAR,NBEP,SUREP,
NZONEX,NZONEY,BG,BD,BI,BS,INDBG,INDBD,INDBI,INDBS,
DNX,DNY,MCL_SOUS_EPAIS,GEOM,SYME)
write_file_pgib_ASCSP2(MCL_SOUS_EPAIS,NLX,NLY)
# GIBI
+ DEFI_FICHIER(ACTION='LIBERER',UNITE=19)
+ DEFI_FICHIER(ACTION='LIBERER',UNITE=20)
EXEC_LOGICIEL( LOGICIEL = logiel ,
- ARGUMENT = ( _F(NOM_PARA=nomFichierDATG),
- _F(NOM_PARA=nomFichierGIBI), ), )
+ ARGUMENT = (nomFichierDATG,
+ nomFichierGIBI), )
# PRE_GIBI
PRE_GIBI()
- if SYME == 'QUART' : self.DeclareOut('nomres',self.sd)
# LIRE_MAILLAGE
- nomres=LIRE_MAILLAGE(INFO=INFO)
+ __nomres=LIRE_MAILLAGE(INFO=INFO)
# DEFI_GROUP 1
CRITERE = CRITER,),)
- nomres=DEFI_GROUP(reuse =nomres,
- MAILLAGE=nomres,
+ __nomres=DEFI_GROUP(reuse =__nomres,
+ MAILLAGE=__nomres,
**motscles )
#
# DEFI_GROUP 2
motscles['CREA_GROUP_NO'].append(_F(NOM = 'G_AXE_2',
INTERSEC = tuple(l_peau+l_intersec),),)
- nomres=DEFI_GROUP(reuse =nomres,
- MAILLAGE=nomres,
+ __nomres=DEFI_GROUP(reuse =__nomres,
+ MAILLAGE=__nomres,
**motscles )
-# AFFE_MODELE
- __MODELE=AFFE_MODELE( MAILLAGE=nomres,
- AFFE=_F( GROUP_MA = 'COUDE' ,
- PHENOMENE = 'MECANIQUE' ,
- MODELISATION = '3D' , )
- )
-
# MODI_MAILLAGE 1
motscles={}
if GEOM == 'COUDE':
D_PLAQ_TUBE['AZIMUT']=MCL_SOUS_EPAIS[0].IPHIC
else:pass
motscles['PLAQ_TUBE'].append(_F(**D_PLAQ_TUBE),)
- nomres=MODI_MAILLAGE( reuse =nomres,
- MAILLAGE=nomres,
+ __nomres=MODI_MAILLAGE( reuse =__nomres,
+ MAILLAGE=__nomres,
**motscles )
# MODI_MAILLAGE 2
if FISS_COUDE!=None:
if FISS_COUDE['FISSURE'] == 'DEB_INIT':
motscles['ORIE_PEAU_3D']=_F(GROUP_MA=('PEAUINT','EXTUBE','FACE1','FACE2'),)
- nomres=MODI_MAILLAGE(reuse =nomres,
- MAILLAGE=nomres,
- MODELE =__MODELE,
+ __nomres=MODI_MAILLAGE(reuse =__nomres,
+ MAILLAGE=__nomres,
**motscles)
# CREA_MAILLAGE
- if SYME != 'QUART':
- self.DeclareOut('nomre2',self.sd)
- motscles={}
- motscles['CREA_POI1']=[]
- motscles['CREA_POI1'].append(_F(NOM_GROUP_MA='P1',
- GROUP_NO='P1'),)
- if TYPBOL == None :
- motscles['CREA_POI1'].append(_F(NOM_GROUP_MA='P2',
- GROUP_NO='P2'),)
- nomre2=CREA_MAILLAGE( MAILLAGE=nomres,
+ self.DeclareOut('nomre2',self.sd)
+ motscles={}
+ motscles['CREA_POI1']=[]
+ motscles['CREA_POI1'].append(_F(NOM_GROUP_MA='P1',
+ GROUP_NO='P1'),)
+ if TYPBOL == None :
+ motscles['CREA_POI1'].append(_F(NOM_GROUP_MA='P2',
+ GROUP_NO='P2'),)
+ nomre2=CREA_MAILLAGE( MAILLAGE=__nomres,
**motscles)
- else:
- nomre2=nomres
# IMPRESSSION
-#@ MODIF macr_aspic_calc_ops Macro DATE 09/05/2006 AUTEUR REZETTE C.REZETTE
+#@ MODIF macr_aspic_calc_ops Macro DATE 31/10/2006 AUTEUR REZETTE C.REZETTE
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
if COMP_ELAS!=None: motscles['COMP_ELAS']= _F(TOUT = 'OUI',
RELATION = COMP_ELAS['RELATION'],)
if COMP_INCR!=None: motscles['COMP_INCR']= _F(RELATION = COMP_INCR['RELATION'],)
- __gtheta = CALC_G ( MODELE = modele,
- CHAM_MATER = affmat,
- THETA = _F(THETA=__theta),
+ __gtheta = CALC_G ( THETA = _F(THETA=__theta),
OPTION = 'CALC_G_GLOB',
RESULTAT = nomres,
TOUT_ORDRE = 'OUI',
mcfact.append(_F( NUME_ORDRE = born['NUME_ORDRE'] ,
VALE_MIN = born['VALE_MIN' ] ,
VALE_MAX = born['VALE_MAX' ] ) )
- __gbil = CALC_G( MODELE = modele,
- CHAM_MATER = affmat,
- THETA = _F(THETA=__theta),
+ __gbil = CALC_G( THETA = _F(THETA=__theta),
RESULTAT = nomres,
TOUT_ORDRE = 'OUI',
COMP_ELAS = _F(TOUT = 'OUI',
if FERME:
motscles['LISSAGE']=_F(LISSAGE_THETA= 'LAGRANGE',
LISSAGE_G= 'LAGRANGE',)
- __glocal = CALC_G( MODELE = modele,
- CHAM_MATER = affmat,
- THETA=_F( FOND_FISS = fond3d[j],
+ __glocal = CALC_G( THETA=_F( FOND_FISS = fond3d[j],
R_INF = tht3d['R_INF'],
R_SUP = tht3d['R_SUP'],),
RESULTAT = nomres,
VALE_MIN = born['VALE_MIN' ] ,
VALE_MAX = born['VALE_MAX' ] ) )
motscles['BORNES']=mcfact
- __glbil = CALC_G( MODELE = modele,
- CHAM_MATER = affmat,
- THETA=_F( FOND_FISS = fond3d[j],
+ __glbil = CALC_G( THETA=_F( FOND_FISS = fond3d[j],
R_INF = tht3d['R_INF'],
R_SUP = tht3d['R_SUP'],),
RESULTAT = nomres,
-#@ MODIF macr_aspic_mail_ops Macro DATE 22/05/2006 AUTEUR MCOURTOI M.COURTOIS
+#@ MODIF macr_aspic_mail_ops Macro DATE 25/09/2006 AUTEUR GALENNE E.GALENNE
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
YN0 = 0.0
ZN0 = ZA0 + A*CALPHA
XN = XN0 * CTHETA
- YN = XN0 * STHETA
+ YN = XN0 * STHETA
SGAMN = YN / ZN0
ZN = ZN0 * sqrt(1.0 - pow(SGAMN,2))
D0N0 = sqrt( pow((XA0 - XN0),2) + pow((ZA0 - ZN0),2) )
DN = sqrt( pow((XA - XN),2) + pow((YA - YN),2) + pow((ZA - ZN),2) )
RAPP = D0N0 / DN
ECART = (RAPP - 1.0) * D0N0
+ # Correction necessaire dans le cas theta grand (cf. AL9679)
+ if ( abs(STHETA) > 0.8) :
+ DXY = sqrt(pow(XD,2) + pow(YD,2) )
+ XN = XN * DXY/XD0
+ YN = YN * DXY/XD0
+ SGAMN = YN / ZN0
+ ZN = ZN0 * sqrt(1.0 - pow(SGAMN,2))
+ D0N0 = sqrt( pow((XA0 - XN0),2) + pow((ZA0 - ZN0),2) )
+ DN = sqrt( pow((XA - XN),2) + pow((YA - YN),2) + pow((ZA - ZN),2) )
+ RAPP = D0N0 / DN
+ ECART = (ECART + (RAPP - 1.0) * D0N0)/2
A = A + ECART
+
elif (ITYPSO == 2) :
# PIQUAGE TYPE 2
if (POSI == 'DROIT') :
LIRE_MAILLAGE =self.get_cmd('LIRE_MAILLAGE')
DEFI_GROUP =self.get_cmd('DEFI_GROUP')
MODI_MAILLAGE =self.get_cmd('MODI_MAILLAGE')
- AFFE_MODELE =self.get_cmd('AFFE_MODELE')
CREA_MAILLAGE =self.get_cmd('CREA_MAILLAGE')
IMPR_RESU =self.get_cmd('IMPR_RESU')
+ DEFI_FICHIER =self.get_cmd('DEFI_FICHIER')
# La macro compte pour 1 dans la numerotation des commandes
self.set_icmd(1)
THETA, A, C, EPS, RC0, RC1, RC2, RC3,
ALP,BETA, NS, NC, NT, POSI ,NDT,NSDT,TFISS,
ZETA,ITYPSO,DPENE, NIVMAG,loc_datg)
-#
+#
+ DEFI_FICHIER(ACTION='LIBERER',UNITE=19)
+ DEFI_FICHIER(ACTION='LIBERER',UNITE=20)
EXEC_LOGICIEL( LOGICIEL = logiel ,
- ARGUMENT = ( _F(NOM_PARA=nomFichierDATG),
- _F(NOM_PARA=nomFichierGIBI), ), )
+ ARGUMENT = (nomFichierDATG,
+ nomFichierGIBI), )
#
PRE_GIBI()
#
X_MAX = XMAX , )
)
#
- __MODELE=AFFE_MODELE( MAILLAGE=__MAPROV,
- AFFE=_F( GROUP_MA = ('EQUERRE','PEAUINT','EXCORP1','EXCORP2','EXTUBU'),
- PHENOMENE = 'MECANIQUE' ,
- MODELISATION = '3D' , )
- )
-#
+
motscles={}
if TFISS=='DEB_INT' :
motscles['ORIE_PEAU_3D']=_F(GROUP_MA=('PEAUINT','EXCORP1','EXCORP2','EXTUBU','LEVRTUBU','LEVRCORP'),)
motscles['ORIE_PEAU_3D']=_F(GROUP_MA=('PEAUINT','EXCORP1','EXCORP2','EXTUBU',),)
__MAPROV=MODI_MAILLAGE(reuse =__MAPROV,
MAILLAGE=__MAPROV,
- MODELE =__MODELE,
**motscles
)
#
-#@ MODIF macr_cabri_calc_ops Macro DATE 07/10/2005 AUTEUR CIBHHPD L.SALMONA
+#@ MODIF macr_cabri_calc_ops Macro DATE 10/07/2006 AUTEUR LEBOUVIE F.LEBOUVIER
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
MAILLAGE=mail,
ORIE_PEAU_3D=(_F(GROUP_MA=('M_INT','M_TUB',),),
_F(GROUP_MA=('M_L_AA','M_JOI','M_L_SA',),),),
- MODELE=modmeca,);
+ );
-#@ MODIF macr_cabri_mail_ops Macro DATE 07/02/2005 AUTEUR MABBAS M.ABBAS
+#@ MODIF macr_cabri_mail_ops Macro DATE 29/08/2006 AUTEUR MCOURTOI M.COURTOIS
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# Lancement de GIBI
EXEC_LOGICIEL(
LOGICIEL=gibi2000,
- ARGUMENT=(_F(NOM_PARA=fichier_datg),
- _F(NOM_PARA=fichier_mgib),
- )
+ ARGUMENT=(fichier_datg, fichier_mgib),
)
# Lecture du maillage GIBI dans ASTER
PRE_GIBI(
-#@ MODIF macr_fiabilite_ops Macro DATE 14/09/2004 AUTEUR MCOURTOI M.COURTOIS
+#@ MODIF macr_fiabilite_ops Macro DATE 27/11/2006 AUTEUR GNICOLAS G.NICOLAS
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# 2.1. ==> Création du répertoire pour l'exécution du logiciel de fiabilité
#
Nom_Rep_local = "tmp_fiabilite"
- Rep_Calc_LOGICIEL_local = os.path.join(".",Nom_Rep_local)
- Rep_Calc_LOGICIEL_global = os.path.join(Rep_Calc_ASTER,Nom_Rep_local)
+ Rep_Calc_LOGICIEL_local = os.path.join(".", Nom_Rep_local)
+ Rep_Calc_LOGICIEL_global = os.path.join(Rep_Calc_ASTER, Nom_Rep_local)
#
try :
os.mkdir(Rep_Calc_LOGICIEL_global)
- except os.error,erreur_partiel :
+ except os.error, erreur_partiel :
self.cr.warn("Code d'erreur de mkdir : " + str(erreur_partiel[0]) + " : " + erreur_partiel[1])
self.cr.fatal("Impossible de créer le répertoire de travail pour le logiciel de fiabilité : "+Rep_Calc_LOGICIEL_global)
erreur = erreur + 1
break
#
-# 2.2. ==> On crée un fichier annexe pour transmettre des données à la procédure
+# 2.2. ==> On définit un fichier pour les résultats du calcul de fiabilité
+#
+ FIC_RESU_FIABILITE = os.path.join(Rep_Calc_LOGICIEL_global, "resu_fiabilite")
+#
+# 2.3. ==> On crée un fichier annexe pour transmettre des données à la procédure
# de lancement des calculs ASTER par le LOGICIEL.
# Ce fichier est créé dans le répertoire d'exécution du logiciel de fiabilité.
# On fait ainsi car les arguments passés ont du mal à transiter via l'exécutable.
#
valeurs_lois = { }
#
- for m in VARIABLE :
+ for la_variable in VARIABLE :
#
v_moy_physique = None
v_moy_loi = None
# 3.1.1. ==> loi uniforme : transfert des min et max
# on définit une moyennne comme étant la médiane des extremes.
#
- if m["LOI"] == "UNIFORME" :
- v_moy_physique = 0.5 * ( m["VALE_MIN"] + m["VALE_MAX"] )
- v_min_loi = m["VALE_MIN"]
- v_max_loi = m["VALE_MAX"]
+ if la_variable["LOI"] == "UNIFORME" :
+ v_moy_physique = 0.5 * ( la_variable["VALE_MIN"] + la_variable["VALE_MAX"] )
+ v_min_loi = la_variable["VALE_MIN"]
+ v_max_loi = la_variable["VALE_MAX"]
#
# 3.1.2. ==> loi normale : transfert des moyennne et écart-type.
#
- elif m["LOI"] == "NORMALE" :
- v_moy_loi = m["VALE_MOY"]
+ elif la_variable["LOI"] == "NORMALE" :
+ v_moy_loi = la_variable["VALE_MOY"]
v_moy_physique = v_moy_loi
- sigma_loi = m["ECART_TYPE"]
+ sigma_loi = la_variable["ECART_TYPE"]
#
# 3.1.3. ==> loi lognormale : identité du min, conversion pour le reste
#
- elif m["LOI"] == "LOGNORMALE" :
- v_min_loi = m["VALE_MIN"]
- if m["VALE_MOY_PHY"] is None :
- v_moy_loi = m["VALE_MOY"]
- sigma_loi = m["ECART_TYPE"]
+ elif la_variable["LOI"] == "LOGNORMALE" :
+ v_min_loi = la_variable["VALE_MIN"]
+ if la_variable["VALE_MOY_PHY"] is None :
+ v_moy_loi = la_variable["VALE_MOY"]
+ sigma_loi = la_variable["ECART_TYPE"]
aux = Numeric.exp(0.5*sigma_loi*sigma_loi+v_moy_loi)
v_moy_physique = v_min_loi + aux
else :
- v_moy_physique = m["VALE_MOY_PHY"]
- aux = m["ECART_TYPE_PHY"]/(m["VALE_MOY_PHY"]-m["VALE_MIN"])
+ v_moy_physique = la_variable["VALE_MOY_PHY"]
+ aux = la_variable["ECART_TYPE_PHY"]/(la_variable["VALE_MOY_PHY"]-la_variable["VALE_MIN"])
aux1 = 1. + aux*aux
aux2 = Numeric.sqrt(aux1)
- v_moy_loi = Numeric.log((m["VALE_MOY_PHY"]-m["VALE_MIN"])/aux2)
+ v_moy_loi = Numeric.log((la_variable["VALE_MOY_PHY"]-la_variable["VALE_MIN"])/aux2)
aux2 = Numeric.log(aux1)
sigma_loi = Numeric.sqrt(aux2)
#
# on définit une moyennne comme étant la médiane des extremes.
#
else :
- v_moy_loi = m["VALE_MOY"]
- v_min_loi = m["VALE_MIN"]
- v_max_loi = m["VALE_MAX"]
- sigma_loi = m["ECART_TYPE"]
- v_moy_physique = 0.5 * ( m["VALE_MIN"] + m["VALE_MAX"] )
-#
- d = { }
- d["v_moy_physique"] = v_moy_physique
- d["v_moy_loi"] = v_moy_loi
- d["v_min_loi"] = v_min_loi
- d["v_max_loi"] = v_max_loi
- d["sigma_loi"] = sigma_loi
- valeurs_lois[m] = d
+ v_moy_loi = la_variable["VALE_MOY"]
+ v_min_loi = la_variable["VALE_MIN"]
+ v_max_loi = la_variable["VALE_MAX"]
+ sigma_loi = la_variable["ECART_TYPE"]
+ v_moy_physique = 0.5 * ( la_variable["VALE_MIN"] + la_variable["VALE_MAX"] )
+#
+ dico = { }
+ dico["v_moy_physique"] = v_moy_physique
+ dico["v_moy_loi"] = v_moy_loi
+ dico["v_min_loi"] = v_min_loi
+ dico["v_max_loi"] = v_max_loi
+ dico["sigma_loi"] = sigma_loi
+ valeurs_lois[la_variable] = dico
#
#____________________________________________________________________
#
-# 4. Création des fichiers pour le logiciel de fiabilite
+# 4. Création des fichiers de donnees pour le logiciel de fiabilite
#____________________________________________________________________
#
if ( LOGICIEL == "MEFISTO" ) :
#
else :
#
- self.cr.warn("Logiciel de fiabilité : "+LOGICIEL)
- erreur = 10
+ self.cr.warn("Logiciel de fiabilité : "+LOGICIEL)
+ erreur = 10
#
# 4.3. ==> Arret en cas d'erreur
#
#____________________________________________________________________
#
#
- VERSION=string.replace(VERSION,"_",".")
- VERSION=string.replace(VERSION,"N","n")
+ VERSION = string.replace(VERSION, "_", ".")
+ VERSION = string.replace(VERSION, "N", "n")
#
- EXEC_LOGICIEL ( ARGUMENT = (_F(NOM_PARA=Rep_Calc_LOGICIEL_global), # nom du repertoire
- _F(NOM_PARA=LOGICIEL), # nom du logiciel de fiabilité
- _F(NOM_PARA=VERSION), # version du logiciel de fiabilité
+ EXEC_LOGICIEL ( ARGUMENT = (Rep_Calc_LOGICIEL_global, # nom du repertoire
+ LOGICIEL, # nom du logiciel de fiabilité
+ VERSION, # version du logiciel de fiabilité
+ FIC_RESU_FIABILITE, # fichier des résultats du logiciel de fiabilité
),
LOGICIEL = fiabilite
)
erreur = 100
self.cr.fatal(messages_erreur[erreur])
#
-# 6.2. ==> Si tout va bien, on crée une liste de réels pour le retour
-# A terme, il serait intéressant d'y mettre les résultats
-# de l'analyse fiabiliste. Pour le moment, on se contente de
-# mettre une valeur nulle qui permet de faire un test dans
-# les commandes appelantes.
+# 6.2. ==> Si tout va bien, on crée une liste de réels pour le retour.
+# Si le fichier n'a pas été rempli, on met une valeur nulle unique.
+#
+ if os.path.isfile(FIC_RESU_FIABILITE) :
+ liste_reel = []
+ fic = open(FIC_RESU_FIABILITE, "r")
+ tout = fic.readlines()
+ fic.close
+ for ligne in tout:
+ liste_reel.append(float(ligne[:-1]))
+ else :
+ liste_reel = [0.]
+#
+ self.DeclareOut("nomres", self.sd)
+ nomres = DEFI_LIST_REEL( VALE = liste_reel , INFO = 1 )
+#
+# 6.3. ==> Menage du répertoire créé pour le calcul fiabiliste
#
- aux = [float(erreur)]
+ liste = os.listdir(Rep_Calc_LOGICIEL_global)
+## print liste
#
- self.DeclareOut("nomres",self.sd)
- nomres = DEFI_LIST_REEL( VALE = aux , INFO = 1 )
+ for nomfic in liste :
+ fic_total = os.path.join(Rep_Calc_LOGICIEL_global, nomfic)
+#
+ if os.path.isdir(fic_total) :
+ liste_bis = os.listdir(fic_total)
+ for nomfic_bis in liste_bis :
+ fic_total_bis = os.path.join(fic_total, nomfic_bis)
+ if os.path.islink(fic_total_bis) :
+ os.unlink (fic_total_bis)
+ else :
+ os.chmod (fic_total_bis, 0755)
+ os.remove (fic_total_bis)
+ os.rmdir (fic_total)
+#
+ elif os.path.isfile(fic_total) :
+ os.chmod (fic_total, 0755)
+ os.remove (fic_total)
+#
+ os.rmdir (Rep_Calc_LOGICIEL_global)
#
return
#
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)
+ 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)
#
-#@ MODIF macr_lign_coupe_ops Macro DATE 09/05/2006 AUTEUR GALENNE E.GALENNE
+#@ MODIF macr_lign_coupe_ops Macro DATE 27/06/2006 AUTEUR THOMASSO D.THOMASSON
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
if MAILLE != None :
motscles['VIS_A_VIS'].append(_F(MAILLE_1 = MAILLE,TOUT_2='OUI'),)
+ if n_modele in self.get_global_contexte().keys() : MODELE_1=self.get_global_contexte()[n_modele]
+ else : MODELE_1=self.jdc.current_context[n_modele]
__recou=PROJ_CHAMP(METHODE='ELEM',
RESULTAT=RESULTAT,
- MODELE_1=self.jdc.current_context[n_modele],
+ MODELE_1=MODELE_1,
MODELE_2=__mocou,
TYPE_CHAM='NOEU',
NOM_CHAM=NOM_CHAM, **motscles);
-#@ MODIF macr_recal_ops Macro DATE 08/11/2005 AUTEUR ASSIRE A.ASSIRE
+#@ MODIF macr_recal_ops Macro DATE 14/11/2006 AUTEUR ASSIRE A.ASSIRE
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
+# RESPONSABLE ASSIRE A.ASSIRE
+import os, sys, types, copy, math
+from glob import glob
+import Numeric
+debug = False
-def macr_recal_ops(self,UNITE_ESCL, RESU_EXP, POIDS, LIST_PARA, RESU_CALC,
- ITER_MAXI, RESI_GLOB_RELA,UNITE_RESU,PARA_DIFF_FINI,
- GRAPHIQUE, INFO, **args ):
- """Macro commande réalisant le recalage de modèles Aster""",
+INFO = 1
+NOMPRO = 'MACR_RECAL'
+
+fichier_export = None
+mode_python = False
+type_fonctionnelle = 'float'
+
+# --------------------------------------------------------------------------------------------------
+def UTMESS(code,sprg,texte):
+ fmt='\n <%s> <%s> %s\n\n'
+ if INFO>0 or code=='F': print fmt % (code,sprg,texte)
+ if code=='F':
+ sys.exit()
+
+
+# --------------------------------------------------------------------------------------------------
+def Ecriture_Fonctionnelle(output_file, type_fonctionnelle, fonctionnelle):
+
+ try: os.remove(output_file)
+ except: pass
+
+ f=open(output_file, 'w')
+ if type_fonctionnelle == 'vector':
+ fonctionnelle = str(fonctionnelle.tolist())
+ fonctionnelle = fonctionnelle.replace('[','')
+ fonctionnelle = fonctionnelle.replace(']','')
+ f.write(str(fonctionnelle))
+ f.close()
+
+
+# --------------------------------------------------------------------------------------------------
+def Ecriture_Derivees(output_file, derivees):
+
+ try: os.remove(output_file)
+ except: pass
+
+ # On sort si il n'y a pas de derivees a imprimer
+ if not derivees: return
+
+ txt = ''
+ a = derivees
+ for l in range(len(a[:,0])):
+ ligne = []
+ for c in range(len(a[0,:])):
+ ligne.append( str(a[l,c]) )
+ txt += ','.join(ligne) + '\n'
+
+ f=open(output_file, 'w')
+ f.write(txt)
+ f.close()
+
+
+# --------------------------------------------------------------------------------------------------
+def Sortie(LIST_NOM_PARA, LIST_PARA, val, CALCUL_ASTER, Mess):
+ """Sortie de la macro, on renvoit les parametres obtenus"""
+
+ import Cata, aster, Macro
+ from Cata.cata import DEFI_LIST_REEL
+ from Accas import _F
+ from Utilitai.Utmess import UTMESS
+ from Macro import reca_message
+ from Macro import reca_algo
+ from Macro import reca_interp
+ from Macro import reca_utilitaires
+ from Macro import reca_calcul_aster
+ from Macro.reca_controles import gestion
+
+ if CALCUL_ASTER.METHODE != 'EXTERNE':
+ txt = "Nombre d'evaluation de la fonction : " + str(CALCUL_ASTER.evaluation_fonction)
+ UTMESS('I','MACR_RECAL',txt)
+ Mess.ecrire("\n"+txt)
+
+ LIST_NOM_PARA_ALPHA = [ para[0] for para in LIST_PARA ]
+ LIST_NOM_PARA_ALPHA.sort()
+ lival=[]
+ for i in LIST_NOM_PARA:
+ lival.append( val[ LIST_NOM_PARA_ALPHA.index(i) ] )
+ nomres = DEFI_LIST_REEL(VALE=lival)
+
+ return nomres
+
+
+# --------------------------------------------------------------------------------------------------
+def macr_recal_externe( RESU_EXP, LIST_PARA, RESU_CALC, UNITE_ESCL=3, POIDS=None, LIST_DERIV=None,
+ ITER_MAXI=10, ITER_FONC_MAXI=100, RESI_GLOB_RELA=1.e-6, UNITE_RESU=91, PARA_DIFF_FINI=0.001,
+ GRAPHIQUE=None, SUIVI_ESCLAVE='NON', METHODE='EXTERNE', INFO=1, **args ):
+
+ METHODE='EXTERNE'
+
+ # Mot-cle GRAPHIQUE
+ if GRAPHIQUE:
+ GRAPHIQUE0 = {'INTERACTIF': 'NON', 'AFFICHAGE': 'TOUTE_ITERATION', 'UNITE': 90, 'FORMAT': 'XMGRACE'}
+ for k in GRAPHIQUE0.keys():
+ if not GRAPHIQUE.has_key(k): GRAPHIQUE[k] = GRAPHIQUE0[k]
+
+ if optparse_prefix_graph: args['prefix_graph'] = opts.prefix_graph
+ else: args['prefix_graph'] = os.getcwd() + os.sep + 'graph'
+
+ # Les parametres passes sur la ligne de commande surchargent les parametres de la commande MACR_RECAL
+ if optparse_INFO: INFO=opts.INFO
+ if optparse_follow_output:
+ if opts.follow_output == True: SUIVI_ESCLAVE='OUI'
+ else: SUIVI_ESCLAVE='NON'
+
+ if optparse_objective:
+ if type_fonctionnelle=='vector': args['FONCTIONNELLE']='VECTORIELLE'
+ else: args['FONCTIONNELLE']='SCALAIRE'
+
+ if optparse_gradient:
+ if opts.gradient=='normal': args['GRADIENT']='NORMAL'
+ elif opts.gradient=='adim': args['GRADIENT']='ADIMENSIONNE'
+ else: args['GRADIENT']='NON_CALCULE'
+
+
+ fonctionnelle, gradient = macr_recal(UNITE_ESCL, RESU_EXP, POIDS, LIST_PARA, LIST_DERIV, RESU_CALC,
+ ITER_MAXI, ITER_FONC_MAXI, RESI_GLOB_RELA, UNITE_RESU, PARA_DIFF_FINI,
+ GRAPHIQUE, SUIVI_ESCLAVE, METHODE, INFO, **args )
+
+ return fonctionnelle, gradient
+
+
+# --------------------------------------------------------------------------------------------------
+def macr_recal_ops(self,UNITE_ESCL, RESU_EXP, POIDS, LIST_PARA, LIST_DERIV, RESU_CALC,
+ ITER_MAXI, ITER_FONC_MAXI, RESI_GLOB_RELA,UNITE_RESU,PARA_DIFF_FINI,
+ GRAPHIQUE, SUIVI_ESCLAVE, METHODE, INFO, **args ):
+ """Macro commande realisant le recalage de modeles Aster"""
# Initialisation du compteur d'erreurs
ier=0
- import string, copy, types, Numeric
+ import aster
import Macro
from Cata import cata
- from Cata.cata import DEFI_LIST_REEL
- from Macro.recal import gestion,transforme_list_Num,calcul_F
+ from Cata.cata import DEFI_LIST_REEL, CREA_TABLE, TEST_TABLE
+
from Macro import reca_message
from Macro import reca_algo
from Macro import reca_interp
- from Macro import reca_graphique
-
- try:
- from Utilitai.Utmess import UTMESS
- except ImportError:
- def UTMESS(code,sprg,texte):
- fmt='\n <%s> <%s> %s\n\n'
- print fmt % (code,sprg,texte)
+ from Macro import reca_utilitaires
+ from Macro import reca_calcul_aster
+ from Macro.reca_controles import gestion
+ from Utilitai.Utmess import UTMESS
- # Test du mot-clé GRAPHIQUE
- if GRAPHIQUE:
- dGRAPHIQUE=GRAPHIQUE[0].cree_dict_valeurs(GRAPHIQUE[0].mc_liste)
- if dGRAPHIQUE.has_key('FORMAT') and dGRAPHIQUE['FORMAT'] == 'GNUPLOT':
- # On essaie d'importer Gnuplot -> PAS DE GRAPHIQUE
- try:
- import Gnuplot
- except ImportError:
- GRAPHIQUE == None
- UTMESS('A','MACR_RECAL',"Le logiciel Gnuplot ou le module python Gnuplot.py n'est pas disponible. On desactive l'affichage des courbes.")
+ # Gestion des Exceptions
+ prev_onFatalError = aster.onFatalError()
+ aster.onFatalError('EXCEPTION')
# La macro compte pour 1 dans l'execution des commandes
self.set_icmd(1)
+ # Concept en sortir
self.DeclareOut('nomres',self.sd)
+ # Declaration de toutes les commandes Aster
+ for k,v in cata.__dict__.items() :
+ if type(v)==types.InstanceType:
+ if v.__class__.__name__ in ('OPER','MACRO'):
+ self.current_context[k]= v
+ self.current_context['_F']=cata.__dict__['_F']
+
+ macr_recal(UNITE_ESCL, RESU_EXP, POIDS, LIST_PARA, LIST_DERIV, RESU_CALC,
+ ITER_MAXI, ITER_FONC_MAXI, RESI_GLOB_RELA,UNITE_RESU,PARA_DIFF_FINI,
+ GRAPHIQUE, SUIVI_ESCLAVE, METHODE, INFO, **args)
+
+ return
+
+
+# --------------------------------------------------------------------------------------------------
+def macr_recal(UNITE_ESCL, RESU_EXP, POIDS, LIST_PARA, LIST_DERIV, RESU_CALC,
+ ITER_MAXI, ITER_FONC_MAXI, RESI_GLOB_RELA,UNITE_RESU,PARA_DIFF_FINI,
+ GRAPHIQUE, SUIVI_ESCLAVE, METHODE, INFO, **args ):
+
+
+ # Import d'as_profil
+ if os.environ.has_key('ASTER_ROOT'):
+ sys.path.append(os.path.join(os.environ['ASTER_ROOT'], 'ASTK', 'ASTK_SERV', 'lib'))
+ else:
+ try: sys.path.append(os.path.join(aster.repout, '..', 'ASTK', 'ASTK_SERV', 'lib'))
+ except: pass
+ try:
+ from as_profil import ASTER_PROFIL
+ except:
+ UTMESS('F','MACR_RECAL',"Impossible d'importer le module as_profil ! Vérifier la variable d'environnement ASTER_ROOT ou mettez a jour ASTK.")
+
+ import Macro, Utilitai
+ from Macro import reca_message
+ from Macro import reca_algo
+ from Macro import reca_interp
+ from Macro import reca_utilitaires
+ from Macro import reca_calcul_aster
+ from Macro.reca_controles import gestion
+ if( METHODE != 'EXTERNE'):
+ from Utilitai.optimize import fmin, line_search, line_search_BFGS, approx_fprime, approx_fhess_p, fminBFGS, fminNCG
+
+ if( METHODE == 'EXTERNE'):
+ pass
+ else:
+ if GRAPHIQUE:
+ dGRAPHIQUE=GRAPHIQUE[0].cree_dict_valeurs(GRAPHIQUE[0].mc_liste)
+ if dGRAPHIQUE.has_key('FORMAT') and dGRAPHIQUE['FORMAT'] == 'GNUPLOT':
+ # On essaie d'importer Gnuplot -> PAS DE GRAPHIQUE
+ try:
+ import Gnuplot
+ except ImportError:
+ GRAPHIQUE == None
+ if INFO>=1: UTMESS('A','MACR_RECAL',"Le logiciel Gnuplot ou le module python Gnuplot.py n'est pas disponible. On desactive l'affichage des courbes par Gnuplot.")
+
+
+ #_____________________________________________
+ #
+ # VERIFICATION PREALABLE SUR MEM_ASTER
+ #_____________________________________________
+
+ # Lecture du fichier .export
+ list_export = glob('*.export')
+ if len(list_export) == 0:
+ UTMESS('F','MACR_RECAL',"Probleme : il n'y a pas de fichier .export dans le repertoire de travail!")
+ elif len(list_export) >1:
+ UTMESS('F','MACR_RECAL',"Probleme : il y a plus d'un fichier .export dans le repertoire de travail!")
+
+ prof = ASTER_PROFIL(list_export[0])
+
+ mem_aster = prof['mem_aster'][0]
+ memjeveux = prof.args.get('memjeveux')
+
+ if mem_aster in ('', '100'):
+ if INFO>=1: UTMESS('A','MACR_RECAL',"Attention : il faut specifier une valeur pour 'mem_aster' (menu Option de ASTK) " \
+ "pour limiter la memoire allouee au calcul maitre.")
+ mem_aster = '0'
+ if not memjeveux:
+ UTMESS('F','MACR_RECAL',"Probleme : aucune valeur pour le parametre 'memjeveux'. Verifier le .export")
+
+ try:
+ if mem_aster == '0':
+ memjeveux_esclave = float(memjeveux)
+ else:
+ memjeveux_esclave = float(memjeveux) / float(mem_aster) * 100. - float(memjeveux)
+ except:
+ UTMESS('F','MACR_RECAL',"Probleme : verifier les valeurs des parametres 'mem_aster' et 'memjeveux'")
+
+ if INFO>=1: UTMESS('I','MACR_RECAL',"Information : les calculs esclaves utiliseront : %.1f Mega Mots." % memjeveux_esclave)
+
+
+ #_____________________________________________
+ #
+ # INITIALISATIONS
+ #_____________________________________________
+
+ # Liste des parametres utilisant la sensibilité
+ if not LIST_DERIV: LIST_DERIV = {}
+ LIST_SENSI = LIST_DERIV.keys()
+
+ # Stocke l'ordre initial des parametres pour restituer dans le bon ordre les valeurs en sortie de la macro
+ LIST_NOM_PARA = [ para[0] for para in LIST_PARA ]
+
+ # On classe les parametres
+ LIST_SENSI.sort()
+ LIST_PARA.sort()
+
+ # Defini si on utilise le mot-clé SENSIBILITE pour IMPR_TABLE ou non
+ if len(LIST_SENSI) >0: table_sensibilite = True
+ else: table_sensibilite = False
+
+ # Defini si on ajoute l'echo des calculs esclaves dans le mess du calcul maitre
+ follow_output = False
+ if SUIVI_ESCLAVE and SUIVI_ESCLAVE=='OUI': follow_output = True
+# if( METHODE == 'EXTERNE') and mode_python: follow_output = opts.follow_output
+
+ # Pour les algorithmes d'optimize, on a des limitations
+ if METHODE in ['FMIN', 'FMINBFGS', 'FMINNCG']:
+ # On ne peut tracer qu'a la derniere iteration
+ if GRAPHIQUE:
+ if GRAPHIQUE['AFFICHAGE']=='TOUTE_ITERATION': UTMESS('I','MACR_RECAL',"Pour l'algorithme " + METHODE + " on ne peut tracer qu'a la derniere iteration")
+ # Les bornes ne sont pas gerees
+ UTMESS('I','MACR_RECAL',"Pour l'algorithme " + METHODE + " on ne tient pas compte des bornes sur les parametres.")
+
#_______________________________________________
#
# GESTION DE L'OPTION FACULTATIVE POUR LES POIDS
#_______________________________________________
if( POIDS == None):
POIDS=Numeric.ones(len(RESU_EXP))
-
+
+
#_____________________________________________
#
# GESTION DES ERREURS DE SYNTAXE
#_____________________________________________
- texte_erreur = gestion(UNITE_ESCL,LIST_PARA,RESU_CALC,RESU_EXP,POIDS,GRAPHIQUE,UNITE_RESU)
+ texte_erreur = gestion(UNITE_ESCL,LIST_PARA,RESU_CALC,RESU_EXP,POIDS,GRAPHIQUE,UNITE_RESU,METHODE)
if (texte_erreur != ""):
UTMESS('F', "MACR_RECAL", texte_erreur)
- #_____________________________________________
- #
- # DECLARATION DE TOUTES LES COMMANDES ASTER
- #_____________________________________________
- for k,v in cata.__dict__.items() :
- if type(v)==types.InstanceType:
- if v.__class__.__name__ in ('OPER','MACRO'):
- self.current_context[k]= v
- self.current_context['_F']=cata.__dict__['_F']
#_____________________________________________
#
# INITIALISATIONS
#_____________________________________________
- iter = 0
- restant,temps_iter=0.,0.
- restant,temps_iter,err=reca_algo.temps_CPU(self,restant,temps_iter)
- para,val,borne_inf,borne_sup = transforme_list_Num(LIST_PARA,RESU_EXP)
+
+ if( METHODE != 'EXTERNE'):
+ iter = 0
+ restant,temps_iter=0.,0.
+ restant,temps_iter,err=reca_utilitaires.temps_CPU(restant,temps_iter)
+
+ para,val,borne_inf,borne_sup = reca_utilitaires.transforme_list_Num(LIST_PARA,RESU_EXP)
+
+ # Pour l'algorithme externe, les valeurs sont celles lues dans le fichier input.txt
+ if( METHODE == 'EXTERNE') and mode_python: val = val_externe
+
val_init = copy.copy(val)
- L_init = calcul_F(self,UNITE_ESCL,para,val,RESU_CALC)
- #instance de la classe gérant l'affichage des resultats du calcul de l'optimisation
- Mess = reca_message.Message(para,RESU_EXP,copy.copy(val_init),UNITE_RESU)
- #instances des classes pour le calcul de l'erreur et le dimensionnemnt/adim
+
+ # OBJET "PARAMETRES GLOBAUX"
+ PARAMETRES = reca_calcul_aster.PARAMETRES(
+ METHODE=METHODE,
+ UNITE_RESU=UNITE_RESU,
+ INFO=INFO,
+ fich_output='./REPE_OUT/output_esclave.txt',
+ mode_include=False,
+ follow_output=follow_output,
+ table_sensibilite=table_sensibilite,
+ memjeveux_esclave=memjeveux_esclave,
+ PARA_DIFF_FINI=PARA_DIFF_FINI,
+ ITER_MAXI=ITER_MAXI,
+ ITER_FONC_MAXI=ITER_FONC_MAXI,
+ )
+
+ if( METHODE == 'EXTERNE'):
+ PARAMETRES.fich_output = './tmp_macr_recal/output_esclave.txt'
+ type_fonctionnelle = 'float'
+ if args.has_key('FONCTIONNELLE') and args['FONCTIONNELLE'] == 'VECTORIELLE':
+ PARAMETRES.vector_output = True
+ type_fonctionnelle = 'vector'
+
+ # On utilise le critere en erreur plutot que normalise
+ elif METHODE in ['FMIN', 'FMINBFGS', 'FMINNCG']: PARAMETRES.error_output = True
+
+ # OBJET "CALCUL"
+ CALCUL_ASTER = reca_calcul_aster.CALCUL_ASTER(PARAMETRES, UL=UNITE_ESCL, para=para, reponses=RESU_CALC, LIST_SENSI=LIST_SENSI, LIST_DERIV=LIST_DERIV)
+
+ # Instances des classes pour le calcul de l'erreur et le dimensionnemnt/adim
Simul = reca_interp.Sim_exp(RESU_EXP,POIDS)
Dim = reca_algo.Dimension(copy.copy(val_init),para)
- L_J_init,erreur = Simul.multi_interpole(L_init, RESU_CALC)
- J_init = Simul.norme_J(copy.copy(L_J_init),copy.copy(L_J_init),UNITE_RESU)
- J = J_init
- A = Simul.sensibilite(self,UNITE_ESCL,L_init,val,para,RESU_CALC,PARA_DIFF_FINI,UNITE_RESU)
- A = Dim.adim_sensi(A)
- l = reca_algo.lambda_init(Numeric.matrixmultiply(Numeric.transpose(A),A))
- gradient_init =reca_algo.calcul_gradient(A,erreur) #utile pour le test de convergence, on prend les valeurs dimensionnées
- residu = reca_algo.test_convergence(gradient_init,erreur,A,Numeric.zeros(len(gradient_init),Numeric.Float))
- Mess.affiche_result_iter(iter,J,val,residu,Numeric.array([]),UNITE_RESU)
- # On teste un manque de temps CPU
- restant,temps_iter,err=reca_algo.temps_CPU(self,restant,temps_iter)
- if (err==1):
- ier=ier+1
- return ier
-
- #_____________________________________________
+
+ CALCUL_ASTER.Simul = Simul
+ CALCUL_ASTER.Dim = Dim
+ CALCUL_ASTER.reca_algo = reca_algo
+
+ if (GRAPHIQUE):
+ CALCUL_ASTER.UNITE_GRAPHIQUE = GRAPHIQUE['UNITE']
+
+
+ # Instance de la classe gérant l'affichage des resultats du calcul de l'optimisation
+ Mess = reca_message.Message(para,RESU_EXP,copy.copy(val_init),UNITE_RESU)
+
+ if( METHODE != 'EXTERNE'):
+ Mess.initialise()
+ txt = "Lancement de l'optimisation avec la methode : " + METHODE
+ if INFO>=1: UTMESS('I','MACR_RECAL',txt)
+ Mess.ecrire(txt)
+
+
+
+ #-------------------------------------------------------------------------------
+ # Methode EXTERNE (en fait juste une evaluation de la fonction puis on sort)
#
- # BOUCLE PRINCIPALE DE L'ALGORITHME
- #_____________________________________________
- epsilon = 10.*RESI_GLOB_RELA
- while((residu > RESI_GLOB_RELA) & (iter<ITER_MAXI)):
- iter = iter +1
- new_val, s, l, Act = reca_algo.Levenberg_bornes(self,val,Dim,val_init,borne_inf,borne_sup,A,erreur,l,UNITE_RESU)
- L_F = calcul_F(self,UNITE_ESCL,para,new_val,RESU_CALC)
- new_L_J,new_erreur = Simul.multi_interpole(L_F, RESU_CALC)
- new_J = Simul.norme_J(L_J_init,new_L_J,UNITE_RESU)
- l = reca_algo.actualise_lambda(l,Dim.adim(val),Dim.adim(new_val),A,erreur,new_J,J)
- val = copy.copy(new_val)
- erreur = copy.copy(new_erreur)
- J = new_J
- A = Simul.sensibilite(self,UNITE_ESCL,L_F,val,para,RESU_CALC,PARA_DIFF_FINI,UNITE_RESU)
- A = Dim.adim_sensi(A)
- residu = reca_algo.test_convergence(gradient_init,erreur,A,s)
- Mess.affiche_result_iter(iter,J,val,residu,Act,UNITE_RESU)
-
- # Affichage des courbes
- if GRAPHIQUE:
- GRAPHE_UL_OUT=GRAPHIQUE['UNITE']
- interactif=(GRAPHIQUE['INTERACTIF']=='OUI')
- reca_graphique.graphique(GRAPHIQUE['FORMAT'],L_F,RESU_EXP,RESU_CALC,iter,GRAPHE_UL_OUT,interactif)
+ if( METHODE == 'EXTERNE'):
+
+ # On sauvegarde le fichier esclave si celui-ci est fort.UL (sinon il sera ecrase)
+ fic_esclave = './fort.'+str(UNITE_ESCL)
+ txt_old_esclave = None
+ if os.path.isfile(fic_esclave):
+ f = open(fic_esclave,'r')
+ txt_old_esclave = f.read()
+ f.close()
+
+# try: os.remove('./fort.'+str(UNITE_ESCL))
+# except: pass
+
+ # Fichier bilan
+ txt = '\nPARAMETRES : ' + str([ para[0] for para in LIST_PARA ]) + ' ' + str(val)
+ Mess.ecrire(txt)
+
+ # Execution de l'esclave
+ if args.has_key('GRADIENT') and args['GRADIENT']!='NON_CALCULE':
+
+ # Calcul de F et G
+ fonctionnelle, residu, A_nodim, A = CALCUL_ASTER.calcul_FG(val)
+
+ # Ecriture du fichier grad.txt contenant les derivees
+ if args['GRADIENT'] == 'ADIMENSIONNE': gradient = A
+ else: gradient = A_nodim
+
+ # Ecriture du fichier contenant le gradient
+ if not mode_python: Ecriture_Derivees(output_file='./fort.1901', derivees=gradient)
+
+ else:
+ # Calcul de F
+ fonctionnelle = CALCUL_ASTER.calcul_F(val)
+ gradient = None
+
+ # Ecriture du fichier contenant la fonctionnelle
+ if not mode_python: Ecriture_Fonctionnelle(output_file='./fort.1900', type_fonctionnelle=type_fonctionnelle, fonctionnelle=fonctionnelle)
+
+ # Fichier bilan
+ if type(fonctionnelle) == types.FloatType: txt = '---> fonctionnelle : ' + str(fonctionnelle)
+ else: txt = '---> norme fonctionnelle : ' + str( math.sqrt( (Numeric.sum( [x**2 for x in fonctionnelle] )) ) )
+ Mess.ecrire(txt)
+
+ # Affichage de la valeur de la fonctionnelle
+ if mode_python and opts.INFO==-1: print txt
+
+ # Affichage de la norme du gradient (AA: a remplacer par une formule de norme L2 !!)
+ if gradient:
+ norme = 0
+ for l in range(len(gradient[:,0])):
+ for c in range(len(gradient[0,:])):
+ norme += ( gradient[l,c] * gradient[l,c] )
+ norme = math.sqrt(norme)
+ txt = '---> norme du gradient : ' + str(norme)
+ Mess.ecrire(txt)
+ if mode_python and opts.INFO==-1: print txt
+
+
+ try: os.remove('./fort.'+str(UNITE_ESCL))
+ except: pass
+
+ # On remet l'ancien fichier esclave si c'etait fort.UL
+ if txt_old_esclave:
+ f = open(fic_esclave,'w')
+ f.write(txt_old_esclave)
+ f.close()
+
+
+ L_F = CALCUL_ASTER.L
+ iter = None
+
+ # On va ensuite jusqu'au bout (pour l'impression des graphes)
+
+
+
+ #-------------------------------------------------------------------------------
+ # Algorithme FMIN (pas d'adimensionnement car n'utilise pas de gradient)
+ #
+ elif( METHODE == 'FMIN'):
+ val, fval, warnflag = fmin(CALCUL_ASTER.calcul_F, val, maxiter=ITER_MAXI, maxfun=ITER_FONC_MAXI, fulloutput=1)
+
+ iter_fonc = CALCUL_ASTER.evaluation_fonction
+
+ Mess.ecrire("\nDerniere iteration : ")
+ Mess.affiche_etat_final_convergence(iter,ITER_MAXI,iter_fonc,ITER_FONC_MAXI, RESI_GLOB_RELA,residu=0,Act=[])
+ Mess.affiche_fonctionnelle(fval)
+ Mess.affiche_valeurs(val)
+ if warnflag==1: Mess.ecrire("Attention : le nombre maximum d'evaluations de la fonction (ITER_FONC_MAXI) a ete atteint")
+ if warnflag==2: Mess.ecrire("Attention : le nombre maximum d'iteration de l'algorithme (ITER_MAXI) a ete atteint")
+
+ nomres = Sortie(LIST_NOM_PARA, LIST_PARA, val, CALCUL_ASTER, Mess)
+ return
+
+ else:
+ #-------------------------------------------------------------------------------
+ # Pour tous les autres methodes, on adimensionne
+
+ # Calcul d'initialisation de F, ici L_deriv_sensible ne contient que les termes calculés par la sensibilité, les autres termes sont nuls
+ L_init, L_deriv_sensible = CALCUL_ASTER.calcul_Aster(val, INFO)
+
+ L_J_init, erreur = Simul.multi_interpole(L_init, RESU_CALC)
+ J_init = Simul.norme_J(copy.copy(L_J_init),copy.copy(L_J_init),UNITE_RESU)
+ J = J_init
+
+ A = Simul.sensibilite(CALCUL_ASTER, L_init, L_deriv_sensible, val, PARA_DIFF_FINI)
+ A = Dim.adim_sensi(A)
+
+ l = reca_algo.lambda_init(Numeric.matrixmultiply(Numeric.transpose(A),A))
+ gradient_init =reca_algo.calcul_gradient(A,erreur) #utile pour le test de convergence, on prend les valeurs dimensionnées
+ residu = reca_algo.test_convergence(gradient_init,erreur,A,Numeric.zeros(len(gradient_init),Numeric.Float))
+
+ Mess.affiche_result_iter(iter,J,val,residu,Numeric.array([]))
+ # On teste un manque de temps CPU
+ restant,temps_iter,err=reca_utilitaires.temps_CPU(restant,temps_iter)
+ if (err==1):
+ ier=ier+1
+ return ier
+
+ CALCUL_ASTER.L_init = L_init
+ CALCUL_ASTER.L_J_init = L_J_init
+ CALCUL_ASTER.J_init = J_init
+ CALCUL_ASTER.A_init = A
+ CALCUL_ASTER.gradient_init = gradient_init
+ CALCUL_ASTER.residu_init = residu
+
+
+ #-------------------------------------------------------------------------------
+ # Methode FMINBFGS et FMINNCG
+
+ if METHODE in ['FMINBFGS', 'FMINNCG']:
+ # Derivees
+ fprime=CALCUL_ASTER.calcul_G
+ warnflag=0
+
+ if args.has_key('GRADIENT') and args['GRADIENT'] == 'NON_CALCULE': fprime=None
+
+ if fprime: UTMESS('I','MACR_RECAL',"Les derivees sont calculees par Aster")
+ else: UTMESS('I','MACR_RECAL',"Les derivees sont calculees par l'algorithme")
+
+ # Lancement de l'optimisation
+ if METHODE == 'FMINBFGS':
+ val, fval, func_calls, grad_calls, warnflag = fminBFGS(CALCUL_ASTER.calcul_F, val, fprime=fprime, maxiter=ITER_MAXI, avegtol=RESI_GLOB_RELA, fulloutput=1)
+
+ elif METHODE == 'FMINNCG':
+ val, fval, func_calls, grad_calls, hcalls, warnflag = fminNCG(CALCUL_ASTER.calcul_F, val, fprime=fprime, fhess_p=None, fhess=None, maxiter=ITER_MAXI, avextol=RESI_GLOB_RELA, fulloutput=1)
+
+ # Affichage des messages de sortie
+ iter_fonc = CALCUL_ASTER.evaluation_fonction
+ Mess.ecrire("\nDerniere iteration : ")
+ Mess.affiche_etat_final_convergence(iter,ITER_MAXI,iter_fonc,ITER_FONC_MAXI, RESI_GLOB_RELA,residu=0,Act=[])
+ Mess.affiche_fonctionnelle(fval)
+ Mess.affiche_valeurs(val)
+# if warnflag==1: Mess.ecrire("\nAttention : le nombre maximum d'evaluations de la fonction (ITER_FONC_MAXI) a ete atteint")
+# if warnflag==2: Mess.ecrire("\nAttention : le nombre maximum d'iteration de la methode (ITER_MAXI) a ete atteint")
+
+ # Permet d'avoir un diagnostic NOOK pour le job
+ if warnflag: iter=ITER_MAXI
+
+ L_F = CALCUL_ASTER.L
+ residu = fval
+
+
+
+
+ #-------------------------------------------------------------------------------
+ # Methode Levenberg-Marquardt
+ else:
+
+ #_____________________________________________
+ #
+ # BOUCLE PRINCIPALE DE L'ALGORITHME
+ #_____________________________________________
+ epsilon = 10.*RESI_GLOB_RELA
+ while((residu > RESI_GLOB_RELA) & (iter<ITER_MAXI)):
+ iter = iter +1
+ new_val, s, l, Act = reca_algo.Levenberg_bornes(val,Dim,val_init,borne_inf,borne_sup,A,erreur,l,UNITE_RESU)
+
+ # Calcul de F, ici L_deriv_sensible ne contient que les termes calculés par la sensibilité, les autres termes sont nuls
+ L_F, L_deriv_sensible = CALCUL_ASTER.calcul_Aster(new_val, INFO)
+
+ new_L_J,new_erreur = Simul.multi_interpole(L_F, RESU_CALC)
+ new_J = Simul.norme_J(L_J_init,new_L_J,UNITE_RESU)
+ l = reca_algo.actualise_lambda(l,Dim.adim(val),Dim.adim(new_val),A,erreur,new_J,J)
+
+ val = copy.copy(new_val)
+ erreur = copy.copy(new_erreur)
+ J = new_J
+
+ # Calcul de la matrice des sensibilites
+ A = Simul.sensibilite(CALCUL_ASTER, L_F, L_deriv_sensible, val, PARA_DIFF_FINI)
+ A = Dim.adim_sensi(A)
+
+ # Calcul du residu
+ residu = reca_algo.test_convergence(gradient_init,erreur,A,s)
+
+ # Affichage iteration
+ Mess.affiche_result_iter(iter,J,val,residu,Act)
+ txt = "Informations de convergence :"
+ txt += '\n=======================================================\n'
+ txt += "Fin de l'iteration "+str(iter)+" :\n"
+ txt += '\n=> Fonctionnelle = '+str(J)
+ txt += '\n=> Residu = '+str(residu)
+ txt += '\n=======================================================\n'
+ if INFO>=1: UTMESS('I','MACR_RECAL',txt)
+
+ if (GRAPHIQUE):
+ if GRAPHIQUE['AFFICHAGE']=='TOUTE_ITERATION':
+ GRAPHE_UL_OUT=GRAPHIQUE['UNITE']
+ interactif=(GRAPHIQUE['INTERACTIF']=='OUI')
+ reca_utilitaires.graphique(GRAPHIQUE['FORMAT'],L_F,RESU_EXP,RESU_CALC,iter,GRAPHE_UL_OUT,interactif)
+
+ # On teste un manque de temps CPU
+ restant,temps_iter,err=reca_utilitaires.temps_CPU(restant,temps_iter)
+ if (err==1):
+ ier=ier+1
+ return ier
+
+
+ #_____________________________________________
+ #
+ # FIN DES ITERATIONS
+ # CONVERGENCE OU ECHEC
+ #_____________________________________________
+ iter_fonc = CALCUL_ASTER.evaluation_fonction
+ Mess.affiche_etat_final_convergence(iter,ITER_MAXI,iter_fonc,ITER_FONC_MAXI, RESI_GLOB_RELA,residu,Act)
+ reca_algo.calcul_etat_final(para,A,iter,ITER_MAXI,RESI_GLOB_RELA,residu,Mess)
+
+
+ #-------------------------------------------------------------------------------
- # On teste un manque de temps CPU
- restant,temps_iter,err=reca_algo.temps_CPU(self,restant,temps_iter)
- if (err==1):
- ier=ier+1
- return ier
#_____________________________________________
#
- # FIN DES ITERATIONS
- # CONVERGENCE OU ECHEC
+ # FIN DES ITERATIONS POUR TOUS LES ALGOS
#_____________________________________________
- Mess.affiche_etat_final_convergence(iter,ITER_MAXI,RESI_GLOB_RELA,residu,Act,UNITE_RESU)
- reca_algo.calcul_etat_final(para,A,iter,ITER_MAXI,RESI_GLOB_RELA,residu,Mess,UNITE_RESU)
+
+ if (GRAPHIQUE):
+ trace = False
+ fichier = None
+ # Pour les algorithmes d'optimize.py, on ne peut tracer qu'a la derniere iteration
+ if (GRAPHIQUE['AFFICHAGE']=='ITERATION_FINALE') or (METHODE in ['FMIN', 'FMINBFGS', 'FMINNCG']):
+ trace = True
+ if (METHODE=='EXTERNE' and GRAPHIQUE['AFFICHAGE']=='TOUTE_ITERATION'):
+ trace = True
+ fichier = args['prefix_graph']
+ if trace:
+ if INFO>=1: UTMESS('I','MACR_RECAL',"Trace des graphiques")
+ GRAPHE_UL_OUT=GRAPHIQUE['UNITE']
+ interactif=(GRAPHIQUE['INTERACTIF']=='OUI')
+ reca_utilitaires.graphique(GRAPHIQUE['FORMAT'],L_F,RESU_EXP,RESU_CALC,iter,GRAPHE_UL_OUT,interactif,fichier)
+
+ if( METHODE == 'EXTERNE'):
+ if mode_python: return fonctionnelle, gradient
+
+# print residu, RESI_GLOB_RELA
+
+ # Si pas de convergence alors diagnostic NOOK_TEST_RESU
+ if residu > RESI_GLOB_RELA:
+ from Cata.cata import CREA_TABLE, TEST_TABLE
+ _tmp = []
+ _tmp.append( { 'PARA': 'ITER_MAXI', 'LISTE_R': 0.0, } )
+ motscle= {'LISTE': _tmp }
+
+ TBL=CREA_TABLE(**motscle);
+
+ TEST_TABLE(TABLE=TBL,
+ TYPE_TEST='SOMM',
+ NOM_PARA='ITER_MAXI',
+ VALE=1.,);
+
#_____________________________________________
#
# CREATIONS DE LA LISTE DE REELS CONTENANT
# LES VALEURS DES PARAMETRES A CONVERGENCE
#_____________________________________________
- lival=[]
- for i in range(len(val)):
- lival.append(val[i])
- nomres=DEFI_LIST_REEL(VALE=lival)
+
+
+ nomres = Sortie(LIST_NOM_PARA, LIST_PARA, val, CALCUL_ASTER, Mess)
return
+
+
+
+
+
+
+
+
+
+
+
+
+
+#-------------------------------------------------------------------------------
+if __name__ == '__main__':
+
+ mode_python = True
+
+ from optparse import OptionParser, OptionGroup
+
+ p = OptionParser(usage='usage: %s fichier_export [options]' % sys.argv[0])
+ p.add_option('-i', '--input', action='store', dest='input', type='string', default='input.txt', help='fichier contenant les parametres')
+ p.add_option('-o', '--output', action='store', dest='output', type='string', default='output.txt', help='fichier contenant la fonctionnelle')
+ p.add_option('-g', '--output_grad', action='store', dest='output_grad', type='string', default='grad.txt', help='fichier contenant le gradient')
+ p.add_option('-p', '--prefix_graph', action='store', dest='prefix_graph', type='string', help='prefixe des fichiers contenant les courbes')
+ p.add_option('-v', '--info', action='store', dest='INFO', type='int', help='niveau de message (-1, 0, 1, 2)')
+ p.add_option('-f', '--follow', action='store', dest='follow_output', type='string', help="affiche ou non l'output du fichier Aster (True/False)")
+ p.add_option('-F', '--objective', action='store', dest='objective', type='string', help="type de la fonctionnelle (float/vector)")
+ p.add_option('-G', '--gradient', action='store', dest='gradient' , type='string', default='no', help="calcul du gradient par Aster (no/normal/adim)")
+ p.add_option('-d', '--display', action='store', dest='display' , type='string', help="renvoi du DISPLAY (pour que la creation des courbes soit moins genante)")
+
+# p.add_option('-n', '--name', action='store', dest='name', type='string', default='optim', help="prefixe du fichier de bilan")
+
+ opts, args = p.parse_args()
+
+ # renvoi du DISPLAY (pour que la creation des courbes soit moins genante)
+ if opts.display: os.environ['DISPLAY'] = opts.display
+
+
+ # Options par defaut
+ optparse_input = optparse_output = optparse_output_grad = optparse_prefix_graph = optparse_INFO = optparse_follow_output = optparse_objective = optparse_gradient = optparse_name = None
+
+ if opts.INFO==None: opts.INFO=0
+
+ if opts.input: optparse_input = True
+ if opts.output: optparse_output = True
+ if opts.output_grad: optparse_output_grad = True
+ if opts.prefix_graph: optparse_prefix_graph = True
+ if opts.INFO in [-1, 0, 1, 2]: optparse_INFO = True
+ if opts.follow_output in ['True', 'False']: optparse_follow_output = True
+ if opts.objective in ['float', 'vector']: optparse_objective = True
+ if opts.gradient in ['no', 'normal', 'adim']: optparse_gradient = True
+# if opts.name: optparse_name = True
+
+ if opts.follow_output=='True': opts.follow_output=True
+ if opts.follow_output=='False': opts.follow_output=False
+
+
+ # Fichier .export
+ if args:
+ fichier_export = args[0]
+ if not os.path.isfile(fichier_export): fichier_export = None
+
+ INFO = opts.INFO
+ input_file = opts.input
+ output_file = opts.output
+ output_grad = opts.output_grad
+ type_fonctionnelle = opts.objective
+
+ # Import d'as_profil
+ if os.environ.has_key('ASTER_ROOT'):
+ sys.path.append(os.path.join(os.environ['ASTER_ROOT'], 'ASTK', 'ASTK_SERV', 'lib'))
+ try:
+ from as_profil import ASTER_PROFIL
+ except:
+ UTMESS('F','MACR_RECAL',"Impossible de determiner l'emplacement d'Aster ! Fixer le chemin avec la variable d'environnement ASTER_ROOT.")
+
+ # Efface les fichiers resultats
+ try: os.remove(output)
+ except: pass
+ try: os.remove(output_grad)
+ except: pass
+
+
+ # Si le fichier export n'est pas en argument on prend l'export qui est dans le rep courant
+ if not fichier_export:
+ # Lecture du fichier .export
+ list_export = glob('*.export')
+ if len(list_export) != 1:
+ UTMESS('F','MACR_RECAL',"Impossible de determiner le fichier .export a utiliser. Specifier le sur la ligne de commande.")
+ else:
+ fichier_export = list_export[0]
+ prof = ASTER_PROFIL(fichier_export)
+
+ # Execution du fichier .comm
+ nom_comm = None
+ # fichier/répertoire
+ for lab in ('data', 'resu'):
+ l_fr = getattr(prof, lab)
+ l_tmp = l_fr[:]
+
+ for dico in l_tmp:
+ # fichiers
+ if not dico['isrep']:
+ # Ancien .comm a executer
+ if dico['type'] == 'comm' and dico['ul'] == '1':
+ nom_comm = dico['path']
+
+ # parametres
+ for lab in ('param',):
+ l_fr = getattr(prof, lab)
+# print l_fr
+# print l_fr['version']
+ try: os.environ['ASTER_VERSION'] = l_fr['version'][0]
+ except: pass
+
+
+ if not nom_comm:
+ UTMESS('F','MACR_RECAL',"Probleme : le fichier .comm n'est pas defini dans le .export.")
+ if not os.path.isfile(nom_comm):
+ UTMESS('F','MACR_RECAL',"Probleme : le fichier .comm suivant n'est pas defini : " + nom_comm)
+
+
+
+ # -------------------------------------------------------------------
+ # Lecture des valeurs d'entree
+ if INFO==2: UTMESS('I',NOMPRO,"Lecture du fichier : " + input_file)
+ try:
+ f = open(input_file, 'r')
+ txt = f.read()
+ f.close()
+ txt = txt.replace(',', ' ')
+ val_externe = [ float(x) for x in txt.strip().split() ]
+ except:
+ UTMESS('F',NOMPRO,"Probleme : impossible de lire le fichier d'entree :\n" + input_file)
+ if INFO>=2: UTMESS('I',NOMPRO,"Parametres d'entree : " + str(val_externe))
+ if optparse_INFO and opts.INFO == -1: print '\n'+ str(val_externe)
+
+
+ # -------------------------------------------------------------------
+ # Efface les fichiers d'entree et de sortie
+ try: os.remove(input_file)
+ except: pass
+ try: os.remove(output_file)
+ except: pass
+ try: os.remove(output_grad)
+ except: pass
+
+
+
+
+ # --------------------------------------------------------------------------------------------------------
+ # --------------------------------------------------------------------------------------------------------
+ # --------------------------------------------------------------------------------------------------------
+ # Ci-dessous on extrait le fichier de commande jusqu'a la commande MACR_RECAL exclue (fichiernew)
+ # Puis la commande MACR_RECAL (commandenew)
+ # Ensuite on annule l'effet des commandes Aster et on evalue en Python les deux chaines de textes
+
+ # Lecture du fichier .comm
+ f=open(nom_comm,'r')
+ fichier=f.read()
+ f.close
+
+ # Extraction des deux parties dans le fichier de commande
+ fichiernew=None
+ commandenew=None
+ nb_par=-99
+ txt1='MACR_RECAL'
+ txt2='('
+ txt3=')'
+ for ligne in fichier.split('\n'):
+ if ligne.find( txt1 )!=-1 and ligne.find( txt2 )!=-1 and ligne.strip()[0]!='#':
+ nb_par=0
+ index_deb1 = fichier.index(ligne)
+ fichiernew=fichier[:index_deb1]
+# if debug: print 80*'*' + 2*'\n'+fichiernew+80*'*' + 2*'\n'
+ if fichiernew and ligne.find( txt2 )!=-1: nb_par+=1
+ if fichiernew and ligne.find( txt3 )!=-1: nb_par-=1
+ if fichiernew and nb_par==0:
+ index_fin1 = fichier.index(ligne)+len(ligne)
+ commandenew=fichier[index_deb1:index_fin1]
+
+ # Remplace le nom de concept a gauche du signe egal
+ index_deb2 = commandenew.index(txt1)
+ commandenew='fonctionnelle, gradient='+commandenew[index_deb2:]+ '\n'
+
+ if debug: print 80*'*' + 2*'\n'+commandenew+80*'*' + 2*'\n'
+ break
+ if not fichiernew or not commandenew:
+ txt = "Probleme : Le fichier de commande :\n" + nom_comm + "\n ne semble pas comporter la commande MACR_RECAL"
+ UTMESS('F',NOMPRO,txt)
+
+
+ # -------------------------------------------------------------------
+ # Import du module Utilitai
+ sys.path.append(os.path.join(os.getcwd(), 'Python'))
+ sys.path.append(os.path.join(os.environ['ASTER_ROOT'], os.environ['ASTER_VERSION'], 'bibpyt'))
+ try:
+ import Utilitai
+ from Utilitai.System import ExecCommand
+ except:
+ UTMESS('F','MACR_RECAL',"Probleme : impossible d'importer le module Utilitai! Prevenir la maintenance.")
+
+
+ # -------------------------------------------------------------------
+ # On annule les commandes Aster du fichier maitre .comm
+ def DEBUT(*args, **kwargs): pass
+ def FIN(*args, **kwargs): pass
+ def MACR_RECAL(*args, **kwargs): pass
+ def _F(*args, **kwargs): return kwargs
+ def DEFI_LIST_REEL(*args, **kwargs): pass
+ def DEFI_FONCTION(*args, **kwargs): pass
+ def TEST_FONCTION(*args, **kwargs): pass
+ def DEFI_CONSTANTE(*args, **kwargs): pass
+
+
+ # -------------------------------------------------------------------
+ # Evaluation du fichier de commande Aster jusqu'a MACR_RECAL
+ lance_aster = False
+ try:
+ exec(fichiernew)
+ except:
+ txt = "Le mode EXTERNE tourne en mode degrade. Lire la documentation."
+ UTMESS('A',NOMPRO,txt)
+ lance_aster = True
+ else:
+ exec(commandenew.replace(txt1, 'macr_recal_externe'))
+# try:
+# exec(commandenew.replace(txt1, 'macr_recal_externe'))
+# except Exception, err:
+# print err
+# txt = "Erreur lors de l'execution de la commande MACR_RECAL"
+# UTMESS('F',NOMPRO,txt)
+
+ Ecriture_Fonctionnelle(output_file, type_fonctionnelle, fonctionnelle)
+ Ecriture_Derivees(output_grad, gradient)
+
+
+
+ # --------------------------------------------------------------------------------------------------------
+ # --------------------------------------------------------------------------------------------------------
+ # --------------------------------------------------------------------------------------------------------
+ # Si l'evaluation du fichier de commande Aster jusqu'a MACR_RECAL a echoue, on execute Aster "normalement"
+ if lance_aster:
+
+ _PARAM_ = '_PARAM_'
+ new_fichier_comm = os.getcwd() + os.sep + 'tmp_comm'
+ new_fichier_export = os.getcwd() + os.sep + fichier_export.split('/')[-1] + '_new'
+
+ # Lecture du fichier .comm
+ f=open(nom_comm,'r')
+ fichier=f.read()
+ f.close
+
+ # -------------------------------------------------------------------
+ # Modification du fichier .comm (changement des valeurs, ecriture du resultat dans un fichier)
+ if INFO==2: UTMESS('I',NOMPRO,"Lecture du fichier : " + nom_comm)
+ f = open(nom_comm, 'r')
+ ok1 = ok3 = ok4 = False
+ txt = ''
+ for ligne in f:
+ if ligne.find('MACR_RECAL')!=-1 and ligne.strip()[0]!='#': # On determine le nom du concept sortant de MACR_RECAL
+ ok3 = True
+ _RESU_ = ligne.split('=')[0].strip()
+ txt += ligne
+ elif ligne.strip()[:len(_PARAM_)] == _PARAM_: # On change les parametres : la variables _PARAM_
+ ok1 = True
+ txt += _PARAM_ + " = " + str(val_externe) + '\n'
+ elif ligne.find('METHODE')!=-1 and ligne.strip()[0]!='#': # On verifie bien que la methode externe est choisi
+ if ligne.find("EXTERNE")!=-1:
+ ok4 = True
+ txt += ligne
+ else: txt += ligne
+ f.close()
+
+ if not ok1: UTMESS('F',NOMPRO,"Probleme : il faut mettre les parametres sous la forme d'une ligne python " + str(_PARAM_) + " = [param1, param2, ...]")
+ if not ok3: UTMESS('F',NOMPRO,"Probleme : la commande MACR_RECAL n'a pas ete trouvee dans le .comm")
+ if not ok4: UTMESS('F',NOMPRO,"Probleme : dans la commande MACR_RECAL, il faut choisir METHODE='EXTERNE'")
+
+ txt = txt.replace('_RESU_', _RESU_)
+
+ # Ecriture du nouveau fichier comm temporaire
+ if INFO==2: UTMESS('I',NOMPRO,"Ecriture du fichier : " + new_fichier_comm)
+ f = open(new_fichier_comm, 'w')
+ f.write(txt)
+ f.close()
+
+ # On remplace dans l'export par le nouveau .comm
+ prof = ASTER_PROFIL(fichier_export)
+ for lab in ('data', 'resu'):
+ l_fr = getattr(prof, lab)
+ l_tmp = l_fr[:]
+ for dico in l_tmp:
+ # fichiers
+ if not dico['isrep']:
+ # On remplace par le nouveau .comm
+ if dico['type'] == 'comm' and dico['ul'] == '1':
+ dico['path'] = new_fichier_comm
+
+# if lab == 'resu':
+# dico['path'] = os.path.join(tmp_macr_recal, os.path.basename(dico['path']))
+
+ # On ajoute au profil le fichier output.txt (unite logique 1900)
+ try: os.remove('./fort.1900')
+ except: pass
+ if not output_file.find(os.sep)!=-1: output_file = os.getcwd() + os.sep + output_file
+ prof.Set('R', {'type':'libr', 'isrep':False, 'path': output_file, 'ul':1900, 'compr': False} )
+
+ # On ajoute au profil le fichier grad.txt (unite logique 1901)
+ if optparse_gradient and opts.gradient!='no':
+ try: os.remove('./fort.1901')
+ except: pass
+ output_grad = opts.gradient
+ if not output_grad.find(os.sep)!=-1: output_grad = os.getcwd() + os.sep + output_grad
+ prof.Set('R', {'type':'libr', 'isrep':False, 'path': output_grad, 'ul':1901, 'compr': False} )
+
+
+ # Ecriture du nouveau fichier export
+ try:
+ if INFO==2: UTMESS('I',NOMPRO,"Ecriture du fichier : " + new_fichier_export)
+ prof.WriteExportTo(new_fichier_export)
+ except:
+ UTMESS('F',NOMPRO,"Probleme : Impossible d'ecrire le fichier export : " + new_fichier_export)
+ prof.WriteExportTo('/tmp/exp')
+
+
+ # chemin vers as_run
+ if os.environ.has_key('ASTER_ROOT'):
+ as_run = os.path.join(os.environ['ASTER_ROOT'], 'ASTK', 'ASTK_SERV', 'bin', 'as_run')
+ else:
+ as_run = 'as_run'
+ if INFO>=1: UTMESS('A', nompro, "Variable d'environnement ASTER_ROOT absente, " \
+ "on essaiera avec 'as_run' dans le $PATH.")
+
+
+ # Import du module Utilitai
+ sys.path.append(os.path.join(os.environ['ASTER_ROOT'], os.environ['ASTER_VERSION'], 'bibpyt'))
+ try:
+ import Utilitai
+ from Utilitai.System import ExecCommand
+ except:
+ UTMESS('F','MACR_RECAL',"Probleme : impossible d'importer le module Utilitai! Prevenir la maintenance.")
+
+
+ # Lancement d'Aster avec le deuxieme export
+ cmd = '%s %s' % (as_run, new_fichier_export)
+ if INFO>=2: UTMESS('I','MACR_RECAL',"Lancement de la commande : " + cmd)
+ iret, txt_output = ExecCommand(cmd, follow_output=opts.follow_output,verbose=opts.follow_output)
+ if INFO>=2: UTMESS('I','MACR_RECAL',"Fin du lancement de la commande : " + cmd)
+
+ try: os.remove(new_fichier_comm)
+ except: pass
+ try: os.remove(new_fichier_export)
+ except: pass
+
+
--- /dev/null
+#@ MODIF macr_spectre_ops Macro DATE 14/11/2006 AUTEUR COURTOIS M.COURTOIS
+# -*- coding: iso-8859-1 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+
+from Accas import _F
+import aster
+import string
+from Utilitai.Utmess import UTMESS
+def macr_spectre_ops(self,MAILLAGE,PLANCHER,NOM_CHAM,CALCUL,RESU,IMPRESSION=None,
+ FREQ=None,LIST_FREQ=None,LIST_INST=None,AMOR_SPEC=None,**args):
+ """
+ Ecriture de la macro MACR_SPECTRE
+ """
+ ier=0
+ import string
+ from types import ListType,TupleType,StringType
+ EnumType=(ListType,TupleType)
+
+ ### On importe les definitions des commandes a utiliser dans la macro
+ RECU_FONCTION = self.get_cmd('RECU_FONCTION')
+ CALC_FONCTION = self.get_cmd('CALC_FONCTION')
+ IMPR_FONCTION = self.get_cmd('IMPR_FONCTION')
+ CREA_TABLE = self.get_cmd('CREA_TABLE')
+
+ ### Comptage commandes + déclaration concept sortant
+ self.set_icmd(1)
+ self.DeclareOut('tab',self.sd)
+ macro='MACR_SPECTRE'
+
+ ### construction de la liste des noeuds à traiter
+ planch_nodes={}
+ dic_gpno=aster.getcolljev(MAILLAGE.nom.ljust(8)+".GROUPENO")
+ l_nodes =aster.getvectjev(MAILLAGE.nom.ljust(8)+".NOMNOE")
+ l_plancher=[]
+ for plancher in PLANCHER :
+ liste_no=[]
+ if plancher['NOEUD']!=None :
+ if type(plancher['NOEUD'])==StringType :
+ liste_no.append(plancher['NOEUD'])
+ else :
+ for noeud in plancher['NOEUD'] :
+ liste_no.append(plancher['NOEUD'])
+ if plancher['GROUP_NO']!=None :
+ if type(plancher['GROUP_NO'])==StringType :
+ noms_no =[string.strip(l_nodes[n-1]) \
+ for n in dic_gpno[plancher['GROUP_NO'].ljust(8)]]
+ liste_no=liste_no+noms_no
+ else :
+ for group_no in plancher['GROUP_NO'] :
+ noms_no =[string.strip(l_nodes[n-1]) \
+ for n in dic_gpno[group_no.ljust(8)]]
+ liste_no=liste_no+noms_no
+ planch_nodes[plancher['NOM']]=liste_no
+ l_plancher.append(plancher['NOM'])
+
+ if AMOR_SPEC!=None and type(AMOR_SPEC) not in EnumType :
+ AMOR_SPEC=(AMOR_SPEC,)
+
+ if NOM_CHAM=='ACCE' : dico_glob={}
+ if NOM_CHAM=='DEPL' : dico_glob={'DX_max' :[] ,
+ 'DY_max' :[] ,
+ 'DZ_max' :[] ,
+ 'DH_max' :[] , }
+
+ ############################################################
+ ### boucle 1 sur les planchers
+ for plancher in l_plancher :
+
+ if NOM_CHAM=='ACCE' :
+ __moy_x=[None]*len(planch_nodes[plancher])
+ __moy_y=[None]*len(planch_nodes[plancher])
+ __moy_z=[None]*len(planch_nodes[plancher])
+ if NOM_CHAM=='DEPL' :
+ dicDmax={}
+ ############################################################
+ ### boucle 2 sur les noeuds du plancher
+ indexn=0
+ for node in planch_nodes[plancher] :
+
+ ############################################################
+ ### boucle 3 sur les directions (X,Y,Z)
+ for dd in ('X','Y','Z') :
+
+ ############################################################
+ ### boucle 4 sur les résultats
+ l_fonc=[]
+ for resu in RESU :
+ ### Récupération des fonctions
+ motscles={}
+ if resu['RESU_GENE']!=None :
+ if CALCUL=='ABSOLU' :
+ UTMESS('F', macro, 'Pas de calcul absolu avec tran_gene')
+ motscles['RESU_GENE'] = resu['RESU_GENE']
+
+ if resu['RESULTAT' ]!=None :
+ motscles['RESULTAT'] = resu['RESULTAT']
+
+ __spo=RECU_FONCTION(NOM_CHAM = NOM_CHAM,
+ TOUT_ORDRE = 'OUI',
+ NOM_CMP = 'D'+dd,
+ INTERPOL = 'LIN',
+ PROL_GAUCHE = 'CONSTANT',
+ PROL_DROITE = 'CONSTANT',
+ NOEUD = node , **motscles )
+
+ if NOM_CHAM=='ACCE' :
+ ### Accelerations relatives
+ if CALCUL=='RELATIF' :
+ ### Combinaison avec fonction d acceleration
+ motscles={}
+ if LIST_INST!=None : motscles['LIST_PARA']=LIST_INST
+ __spo=CALC_FONCTION(COMB=(_F(FONCTION=__spo,
+ COEF= 1.0 ),
+ _F(FONCTION=resu['ACCE_'+dd],
+ COEF= 1.0) ),**motscles )
+
+ ### Calcul des spectres d'oscillateur
+ motscles={}
+ if FREQ !=None : motscles['FREQ'] =FREQ
+ if LIST_FREQ!=None : motscles['LIST_FREQ']=LIST_FREQ
+ __spo=CALC_FONCTION(
+ SPEC_OSCI=_F(FONCTION = __spo,
+ AMOR_REDUIT = AMOR_SPEC,
+ NORME = args['NORME'],
+ **motscles ) )
+ l_fonc.append(__spo)
+
+ if NOM_CHAM=='DEPL' :
+ if CALCUL=='ABSOLU' :
+ ### On retranche les deplacements d entrainement
+ motscles={}
+ if LIST_INST!=None : motscles['LIST_PARA']=LIST_INST
+ __spo=CALC_FONCTION(COMB=(_F(FONCTION=__spo,
+ COEF= 1.0 ),
+ _F(FONCTION=resu['DEPL_'+dd],
+ COEF= -1.0) ),**motscles )
+
+ l_fonc.append(__spo)
+
+ ### fin boucle 4 sur les résultats
+ ############################################################
+
+ ############################################################
+ ### calcul de la moyenne sur les resultats à noeud et direction fixes
+ nbresu=len(RESU)
+ if NOM_CHAM=='ACCE' :
+ mcfCMBx=[]
+ mcfCMBy=[]
+ mcfCMBz=[]
+ for spo in l_fonc :
+ mcfCMBx.append(_F(FONCTION=spo,
+ COEF=1./float(nbresu),))
+ mcfCMBy.append(_F(FONCTION=spo,
+ COEF=1./float(nbresu),))
+ mcfCMBz.append(_F(FONCTION=spo,
+ COEF=1./float(nbresu),))
+ motscles={}
+ if LIST_FREQ!=None : motscles['LIST_PARA']=LIST_FREQ
+ if dd=='X' : __moy_x[indexn]=CALC_FONCTION(COMB=mcfCMBx,**motscles)
+ if dd=='Y' : __moy_y[indexn]=CALC_FONCTION(COMB=mcfCMBy,**motscles)
+ if dd=='Z' : __moy_z[indexn]=CALC_FONCTION(COMB=mcfCMBz,**motscles)
+
+ if NOM_CHAM=='DEPL' :
+ moy = 0.
+ for spo in l_fonc :
+ fspo = spo.convert()
+ aspo = fspo.abs()
+ vmax = aspo.extreme()['max']
+ moy = moy + vmax[-1][-1]
+ dicDmax[(node,dd)]=moy/nbresu
+
+ ### fin boucle 3 sur les directions
+ ############################################################
+
+ ################################
+ ### impressions en chaque noeud
+ if NOM_CHAM=='ACCE' and IMPRESSION!=None :
+ if IMPRESSION['TOUT']=='OUI' :
+ __moyxa=[None]*len(AMOR_SPEC)
+ __moyya=[None]*len(AMOR_SPEC)
+ __moyza=[None]*len(AMOR_SPEC)
+ for i in range(len(AMOR_SPEC)) :
+ amor = AMOR_SPEC[i]
+ __moyxa[i]=RECU_FONCTION(NAPPE = __moy_x[indexn],
+ VALE_PARA_FONC = AMOR_SPEC[i] )
+ __moyya[i]=RECU_FONCTION(NAPPE = __moy_y[indexn],
+ VALE_PARA_FONC = AMOR_SPEC[i] )
+ __moyza[i]=RECU_FONCTION(NAPPE = __moy_z[indexn],
+ VALE_PARA_FONC = AMOR_SPEC[i] )
+ motscles={}
+ dI = IMPRESSION[0].cree_dict_valeurs(IMPRESSION[0].mc_liste)
+ if dI.has_key('PILOTE') : motscles['PILOTE' ]=IMPRESSION['PILOTE']
+ if IMPRESSION['FORMAT']!='TABLEAU' : motscles['ECHELLE_X']='LOG'
+ if IMPRESSION['TRI']=='AMOR_SPEC' :
+ for i in range(len(AMOR_SPEC)) :
+ TITRE ='Spectres / Plancher = '+plancher+\
+ ' / amor='+str(AMOR_SPEC[i])+\
+ ' / noeud='+node
+ IMPR_FONCTION(
+ FORMAT=IMPRESSION['FORMAT'],
+ UNITE =IMPRESSION['UNITE' ],
+ COURBE=( _F(FONCTION=__moyxa[i], LEGENDE ='X',),
+ _F(FONCTION=__moyya[i], LEGENDE ='Y',),
+ _F(FONCTION=__moyza[i], LEGENDE ='Z',),),
+ TITRE =TITRE,
+ **motscles)
+ elif IMPRESSION['TRI']=='DIRECTION' :
+ lfonc=[]
+ for dd in ('X','Y','Z') :
+ TITRE ='Spectres / Plancher = '+plancher+\
+ ' / direction = '+dd+\
+ ' / noeud = '+node
+ if dd=='X' : l_fonc=[_F(FONCTION=__moyxa[i], LEGENDE ='amor='+str(AMOR_SPEC[i]),)\
+ for i in range(len(AMOR_SPEC)) ]
+ if dd=='Y' : l_fonc=[_F(FONCTION=__moyya[i], LEGENDE ='amor='+str(AMOR_SPEC[i]),)\
+ for i in range(len(AMOR_SPEC)) ]
+ if dd=='Z' : l_fonc=[_F(FONCTION=__moyza[i], LEGENDE ='amor='+str(AMOR_SPEC[i]),)\
+ for i in range(len(AMOR_SPEC)) ]
+ IMPR_FONCTION(
+ FORMAT=IMPRESSION['FORMAT'],
+ UNITE =IMPRESSION['UNITE' ],
+ COURBE=l_fonc,
+ TITRE =TITRE,
+ **motscles)
+
+ ### increment de l'indice de noeud
+ indexn=indexn+1
+
+ ### fin boucle 2 sur les noeuds du plancher
+ ############################################################
+
+ ############################################################
+ ### Calcul des enveloppes des spectres ou des deplacements max
+ if NOM_CHAM=='ACCE' :
+ mcslx=[]
+ mcsly=[]
+ mcslz=[]
+ indexn=0
+ for node in planch_nodes[plancher] :
+ mcslx.append(__moy_x[indexn])
+ mcsly.append(__moy_y[indexn])
+ mcslz.append(__moy_z[indexn])
+ indexn=indexn+1
+ __snx=CALC_FONCTION(ENVELOPPE=_F(FONCTION=mcslx))
+ __sny=CALC_FONCTION(ENVELOPPE=_F(FONCTION=mcsly))
+ __snz=CALC_FONCTION(ENVELOPPE=_F(FONCTION=mcslz))
+ __snh=CALC_FONCTION(ENVELOPPE=_F(FONCTION=(__snx,__sny)))
+ if NOM_CHAM=='DEPL' :
+ DRmX = max([dicDmax[(node,'X')] for node in planch_nodes[plancher]])
+ DRmY = max([dicDmax[(node,'Y')] for node in planch_nodes[plancher]])
+ DRmZ = max([dicDmax[(node,'Z')] for node in planch_nodes[plancher]])
+ DRmH = max([DRmX,DRmY])
+
+ ############################################################
+ ### Renseignement de la table finale des résultats
+ if NOM_CHAM=='ACCE' :
+ nbind=len(AMOR_SPEC)
+ for i in range(nbind) :
+ dico_glob['FREQ' ]=__snx.Valeurs()[1][i][0]
+ dico_glob['eX_%d_%s' % (i, plancher)]=__snx.Valeurs()[1][i][1]
+ dico_glob['eY_%d_%s' % (i, plancher)]=__sny.Valeurs()[1][i][1]
+ dico_glob['eZ_%d_%s' % (i, plancher)]=__snz.Valeurs()[1][i][1]
+ dico_glob['eH_%d_%s' % (i, plancher)]=__snh.Valeurs()[1][i][1]
+ elif NOM_CHAM=='DEPL' :
+ dico_glob['DX_max'].append(DRmX)
+ dico_glob['DY_max'].append(DRmY)
+ dico_glob['DZ_max'].append(DRmZ)
+ dico_glob['DH_max'].append(DRmH)
+
+ ############################################################
+ ### Impression des courbes
+ if NOM_CHAM=='ACCE' and IMPRESSION!=None :
+ motscles={}
+ dI = IMPRESSION[0].cree_dict_valeurs(IMPRESSION[0].mc_liste)
+ if dI.has_key('PILOTE') : motscles['PILOTE']=IMPRESSION['PILOTE']
+ if IMPRESSION['FORMAT']!='TABLEAU' : motscles['ECHELLE_X']='LOG'
+ __snxa=[None]*len(AMOR_SPEC)
+ __snya=[None]*len(AMOR_SPEC)
+ __snza=[None]*len(AMOR_SPEC)
+ __snha=[None]*len(AMOR_SPEC)
+ for i in range(nbind) :
+ __snxa[i]=RECU_FONCTION(NAPPE = __snx,
+ VALE_PARA_FONC = AMOR_SPEC[i], )
+ __snya[i]=RECU_FONCTION(NAPPE = __sny,
+ VALE_PARA_FONC = AMOR_SPEC[i], )
+ __snza[i]=RECU_FONCTION(NAPPE = __snz,
+ VALE_PARA_FONC = AMOR_SPEC[i], )
+ __snha[i]=RECU_FONCTION(NAPPE = __snh,
+ VALE_PARA_FONC = AMOR_SPEC[i], )
+ if IMPRESSION['TRI']=='AMOR_SPEC' :
+ for i in range(nbind) :
+ TITRE ='Spectres moyens / Plancher = '+plancher+' / amor='+str(AMOR_SPEC[i])
+ IMPR_FONCTION(
+ FORMAT=IMPRESSION['FORMAT'],
+ UNITE =IMPRESSION['UNITE' ],
+ COURBE=( _F(FONCTION=__snxa[i], LEGENDE ='X',),
+ _F(FONCTION=__snya[i], LEGENDE ='Y',),
+ _F(FONCTION=__snza[i], LEGENDE ='Z',),
+ _F(FONCTION=__snha[i], LEGENDE ='H',),),
+ TITRE =TITRE,
+ **motscles
+ )
+ elif IMPRESSION['TRI']=='DIRECTION' :
+ for dd in ('X','Y','Z','H'):
+ TITRE ='Spectres moyens / Plancher = '+plancher+' / direction = '+dd
+ l_fonc =[]
+ if dd=='X' : l_fonc=[_F(FONCTION=__snxa[i], LEGENDE ='amor='+str(AMOR_SPEC[i]),)\
+ for i in range(len(AMOR_SPEC)) ]
+ if dd=='Y' : l_fonc=[_F(FONCTION=__snya[i], LEGENDE ='amor='+str(AMOR_SPEC[i]),)\
+ for i in range(len(AMOR_SPEC)) ]
+ if dd=='Z' : l_fonc=[_F(FONCTION=__snza[i], LEGENDE ='amor='+str(AMOR_SPEC[i]),)\
+ for i in range(len(AMOR_SPEC)) ]
+ if dd=='H' : l_fonc=[_F(FONCTION=__snha[i], LEGENDE ='amor='+str(AMOR_SPEC[i]),)\
+ for i in range(len(AMOR_SPEC)) ]
+ IMPR_FONCTION(
+ FORMAT=IMPRESSION['FORMAT'],
+ UNITE =IMPRESSION['UNITE' ],
+ COURBE=l_fonc,
+ TITRE =TITRE,
+ **motscles
+ )
+
+ ### fin boucle 1 sur les planchers
+ ############################################################
+
+ ############################################################
+ ### Renseignement de la table finale des résultats
+ lListe=[]
+ if NOM_CHAM=='DEPL' :
+ lListe.append(_F(LISTE_K=l_plancher,PARA='PLANCHER'))
+ titre = 'Calcul des spectres enveloppes'
+ if NOM_CHAM=='ACCE' :
+ titre = ['Calcul des spectres enveloppes par planchers pour les amortissements numérotés :',]
+ b=[' %d : %g ' % (i,AMOR_SPEC[i]) for i in range(len(AMOR_SPEC)) ]
+ titre.append('/'.join(b))
+ lkeys=dico_glob.keys()
+ lkeys.sort()
+ for key in lkeys :
+ lListe.append(_F(LISTE_R=dico_glob[key],PARA=key))
+ tab = CREA_TABLE(LISTE=lListe,TITRE=titre)
+ return ier
-#@ MODIF macro_elas_mult_ops Macro DATE 05/09/2005 AUTEUR DURAND C.DURAND
+#@ MODIF macro_elas_mult_ops Macro DATE 07/11/2006 AUTEUR CIBHHLV L.VIVAN
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
CALC_ELEM(reuse=nomres,
RESULTAT=nomres,
MODELE=MODELE,
- NIVE_COUCHE=m['NIVE_COUCHE'],
- NUME_COUCHE=m['NUME_COUCHE'],
+ REPE_COQUE=_F(NIVE_COUCHE=m['NIVE_COUCHE'],
+ NUME_COUCHE=m['NUME_COUCHE'],),
OPTION=tuple(liste_el),
**motscles)
if nbno:
-#@ MODIF macro_matr_asse_ops Macro DATE 30/01/2006 AUTEUR DURAND C.DURAND
+#@ MODIF macro_matr_asse_ops Macro DATE 12/06/2006 AUTEUR CIBHHLV L.VIVAN
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
def macro_matr_asse_ops(self,MODELE,CHAM_MATER,CARA_ELEM,MATR_ASSE,
- SOLVEUR,NUME_DDL,CHARGE,INST,**args):
+ SOLVEUR,NUME_DDL,CHARGE,CHAR_CINE,INST,**args):
"""
Ecriture de la macro MACRO_MATR_ASSE
"""
motscles={'OPTION':option}
+ if option == 'RIGI_MECA_HYST':
+ if (not lrigel):
+ UTMESS('F', "MACRO_MATR_ASSE", "POUR CALCULER RIGI_MECA_HYST, IL FAUT AVOIR CALCULE RIGI_MECA AUPARAVANT (DANS LE MEME APPEL)")
+ motscles['RIGI_MECA'] =rigel
if option == 'AMOR_MECA':
if (not lrigel or not lmasel):
UTMESS('F', "MACRO_MATR_ASSE", "POUR CALCULER AMOR_MECA, IL FAUT AVOIR CALCULE RIGI_MECA ET MASS_MECA AUPARAVANT (DANS LE MEME APPEL)")
num=numeddl
self.DeclareOut('mm',m['MATRICE'])
- mm=ASSE_MATRICE(MATR_ELEM=_a,NUME_DDL=num)
+ motscles={'OPTION':option}
+ if CHAR_CINE != None:
+ mm=ASSE_MATRICE(MATR_ELEM=_a,NUME_DDL=num,CHAR_CINE=CHAR_CINE)
+ else:
+ mm=ASSE_MATRICE(MATR_ELEM=_a,NUME_DDL=num)
+
return ier
-#@ MODIF macro_miss_3d_ops Macro DATE 20/03/2006 AUTEUR ACBHHCD G.DEVESA
+#@ MODIF macro_miss_3d_ops Macro DATE 31/10/2006 AUTEUR ACBHHCD G.DEVESA
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
import aster
loc_fic=aster.repout()
- miss3d=loc_fic+'miss3d'
- #miss3d='/home/acbhhcd/MISS3D/V6.4/miss3d.csh'
+ tv = aster.__version__.split('.')
+ if len(tv) < 3:
+ tv.extend(['x']*(3-len(tv)))
+ elif len(tv) > 3:
+ tv = tv[:3]
+ vers = '%2s.%2s.%2s' % tuple(tv)
+ # if vers > ' 8. 3.11':
+ # miss3d='/aster/logiciels/MISS3D/NEW/miss3d.csh'
+ # else:
+ # miss3d=loc_fic+'miss3d'
+
+ miss3d=loc_fic+'miss3d'
+
+ if VERSION=='V1_2':
+ if PARAMETRE != None and PARAMETRE['TYPE']=='BINAIRE':
+ raise AsException("MACRO_MISS_3D/PARAMETRE : type incompatible avec version")
+
if OPTION['TOUT']!=None:
MODUL2='COMPLET'
elif OPTION['MODULE']=='MISS_IMPE':
prfor = 'fort.'+str(UNITE_RESU_FORC)
l_para = ['FREQ_MIN','FREQ_MAX','FREQ_PAS','Z0','RFIC','SURF',
- 'FICH_RESU_IMPE','FICH_RESU_FORC','DREF','ALGO',
+ 'FICH_RESU_IMPE','FICH_RESU_FORC','TYPE','DREF','ALGO',
'OFFSET_MAX','OFFSET_NB','SPEC_MAX','SPEC_NB','ISSF',
'FICH_POST_TRAI','CONTR_NB','CONTR_LISTE','LFREQ_NB',
'LFREQ_LISTE']
dpara = {}
for cle in l_para:
- if cle in ('SURF', 'ISSF'):
+ if cle in ('SURF', 'ISSF', ):
dpara[cle] = 'NON'
else:
dpara[cle] = '0'
if PARAMETRE != None and PARAMETRE[cle] != None:
if type(PARAMETRE[cle]) in (TupleType, ListType):
- dpara[cle] = ' '.join([str(s) for s in PARAMETRE[cle]])
+ dpara[cle] = repr(' '.join([str(s) for s in PARAMETRE[cle]]))
else:
dpara[cle] = str(PARAMETRE[cle])
EXEC_LOGICIEL(
LOGICIEL=miss3d,
- ARGUMENT=(_F(NOM_PARA=MODUL2),
- _F(NOM_PARA=ETUDE),
- _F(NOM_PARA=BASE),
- _F(NOM_PARA=paste),
- _F(NOM_PARA=popti),
- _F(NOM_PARA=pdsol),
- _F(NOM_PARA=primp),
- _F(NOM_PARA=VERSION),
- _F(NOM_PARA=dpara['FREQ_MIN']),
- _F(NOM_PARA=dpara['FREQ_MAX']),
- _F(NOM_PARA=dpara['FREQ_PAS']),
- _F(NOM_PARA=dpara['Z0']),
- _F(NOM_PARA=dpara['SURF']),
- _F(NOM_PARA=dpara['RFIC']),
- _F(NOM_PARA=dpara['FICH_RESU_IMPE']),
- _F(NOM_PARA=dpara['FICH_RESU_FORC']),
- _F(NOM_PARA=dpara['DREF']),
- _F(NOM_PARA=dpara['ALGO']),
- _F(NOM_PARA=dpara['OFFSET_MAX']),
- _F(NOM_PARA=dpara['OFFSET_NB']),
- _F(NOM_PARA=dpara['SPEC_MAX']),
- _F(NOM_PARA=dpara['SPEC_NB']),
- _F(NOM_PARA=dpara['ISSF']),
- _F(NOM_PARA=dpara['FICH_POST_TRAI']),
- _F(NOM_PARA=dpara['CONTR_NB']),
- _F(NOM_PARA=dpara['CONTR_LISTE']),
- _F(NOM_PARA=dpara['LFREQ_NB']),
- _F(NOM_PARA=dpara['LFREQ_LISTE']),
- _F(NOM_PARA=prfor),
+ ARGUMENT=(MODUL2,
+ ETUDE,
+ BASE,
+ paste,
+ popti,
+ pdsol,
+ primp,
+ VERSION,
+ dpara['FREQ_MIN'],
+ dpara['FREQ_MAX'],
+ dpara['FREQ_PAS'],
+ dpara['Z0'],
+ dpara['SURF'],
+ dpara['RFIC'],
+ dpara['FICH_RESU_IMPE'],
+ dpara['FICH_RESU_FORC'],
+ dpara['DREF'],
+ dpara['ALGO'],
+ dpara['OFFSET_MAX'],
+ dpara['OFFSET_NB'],
+ dpara['SPEC_MAX'],
+ dpara['SPEC_NB'],
+ dpara['ISSF'],
+ dpara['FICH_POST_TRAI'],
+ dpara['CONTR_NB'],
+ dpara['CONTR_LISTE'],
+ dpara['LFREQ_NB'],
+ dpara['LFREQ_LISTE'],
+ dpara['TYPE'],
+ prfor,
),
)
--- /dev/null
+#@ MODIF post_dyna_alea_ops Macro DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS
+# -*- coding: iso-8859-1 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+
+def post_dyna_alea_ops(self,INTE_SPEC,NUME_VITE_FLUI,TOUT_ORDRE,NUME_ORDRE_I,
+ NOEUD_I,OPTION,MOMENT,TITRE,INFO,**args):
+ import aster
+ from types import ListType, TupleType
+ EnumTypes = (ListType, TupleType)
+ from Accas import _F
+ from Utilitai.Utmess import UTMESS
+ from Utilitai.t_fonction import t_fonction
+ from Utilitai.Table import Table
+ import Numeric
+ import math
+ from math import pi,sqrt
+
+ commande='POST_DYNA_ALEA'
+
+ ier = 0
+ # La macro compte pour 1 dans la numerotation des commandes
+ self.set_icmd(1)
+
+ # Le concept sortant (de type table_sdaster ou dérivé) est tab
+ self.DeclareOut('tabout', self.sd)
+
+ # On importe les definitions des commandes a utiliser dans la macro
+ # Le nom de la variable doit etre obligatoirement le nom de la commande
+ CREA_TABLE = self.get_cmd('CREA_TABLE')
+ CALC_TABLE = self.get_cmd('CALC_TABLE')
+ IMPR_TABLE = self.get_cmd('IMPR_TABLE')
+ RECU_FONCTION = self.get_cmd('RECU_FONCTION')
+ IMPR_FONCTION = self.get_cmd('IMPR_FONCTION')
+
+ intespec=INTE_SPEC.EXTR_TABLE()
+
+# ------------------------------------------------------------------
+# Liste des moments spectraux
+# repérer le type de l'interspectre et son nom
+# 1- concept interspectre
+# 2- table de table d interspectre
+
+ if 'NUME_VITE_FLUI' in intespec.para :
+ if TOUT_ORDRE!=None :
+ jnuor=intespec['NUME_VITE_FLUI'].values()['NUME_VITE_FLUI']
+ jvite=dict([(i,0) for i in jnuor]).keys()
+ else :
+ jvite=[NUME_VITE_FLUI,]
+ else :
+ jvite =[None]
+
+# ------------------------------------------------------------------
+# Repérer les couples d'indices selectionnés
+# vérification de l'égalité du nombre d indices en i et j
+
+ if NUME_ORDRE_I!=None :
+ l_ind_i=NUME_ORDRE_I
+ l_ind_j=args['NUME_ORDRE_J']
+ if type(l_ind_i) not in EnumTypes : l_ind_i=[l_ind_i]
+ if type(l_ind_j) not in EnumTypes : l_ind_j=[l_ind_j]
+ if len(l_ind_i)!=len(l_ind_j) :
+ txt = "il faut autant d indices en I et J"
+ UTMESS('F',commande, txt)
+ listpara=['NUME_ORDRE_I','NUME_ORDRE_J']
+ listtype=['I','I']
+ dicotabl={'NUME_ORDRE_I' : l_ind_i ,\
+ 'NUME_ORDRE_J' : l_ind_j , }
+ elif NOEUD_I!=None :
+ l_ind_i=NOEUD_I
+ l_ind_j=args['NOEUD_J']
+ l_cmp_i=args['NOM_CMP_I']
+ l_cmp_j=args['NOM_CMP_J']
+ if type(l_cmp_i) not in EnumTypes : l_cmp_i=[l_cmp_i]
+ if type(l_cmp_j) not in EnumTypes : l_cmp_j=[l_cmp_j]
+ if type(l_ind_i) not in EnumTypes : l_ind_i=[l_ind_i]
+ if type(l_ind_j) not in EnumTypes : l_ind_j=[l_ind_j]
+ if len(l_ind_i)!=len(l_ind_j) :
+ txt = "il faut autant d indices en I et J"
+ UTMESS('F',commande, txt)
+ if len(l_cmp_i)!=len(l_cmp_j) :
+ txt = "il faut autant de composantes en I et J"
+ UTMESS('F',commande, txt)
+ if len(l_ind_i)!=len(l_cmp_i) :
+ txt = "il faut autant de composantes que de noeuds"
+ UTMESS('F',commande, txt)
+ listpara=['NOEUD_I','NOEUD_J','NOM_CMP_I','NOM_CMP_J']
+ listtype=['K8','K8','K8','K8',]
+ dicotabl={'NOEUD_I' : l_ind_i,\
+ 'NOEUD_J' : l_ind_j,\
+ 'NOM_CMP_I': l_cmp_i,\
+ 'NOM_CMP_J': l_cmp_j }
+# ------------------------------------------------------------------
+# Cas de tous les indices centraux
+
+ elif OPTION!=None :
+ if 'NUME_ORDRE_I' in intespec.para :
+ inuor=intespec['NUME_ORDRE_I'].values()['NUME_ORDRE_I']
+ imode=dict([(i,0) for i in inuor]).keys()
+ l_ind_i=imode
+ l_ind_j=imode
+ listpara=['NUME_ORDRE_I','NUME_ORDRE_J']
+ listtype=['I','I']
+ dicotabl={'NUME_ORDRE_I' : l_ind_i ,\
+ 'NUME_ORDRE_J' : l_ind_j , }
+ else :
+ if 'NUME_VITE_FLUI' in intespec.para :
+ intespec=intespec.NUME_VITE_FLUI==jvite[0]
+ l_ind_i=intespec['NOEUD_I'].values()['NOEUD_I']
+ l_ind_j=intespec['NOEUD_J'].values()['NOEUD_J']
+ if len(l_ind_i)!=len(l_ind_j) :
+ txt = "il faut autant d indices en I et J"
+ UTMESS('F',commande, txt)
+ l_cmp_i=intespec['NOM_CMP_I'].values()['NOM_CMP_I']
+ l_cmp_j=intespec['NOM_CMP_J'].values()['NOM_CMP_J']
+ if (len(l_ind_i)!=len(l_cmp_i) or len(l_ind_j)!=len(l_cmp_j)) :
+ txt = "il faut autant de composantes que de noeuds"
+ UTMESS('F',commande, txt)
+ l_l=zip(zip(l_ind_i,l_cmp_i),zip(l_ind_j,l_cmp_j))
+ l_ind_i=[]
+ l_ind_j=[]
+ l_cmp_i=[]
+ l_cmp_j=[]
+ for ai,aj in l_l :
+ if ai==aj :
+ l_ind_i.append(ai[0])
+ l_ind_j.append(aj[0])
+ l_cmp_i.append(ai[1])
+ l_cmp_j.append(aj[1])
+ listpara=['NOEUD_I','NOEUD_J','NOM_CMP_I','NOM_CMP_J']
+ listtype=['K8','K8','K8','K8',]
+ dicotabl={'NOEUD_I' : l_ind_i*len(jvite) ,\
+ 'NOEUD_J' : l_ind_j*len(jvite) ,\
+ 'NOM_CMP_I': l_cmp_i*len(jvite) ,\
+ 'NOM_CMP_J': l_cmp_j*len(jvite) }
+
+ if jvite[0]!=None :
+ listpara.append('NUME_VITE_FLUI')
+ listtype.append('I')
+ dicotabl['NUME_VITE_FLUI']=[]
+# ------------------------------------------------------------------
+# Liste des moments spectraux
+
+ l_moments=[0,1,2,3,4]
+ if MOMENT!=None :
+ l_moments=l_moments+list(MOMENT)
+ l_moments=dict([(i,0) for i in l_moments]).keys()
+
+# ------------------------------------------------------------------
+# Boucle sur les tables
+
+ l_ind=zip(l_ind_i,l_ind_j)
+ for vite in jvite :
+ if INFO==2 :
+ texte='POUR LA MATRICE INTERSPECTRALE '+INTE_SPEC.nom+'\n'
+ aster.affiche('MESSAGE',texte)
+ for ind in l_ind :
+ mcfact=[]
+ if vite!=None :
+ dicotabl['NUME_VITE_FLUI'].append(vite)
+ mcfact.append(_F(NOM_PARA='NUME_VITE_FLUI',VALE_I=vite))
+ if 'NOEUD_I' in listpara :
+ mcfact.append(_F(NOM_PARA='NOEUD_I',VALE_K=ind[0]))
+ mcfact.append(_F(NOM_PARA='NOEUD_I',VALE_K=ind[1]))
+ if INFO==2 :
+ aster.affiche('MESSAGE','INDICES :'+ind[0]+' - '+ind[1]+'\n')
+ else :
+ mcfact.append(_F(NOM_PARA='NUME_ORDRE_I',VALE_I=ind[0]))
+ mcfact.append(_F(NOM_PARA='NUME_ORDRE_J',VALE_I=ind[1]))
+ if INFO==2 :
+ aster.affiche('MESSAGE','INDICES :'+str(ind[0])+' - '\
+ +str(ind[1])+'\n')
+ __fon1=RECU_FONCTION(TABLE = INTE_SPEC,
+ NOM_PARA_TABL= 'FONCTION_C',
+ FILTRE = mcfact, )
+ val = __fon1.Valeurs()
+ fvalx= Numeric.array(val[0])
+ fvaly= Numeric.array(val[1])
+ frez = fvalx[0]
+
+#--- moments spectraux
+
+ val_mom={}
+ for i_mom in l_moments :
+ trapz = Numeric.zeros(len(fvaly),Numeric.Float)
+ trapz[0] = 0.
+ valy = fvaly*(2*pi*fvalx)**i_mom
+ trapz[1:] = (valy[1:]+valy[:-1])/2*(fvalx[1:]-fvalx[:-1])
+ prim_y = Numeric.cumsum(trapz)
+ val_mom[i_mom] = prim_y[-1]
+ for i_mom in l_moments :
+ chmo='LAMBDA_'+str(i_mom).zfill(2)
+ if dicotabl.has_key(chmo) : dicotabl[chmo].append(val_mom[i_mom])
+ else :
+ dicotabl[chmo]=[val_mom[i_mom],]
+ listpara.append(chmo)
+ listtype.append('R')
+
+#--- fonctions statistiques
+
+ pstat = {'ECART' :0.,\
+ 'NB_PASS_ZERO_P_S':0.,\
+ 'NB_EXTREMA_P_S' :0.,\
+ 'FACT_IRRE' :0.,\
+ 'FREQ_APPAR' :0.,}
+ if (NUME_VITE_FLUI or frez>=0.) :
+#--- cas NUME_VITE_FLUI, seule la partie positive du spectre est utilisée
+#--- Il faut donc doubler lambda pour calculer le bon écart type
+ pstat['ECART'] = sqrt(val_mom[0]*2.)
+ else :
+ pstat['ECART'] = sqrt(val_mom[0])
+ if abs(val_mom[2])>=1e-20 :
+ pstat['NB_EXTREMA_P_S'] = 1./pi*sqrt(val_mom[4]/val_mom[2])
+ if abs(val_mom[0])>=1e-20 :
+ pstat['NB_PASS_ZERO_P_S'] = 1./pi*sqrt(val_mom[2]/val_mom[0])
+ pstat['FREQ_APPAR'] = 0.5*pstat['NB_PASS_ZERO_P_S']
+ if abs(val_mom[4])>=1e-20 :
+ pstat['FACT_IRRE'] = sqrt( val_mom[2]*val_mom[2]/val_mom[0]/val_mom[4])
+
+ for key in pstat.keys():
+ if dicotabl.has_key(key) : dicotabl[key].append(pstat[key])
+ else :
+ dicotabl[key]=[pstat[key],]
+ listpara.append(key)
+ listtype.append('R')
+
+#--- construction de la table produite
+
+ mcfact=[]
+ for i in range(len(listpara)) :
+ if listtype[i]=='R':
+ mcfact.append(_F(PARA=listpara[i] ,LISTE_R=dicotabl[listpara[i]] ))
+ if listtype[i]=='K8':
+ mcfact.append(_F(PARA=listpara[i] ,LISTE_K=dicotabl[listpara[i]] ))
+ if listtype[i]=='I':
+ mcfact.append(_F(PARA=listpara[i] ,LISTE_I=dicotabl[listpara[i]] ))
+ tabout = CREA_TABLE(LISTE=mcfact,TITRE = 'POST_DYNA_ALEA concept : '+self.sd.nom)
+
+ return ier
--- /dev/null
+#@ MODIF post_gp_ops Macro DATE 31/10/2006 AUTEUR REZETTE C.REZETTE
+# -*- coding: iso-8859-1 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+
+from types import ListType, TupleType
+EnumTypes = (ListType, TupleType)
+from sets import Set
+
+# -----------------------------------------------------------------------------
+def post_gp_ops(self, **args):
+ """
+ Corps de la macro POST_GP
+ """
+ macro = 'POST_GP'
+ ier=0
+ from Accas import _F
+ from Utilitai.Utmess import UTMESS
+ from Utilitai.Table import Table, merge
+ from Utilitai.t_fonction import t_fonction
+ import aster
+
+ # ----- On importe les definitions des commandes a utiliser dans la macro
+ CALC_THETA = self.get_cmd('CALC_THETA')
+ CALC_G = self.get_cmd('CALC_G')
+ POST_ELEM = self.get_cmd('POST_ELEM')
+ POST_RELEVE_T = self.get_cmd('POST_RELEVE_T')
+ CREA_TABLE = self.get_cmd('CREA_TABLE')
+
+ # ----- Comptage, commandes + déclaration concept sortant
+ self.set_icmd(1)
+ self.DeclareOut('result', self.sd)
+ self.DeclareOut('tabresult', self['TABL_RESU'])
+ info = self['INFO']
+
+ # 0. ----- Type de calcul
+ identification = self['IDENTIFICATION'] != None
+ if identification:
+ # 0.1. --- identification : on boule sur les valeurs de TEMP.
+ # Pour chaque couple (T, Kjc(T)), on évalue les Ki, Kmoy et
+ # les valeurs de Gpmax, DeltaLmax, inst.max correspondantes.
+ mccalc = self['IDENTIFICATION']
+ l_crit = mccalc['KJ_CRIT']
+ lv_ident = []
+ l_temp = mccalc['TEMP']
+ else:
+ # 0.2. --- prédiction : on ne fait qu'une itération.
+ # Il faut un RESU_THER (sinon on utilise la température du
+ # premier Gpcrit et cà n'a pas trop d'intéret).
+ # A chaque instant, on regarde à quelle température est le
+ # fond d'entaille et on compare Gpmax à cet instant au Gpcrit.
+ mccalc = self['PREDICTION']
+ l_crit = mccalc['GP_CRIT']
+ lv_pred = []
+ l_temp = mccalc['TEMP'][0]
+
+ if not type(l_temp) in EnumTypes:
+ l_temp = [l_temp,]
+ if not type(l_crit) in EnumTypes:
+ l_crit = [l_crit,]
+
+ # 1. ----- calcul de G-theta
+ nbcour = len(self['THETA_2D'])
+ l_tab = []
+ for occ in self['THETA_2D']:
+ dMC = occ.cree_dict_valeurs(occ.mc_liste)
+
+ __theta = CALC_THETA(MODELE=self['MODELE'],
+ DIRECTION=self['DIRECTION'],
+ THETA_2D=_F(GROUP_NO=dMC['GROUP_NO'],
+ MODULE=1.0,
+ R_INF=dMC['R_INF'],
+ R_SUP=dMC['R_SUP']),)
+
+ __gtheta = CALC_G(THETA=_F(THETA=__theta),
+ EXCIT=self['EXCIT'].List_F(),
+ RESULTAT=self['RESULTAT'],
+ TOUT_ORDRE='OUI',
+ SYME_CHAR=self['SYME_CHAR'],
+ COMP_ELAS=self['COMP_ELAS'].List_F(),)
+
+ tab = __gtheta.EXTR_TABLE()
+
+ # une Table par couronne
+ l_tab.append(tab)
+
+ # 2. ----- Calcul de l'energie élastique en exploitant les groupes de
+ # mailles fournis par la procedure de maillage
+ l_copo = [grma.strip() for grma in self['GROUP_MA']]
+ nbcop = len(l_copo)
+ l_charg = [charg['CHARGE'] for charg in self['EXCIT']]
+
+ __ener = POST_ELEM(MODELE=self['MODELE'],
+ RESULTAT=self['RESULTAT'],
+ CHARGE=l_charg,
+ TOUT_ORDRE='OUI',
+ ENER_ELAS=_F(GROUP_MA=l_copo),
+ TITRE='Energie élastique',)
+
+ t_enel = __ener.EXTR_TABLE()
+
+ # 2.1. ----- Indice de chaque copeau et deltaL
+ d_icop = dict(zip(l_copo, range(1, nbcop + 1)))
+
+ l_lieu = [grma.strip() for grma in t_enel.LIEU.values()]
+ l_icop = [d_icop[grma] for grma in l_lieu]
+ t_enel['ICOP'] = l_icop
+ t_enel.fromfunction('DELTAL', fDL, 'ICOP', { 'pascop' : self['PAS_ENTAILLE'] })
+
+ # 2.2. ----- Calcul de Gp fonction de Ener.Totale et de deltaL
+ t_enel.fromfunction('GP', fGp_Etot, ('TOTALE', 'ICOP'),
+ { 'pascop' : self['PAS_ENTAILLE'],
+ 'syme' : self['SYME_CHAR'] != 'SANS',
+ 'R' : self['RAYON_AXIS'] })
+
+ # 2.3. ----- Tableau de Gp = f(icop) pour chaque instant
+ if info >= 2:
+ tGp_t_icop = t_enel['INST', 'DELTAL', 'GP']
+ tGp_t_icop.titr = "Gp à chaque instant en fonction de la distance au " \
+ "fond d'entaille"
+ tGp_t_icop.ImprTabCroise()
+
+ # 2.4. ----- Table Gpmax
+ ttmp = t_enel['NUME_ORDRE', 'INST', 'ICOP', 'DELTAL', 'GP']
+ l_numord = list(Set(ttmp.NUME_ORDRE.values()))
+ l_numord.sort()
+ for j in l_numord:
+ tj = ttmp.NUME_ORDRE == j
+ if self['CRIT_MAXI_GP'] == 'ABSOLU':
+ t = tj.GP.MAXI()
+ else:
+ t = MaxRelatif(tj, 'GP')
+ if j == 1:
+ tb_Gpmax = t
+ else:
+ tb_Gpmax = tb_Gpmax | t
+ tb_Gpmax.Renomme('GP', 'GPMAX')
+ tb_Gpmax.Renomme('ICOP', 'ICOPMAX')
+ tb_Gpmax.Renomme('DELTAL', 'DELTALMAX')
+ tb_Gpmax.titr = 'Gpmax à chaque instant'
+ if info >= 2:
+ print tb_Gpmax
+
+ # 2.5. ----- extraction de la température en fond d'entaille
+ if self['RESU_THER']:
+ grno_fond = self['THETA_2D'][0]['GROUP_NO']
+ __relev = POST_RELEVE_T(ACTION=_F(RESULTAT=self['RESU_THER'],
+ OPERATION='EXTRACTION',
+ INTITULE='Temperature',
+ NOM_CHAM='TEMP',
+ TOUT_ORDRE='OUI',
+ NOM_CMP='TEMP',
+ GROUP_NO=grno_fond,),)
+ t_relev = __relev.EXTR_TABLE()['NUME_ORDRE', 'TEMP']
+
+
+ # 3. ----- boucle sur les mots-clés facteurs
+ # opérations dépendant de la température
+ MATER = self['MATER']
+ flag_mat = True
+
+ for iocc, TEMP in enumerate(l_temp):
+ # 3.0. ----- Temperature fonction du temps : si on n'a pas de RESU_THER,
+ # on prend la température d'identification.
+ if not self['RESU_THER']:
+ l_rows = [{'NUME_ORDRE' : i, 'TEMP' : TEMP} for i in l_numord]
+ t_relev = Table(rows=l_rows, para=('NUME_ORDRE', 'TEMP'), typ=('R', 'R'))
+ flag_mat = True
+
+ # 3.1. ----- extrait du matériau E(TEMP) et NU(TEMP) (si nécessaire)
+ if flag_mat:
+ t_relev.fromfunction('YOUNG', CallRCVALE, 'TEMP',
+ { 'para' : 'E', 'MATER' : MATER })
+ t_relev.fromfunction('NU', CallRCVALE, 'TEMP',
+ { 'para' : 'NU', 'MATER' : MATER })
+ #tb_Gpmax = merge(tb_Gpmax, t_relev, 'NUME_ORDRE')
+ flag_mat = False
+
+ # 3.2. ----- paramètres
+ dict_constantes = {
+ 'YOUNG' : CallRCVALE(TEMP, 'E', MATER),
+ 'NU' : CallRCVALE(TEMP, 'NU', MATER),
+ 'R' : self['RAYON_AXIS'],
+ }
+
+ # 3.3. ----- calcul de Kj(G)
+ l_tabi = []
+ for k, tab in enumerate(l_tab):
+ # fusion avec TEMP, E et nu.
+ tab = merge(tab, t_relev, 'NUME_ORDRE')
+
+ # calcul de Kj(G) = K_i
+ new_para = 'K_%d' % (k + 1)
+ tab.fromfunction(new_para, fKj, ('G', 'YOUNG', 'NU'),
+ { 'R' : self['RAYON_AXIS'] })
+
+ # renomme G en G_i
+ tab.Renomme('G', 'G_%d' % (k + 1))
+ l_tabi.append(tab)
+
+ # 3.4 ----- Table des Gi, Ki sur les differentes couronnes + Kmoyen
+ tabK_G = l_tabi[0]['NUME_ORDRE']
+ for tab in l_tabi:
+ tabK_G = merge(tabK_G, tab, 'NUME_ORDRE')
+ tabK_G.titr = 'G et K sur les differentes couronnes + moyennes'
+ tabK_G.fromfunction('GMOY', moyenne, ['G_%d' % (k + 1) for k in range(nbcour)])
+ tabK_G.fromfunction('KMOY', moyenne, ['K_%d' % (k + 1) for k in range(nbcour)])
+
+ # 3.5. ----- Contribution à la table globale
+ tabres = merge(tabK_G, tb_Gpmax, 'NUME_ORDRE')
+ tabres['OCCURRENCE'] = [iocc + 1] * len(l_numord)
+ if info >= 2:
+ print tabres
+
+ # 3.5.1. --- Table globale
+ if iocc == 0:
+ tabl_glob = tabres
+ else:
+ tabl_glob = merge(tabl_glob, tabres)
+ tabl_glob.titr = 'G, K sur les differentes couronnes, Gmoy, Kmoy et ' \
+ 'Gpmax fonctions du temps'
+
+ # 3.6. ----- traitement selon identification / prédiction
+ d_para = {
+ 'INTERPOL' : ['LIN', 'LIN'],
+ 'NOM_PARA' : 'INST',
+ 'PROL_DROITE' : 'CONSTANT',
+ 'PROL_GAUCHE' : 'CONSTANT',
+ }
+ # Gpmax fonction du temps
+ d_para.update({ 'NOM_RESU' : 'GPMAX' })
+ fGp = t_fonction(tabres.INST.values(), tabres.GPMAX.values(), d_para)
+
+ # 3.6.1. --- identification
+ if identification:
+ KJ_CRIT = l_crit[iocc]
+ # définition des fonctions pour faire les interpolations
+ d_para.update({ 'NOM_RESU' : 'DELTALMAX' })
+ fdL = t_fonction(tabres.INST.values(), tabres.DELTALMAX.values(), d_para)
+
+ d_para.update({ 'NOM_PARA' : 'KMOY',
+ 'NOM_RESU' : 'INST', })
+ valkmoy = tabres.KMOY.values()
+ finv = t_fonction(valkmoy, tabres.INST.values(), d_para)
+
+ if not (min(valkmoy) <= KJ_CRIT <= max(valkmoy)):
+ UTMESS('A', macro, 'Interpolation hors du domaine (prolongement ' \
+ 'constant utilisé).')
+ # valeurs à mettre dans la table
+ ti = finv(KJ_CRIT)
+ Gpi = fGp(ti)
+ d_ident = {
+ 'KJ_CRIT' : KJ_CRIT,
+ 'INST' : ti,
+ 'GPMAX' : Gpi,
+ 'KGPMAX' : fKj(Gpi, **dict_constantes),
+ 'DELTALMAX' : fdL(ti),
+ }
+ lv_ident.append(d_ident)
+
+ # 3.6.2. --- prédiction
+ else:
+ pass
+
+ # 4. ----- Construction de la table résultat si demandée
+ # 4.1. --- identification
+ if identification:
+ tab_ident = Table(rows=lv_ident,
+ para=('KJ_CRIT', 'INST', 'GPMAX', 'KGPMAX', 'DELTALMAX'),
+ typ= ('R', 'R', 'R', 'R', 'R'),
+ titr='Identification aux valeurs de tenacités critiques')
+ dprod_result = tab_ident.dict_CREA_TABLE()
+ if info >= 2:
+ print tab_ident
+
+ # 4.2. --- prédiction
+ else:
+ # définition de la fonction GPcrit = f(TEMP)
+ d_para.update({ 'NOM_PARA' : 'TEMP',
+ 'NOM_RESU' : 'GP_CRIT', })
+ fGpc = t_fonction(mccalc['TEMP'], mccalc['GP_CRIT'], d_para)
+
+ tab_pred = tabl_glob['NUME_ORDRE', 'INST', 'TEMP', 'DELTALMAX', 'GPMAX']
+ tab_pred.fromfunction('GP_CRIT', fGpc, 'TEMP')
+ tab_pred.fromfunction('PREDICTION', crit, ('GP_CRIT', 'GPMAX'))
+ tab_pred.titr = 'Comparaison Gpmax à Gpcrit(T)'
+ dprod_result = tab_pred.dict_CREA_TABLE()
+
+ # 9. ----- création de la table_sdaster résultat
+ dprod = tabl_glob.dict_CREA_TABLE()
+ result = CREA_TABLE(**dprod)
+ tabresult = CREA_TABLE(**dprod_result)
+
+
+
+# -----------------------------------------------------------------------------
+def CallRCVALE(TEMP, para, MATER):
+ """Fonction appelant RCVALE et retourne la valeur d'un paramètre.
+ """
+ valres, flag_ok = MATER.RCVALE('ELAS', 'TEMP', TEMP, para)
+ assert list(flag_ok).count('OK') != 1, \
+ 'Erreur lors de la récupération des valeurs du matériau.'
+ return valres
+
+# -----------------------------------------------------------------------------
+def fKj(G, YOUNG, NU, R):
+ """Calcul de Kj à partir de G (formule d'Irwin)
+ """
+ return (G / R * YOUNG / (1.0 - NU**2))**0.5
+
+# -----------------------------------------------------------------------------
+def fDL(ICOP, pascop):
+ """DeltaL = numéro copeau * pas d'entaille
+ """
+ return ICOP * pascop
+
+# -----------------------------------------------------------------------------
+def fGp_Etot(TOTALE, ICOP, pascop, R, syme=False):
+ """Gp(Etotale, K), deltal pris dans le context global.
+ ICOP : numéro du copeau,
+ pascop : pas d'entaille.
+ syme : True s'il y a symétrie.
+ """
+ fact_axis = 1.
+ if syme:
+ fact_axis = 2.
+ return fact_axis * TOTALE / (fDL(ICOP, pascop) * R)
+
+# -----------------------------------------------------------------------------
+def MaxRelatif(table, nom_para):
+ """Extrait le dernier maxi du champ `nom_para` de la table.
+ """
+ l_val = getattr(table, nom_para).values()
+ l_val.reverse()
+ Vlast = l_val[0]
+ for val in l_val:
+ if val < Vlast:
+ break
+ Vlast = val
+ return getattr(table, nom_para) == Vlast
+
+# -----------------------------------------------------------------------------
+def crit(GP_CRIT, GPMAX):
+ """Retourne 1 quand GP_CRIT > GPMAX
+ """
+ if GPMAX > GP_CRIT:
+ return 1
+ else:
+ return 0
+
+# -----------------------------------------------------------------------------
+def moyenne(*args):
+ """Fonction moyenne
+ """
+ return sum(args)/len(args)
+
-#@ MODIF post_k1_k2_k3_ops Macro DATE 22/05/2006 AUTEUR REZETTE C.REZETTE
+#@ MODIF post_k1_k2_k3_ops Macro DATE 06/11/2006 AUTEUR GALENNE E.GALENNE
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
cross[1] = a[2]*b[0]-a[0]*b[2]
cross[2] = a[0]*b[1]-a[1]*b[0]
return cross
-
+
+def moy(t):
+ m = 0
+ for value in t :
+ m += value
+ return (m/len(t))
+
def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,MATER,RESULTAT,
TABL_DEPL_SUP,TABL_DEPL_INF,ABSC_CURV_MAXI,PREC_VIS_A_VIS,
TOUT_ORDRE,NUME_ORDRE,LIST_ORDRE,INST,LIST_INST,SYME_CHAR,
# Le nom de la variable doit etre obligatoirement le nom de la commande
CREA_TABLE = self.get_cmd('CREA_TABLE')
CALC_TABLE = self.get_cmd('CALC_TABLE')
- IMPR_TABLE = self.get_cmd('IMPR_TABLE')
POST_RELEVE_T = self.get_cmd('POST_RELEVE_T')
DETRUIRE = self.get_cmd('DETRUIRE')
+ DEFI_GROUP = self.get_cmd('DEFI_GROUP')
MACR_LIGN_COUPE = self.get_cmd('MACR_LIGN_COUPE')
# ------------------------------------------------------------------
if LNOFO==None :
RECOL = True
LNOFO = aster.getvectjev(string.ljust(FOND_FISS.nom,8)+'.FOND_INF .NOEU ')
- if LNOFO==None : UTMESS('F', macro, 'PROBLEME A LA RECUPERATION DES NOEUDS DU FOND DE FISSURE')
+ if LNOFO==None : UTMESS('F', macro, 'PROBLEME A LA RECUPERATION DES NOEUDS DU FOND DE FISSURE \n')
LNOFO = map(string.rstrip,LNOFO)
Nbfond = len(LNOFO)
+ if MODELISATION=='3D' :
# ----------Mots cles TOUT, NOEUD, SANS_NOEUD -------------
- Typ = aster.getvectjev(string.ljust(FOND_FISS.nom,8)+'.FOND .TYPE ')
- if (Typ[0]=='SEG2 ') or (Typ[0]=='SEG3 ' and TOUT=='OUI') :
- pas = 1
- elif (Typ[0]=='SEG3 ') :
- pas = 2
- else :
- UTMESS('F', macro, 'TYPE DE MAILLES DU FOND DE FISSURE NON DEFINI')
+ Typ = aster.getvectjev(string.ljust(FOND_FISS.nom,8)+'.FOND .TYPE ')
+ if (Typ[0]=='SEG2 ') or (Typ[0]=='SEG3 ' and TOUT=='OUI') :
+ pas = 1
+ elif (Typ[0]=='SEG3 ') :
+ pas = 2
+ else :
+ UTMESS('F', macro, 'TYPE DE MAILLES DU FOND DE FISSURE NON DEFINI')
####
- NO_SANS = []
- NO_AVEC = []
- if GROUP_NO!=None :
- collgrno=aster.getcolljev(string.ljust(MAILLAGE.nom,8)+'.GROUPENO')
- cnom = aster.getvectjev(string.ljust(MAILLAGE.nom,8)+'.NOMNOE')
- if type(GROUP_NO) not in EnumTypes : GROUP_NO = (GROUP_NO,)
- for m in range(len(GROUP_NO)) :
- ngrno=GROUP_NO[m].ljust(8).upper()
- if ngrno not in collgrno.keys() :
- UTMESS('F', macro, "LE GROUP_NO "+ngrno+" N EST PAS DANS LE MAILLAGE")
- for i in range(len(collgrno[ngrno])) : NO_AVEC.append(cnom[collgrno[ngrno][i]-1])
- NO_AVEC= map(string.rstrip,NO_AVEC)
- if NOEUD!=None :
- if type(NOEUD) not in EnumTypes : NO_AVEC = (NOEUD,)
- else : NO_AVEC = NOEUD
- if SANS_GROUP_NO!=None :
- collgrno=aster.getcolljev(string.ljust(MAILLAGE.nom,8)+'.GROUPENO')
- cnom = aster.getvectjev(string.ljust(MAILLAGE.nom,8)+'.NOMNOE')
- if type(SANS_GROUP_NO) not in EnumTypes : SANS_GROUP_NO = (SANS_GROUP_NO,)
- for m in range(len(SANS_GROUP_NO)) :
- ngrno=SANS_GROUP_NO[m].ljust(8).upper()
- if ngrno not in collgrno.keys() :
- UTMESS('F', macro, "LE GROUP_NO "+ngrno+" N EST PAS DANS LE MAILLAGE")
- for i in range(len(collgrno[ngrno])) : NO_SANS.append(cnom[collgrno[ngrno][i]-1])
- NO_SANS= map(string.rstrip,NO_SANS)
- if SANS_NOEUD!=None :
- if type(SANS_NOEUD) not in EnumTypes : NO_SANS = (SANS_NOEUD,)
- else : NO_SANS = SANS_NOEUD
+ NO_SANS = []
+ NO_AVEC = []
+ if GROUP_NO!=None :
+ collgrno=aster.getcolljev(string.ljust(MAILLAGE.nom,8)+'.GROUPENO')
+ cnom = aster.getvectjev(string.ljust(MAILLAGE.nom,8)+'.NOMNOE')
+ if type(GROUP_NO) not in EnumTypes : GROUP_NO = (GROUP_NO,)
+ for m in range(len(GROUP_NO)) :
+ ngrno=GROUP_NO[m].ljust(8).upper()
+ if ngrno not in collgrno.keys() :
+ UTMESS('F', macro, "LE GROUP_NO "+ngrno+" N EST PAS DANS LE MAILLAGE")
+ for i in range(len(collgrno[ngrno])) : NO_AVEC.append(cnom[collgrno[ngrno][i]-1])
+ NO_AVEC= map(string.rstrip,NO_AVEC)
+ if NOEUD!=None :
+ if type(NOEUD) not in EnumTypes : NO_AVEC = (NOEUD,)
+ else : NO_AVEC = NOEUD
+ if SANS_GROUP_NO!=None :
+ collgrno=aster.getcolljev(string.ljust(MAILLAGE.nom,8)+'.GROUPENO')
+ cnom = aster.getvectjev(string.ljust(MAILLAGE.nom,8)+'.NOMNOE')
+ if type(SANS_GROUP_NO) not in EnumTypes : SANS_GROUP_NO = (SANS_GROUP_NO,)
+ for m in range(len(SANS_GROUP_NO)) :
+ ngrno=SANS_GROUP_NO[m].ljust(8).upper()
+ if ngrno not in collgrno.keys() :
+ UTMESS('F', macro, "LE GROUP_NO "+ngrno+" N EST PAS DANS LE MAILLAGE")
+ for i in range(len(collgrno[ngrno])) : NO_SANS.append(cnom[collgrno[ngrno][i]-1])
+ NO_SANS= map(string.rstrip,NO_SANS)
+ if SANS_NOEUD!=None :
+ if type(SANS_NOEUD) not in EnumTypes : NO_SANS = (SANS_NOEUD,)
+ else : NO_SANS = SANS_NOEUD
# Creation de la liste des noeuds du fond a traiter : Lnf1
- Lnf1 = []
- Nbf1 = 0
- if len(NO_AVEC)!=0 :
- for i in range(len(NO_AVEC)) :
- if NO_AVEC[i] in LNOFO :
- Lnf1.append(NO_AVEC[i])
- Nbf1 = Nbf1 +1
- else :
- UTMESS('F', macro, 'LE NOEUD %s N APPARTIENT PAS AU FOND DE FISSURE'%NO_AVEC[i])
+ Lnf1 = []
+ Nbf1 = 0
+ if len(NO_AVEC)!=0 :
+ for i in range(len(NO_AVEC)) :
+ if NO_AVEC[i] in LNOFO :
+ Lnf1.append(NO_AVEC[i])
+ Nbf1 = Nbf1 +1
+ else :
+ UTMESS('F', macro, 'LE NOEUD %s N APPARTIENT PAS AU FOND DE FISSURE'%NO_AVEC[i])
+ else :
+ for i in range(0,Nbfond,pas) :
+ if not (LNOFO[i] in NO_SANS) :
+ Lnf1.append(LNOFO[i])
+ Nbf1 = Nbf1 +1
else :
- for i in range(0,Nbfond,pas) :
- if not (LNOFO[i] in NO_SANS) :
- Lnf1.append(LNOFO[i])
- Nbf1 = Nbf1 +1
-
+ Lnf1 = LNOFO
+ Nbf1 = 1
+
##### Cas maillage libre###########
# creation des directions normales et macr_lign_coup
if TYPE_MAILLAGE =='LIBRE':
nbt = len(tcoorf['NOEUD'].values()['NOEUD'])
xs=array(tcoorf['COOR_X'].values()['COOR_X'][:nbt],Float)
ys=array(tcoorf['COOR_Y'].values()['COOR_Y'][:nbt],Float)
- if ndim==2 : zs=Numeric.zeros(nbval,Float)
+ if ndim==2 : zs=Numeric.zeros(nbt,Float)
elif ndim==3 : zs=array(tcoorf['COOR_Z'].values()['COOR_Z'][:nbt],Float)
ns = tcoorf['NOEUD'].values()['NOEUD'][:nbt]
ns = map(string.rstrip,ns)
l_coorf = [[ns[i],xs[i],ys[i],zs[i]] for i in range(0,nbt)]
l_coorf = [(i[0],i[1:]) for i in l_coorf]
d_coorf = dict(l_coorf)
+# Coordonnee d un pt quelconque des levres pr determination sens de propagation
+ cmail=aster.getvectjev(string.ljust(MAILLAGE.nom,8)+'.NOMMAI')
+ for i in range(len(cmail)) :
+ if cmail[i] == ListmaS[0] : break
+ colcnx=aster.getcolljev(string.ljust(MAILLAGE.nom,8)+'.CONNEX')
+ cnom = aster.getvectjev(string.ljust(MAILLAGE.nom,8)+'.NOMNOE')
+ NO_TMP = []
+ for k in range(len(colcnx[i+1])) : NO_TMP.append(cnom[colcnx[i+1][k]-1])
+ __NCOLEV=POST_RELEVE_T(ACTION=_F(INTITULE='Tab pour coordonnees pt levre',
+ NOEUD = NO_TMP,
+ RESULTAT=RESULTAT,
+ NOM_CHAM='DEPL',NUME_ORDRE=1,NOM_CMP=('DX',),
+ OPERATION='EXTRACTION',),);
+ tcoorl=__NCOLEV.EXTR_TABLE()
+ DETRUIRE(CONCEPT=_F(NOM=__NCOLEV),INFO=1)
+ nbt = len(tcoorl['NOEUD'].values()['NOEUD'])
+ xl=moy(tcoorl['COOR_X'].values()['COOR_X'][:nbt])
+ yl=moy(tcoorl['COOR_Y'].values()['COOR_Y'][:nbt])
+ zl=moy(tcoorl['COOR_Z'].values()['COOR_Z'][:nbt])
+ Plev = array([xl, yl, zl])
# Calcul des normales a chaque noeud du fond
v1 = array(VECT_K1)
VN = [None]*Nbfond
absfon = [0,]
- DTANOR = aster.getvectjev(string.ljust(FOND_FISS.nom,8)+'.DTAN_ORIGINE')
- if DTANOR != None :
- VN[0] = array(DTANOR)
- else :
+ if MODELISATION=='3D' :
+ DTANOR = aster.getvectjev(string.ljust(FOND_FISS.nom,8)+'.DTAN_ORIGINE')
Pfon2 = array([d_coorf[LNOFO[0]][0],d_coorf[LNOFO[0]][1],d_coorf[LNOFO[0]][2]])
- Pfon3 = array([d_coorf[LNOFO[1]][0],d_coorf[LNOFO[1]][1],d_coorf[LNOFO[1]][2]])
- VT = (Pfon3 - Pfon2)/sqrt(dot(transpose(Pfon3-Pfon2),Pfon3-Pfon2))
- VN[i] = array(cross_product(VT,v1))
- for i in range(1,Nbfond-1):
+ VLori = Pfon2 - Plev
+ if DTANOR != None :
+ VN[0] = array(DTANOR)
+ else :
+ Pfon3 = array([d_coorf[LNOFO[1]][0],d_coorf[LNOFO[1]][1],d_coorf[LNOFO[1]][2]])
+ VT = (Pfon3 - Pfon2)/sqrt(dot(transpose(Pfon3-Pfon2),Pfon3-Pfon2))
+ VN[0] = array(cross_product(VT,v1))
+ for i in range(1,Nbfond-1):
+ Pfon1 = array([d_coorf[LNOFO[i-1]][0],d_coorf[LNOFO[i-1]][1],d_coorf[LNOFO[i-1]][2]])
+ Pfon2 = array([d_coorf[LNOFO[i]][0],d_coorf[LNOFO[i]][1],d_coorf[LNOFO[i]][2]])
+ Pfon3 = array([d_coorf[LNOFO[i+1]][0],d_coorf[LNOFO[i+1]][1],d_coorf[LNOFO[i+1]][2]])
+ absf = sqrt(dot(transpose(Pfon1-Pfon2),Pfon1-Pfon2)) + absfon[i-1]
+ absfon.append(absf)
+ VT = (Pfon3 - Pfon2)/sqrt(dot(transpose(Pfon3-Pfon2),Pfon3-Pfon2))
+ VT = VT+(Pfon2 - Pfon1)/sqrt(dot(transpose(Pfon2-Pfon1),Pfon2-Pfon1))
+ VN[i] = array(cross_product(VT,v1))
+ VN[i] = VN[i]/sqrt(dot(transpose(VN[i]),VN[i]))
+ i = Nbfond-1
Pfon1 = array([d_coorf[LNOFO[i-1]][0],d_coorf[LNOFO[i-1]][1],d_coorf[LNOFO[i-1]][2]])
Pfon2 = array([d_coorf[LNOFO[i]][0],d_coorf[LNOFO[i]][1],d_coorf[LNOFO[i]][2]])
- Pfon3 = array([d_coorf[LNOFO[i+1]][0],d_coorf[LNOFO[i+1]][1],d_coorf[LNOFO[i+1]][2]])
+ VLextr = Pfon2 - Plev
absf = sqrt(dot(transpose(Pfon1-Pfon2),Pfon1-Pfon2)) + absfon[i-1]
absfon.append(absf)
- VT = (Pfon3 - Pfon2)/sqrt(dot(transpose(Pfon3-Pfon2),Pfon3-Pfon2))
- VT = VT+(Pfon2 - Pfon1)/sqrt(dot(transpose(Pfon2-Pfon1),Pfon2-Pfon1))
- VN[i] = array(cross_product(VT,v1))
- VN[i] = VN[i]/sqrt(dot(transpose(VN[i]),VN[i]))
- i = Nbfond-1
- Pfon1 = array([d_coorf[LNOFO[i-1]][0],d_coorf[LNOFO[i-1]][1],d_coorf[LNOFO[i-1]][2]])
- Pfon2 = array([d_coorf[LNOFO[i]][0],d_coorf[LNOFO[i]][1],d_coorf[LNOFO[i]][2]])
- absf = sqrt(dot(transpose(Pfon1-Pfon2),Pfon1-Pfon2)) + absfon[i-1]
- absfon.append(absf)
- DTANEX = aster.getvectjev(string.ljust(FOND_FISS.nom,8)+'.DTAN_EXTREMITE')
- if DTANEX != None :
- VN[i] = array(DTANEX)
- else :
- VT = (Pfon2 - Pfon1)/sqrt(dot(transpose(Pfon2-Pfon1),Pfon2-Pfon1))
- VN[i] = array(cross_product(VT,v1))
- dicoF = dict([(LNOFO[i],absfon[i]) for i in range(Nbfond)])
- dicVN = dict([(LNOFO[i],VN[i]) for i in range(Nbfond)])
+ DTANEX = aster.getvectjev(string.ljust(FOND_FISS.nom,8)+'.DTAN_EXTREMITE')
+ if DTANEX != None :
+ VN[i] = array(DTANEX)
+ else :
+ VT = (Pfon2 - Pfon1)/sqrt(dot(transpose(Pfon2-Pfon1),Pfon2-Pfon1))
+ VN[i] = array(cross_product(VT,v1))
+ dicoF = dict([(LNOFO[i],absfon[i]) for i in range(Nbfond)])
+ dicVN = dict([(LNOFO[i],VN[i]) for i in range(Nbfond)])
+#Sens de la tangente
+ v = cross_product(VLori,VLextr)
+ sens = sign(dot(transpose(v),v1))
+#Cas 2D
+ if MODELISATION!='3D' :
+ DTANOR = False
+ DTANEX = False
+ VT = array([0.,0.,1.])
+ VN = array(cross_product(v1,VT))
+ dicVN = dict([(LNOFO[0],VN)])
+ Pfon = array([d_coorf[LNOFO[0]][0],d_coorf[LNOFO[0]][1],d_coorf[LNOFO[0]][2]])
+ VLori = Pfon - Plev
+ sens = sign(dot(transpose(VN),VLori))
#Extraction dep sup/inf sur les normales
TlibS = [None]*Nbf1
TlibI = [None]*Nbf1
MODEL = self.jdc.sds_dict[MOD[0]]
for i in range(Nbf1):
Porig = array(d_coorf[Lnf1[i]] )
- Pextr = Porig - ABSC_CURV_MAXI*dicVN[Lnf1[i]]
+ if Lnf1[i]==LNOFO[0] and DTANOR : Pextr = Porig - ABSC_CURV_MAXI*dicVN[Lnf1[i]]
+ elif Lnf1[i]==LNOFO[Nbfond-1] and DTANEX : Pextr = Porig - ABSC_CURV_MAXI*dicVN[Lnf1[i]]
+ else : Pextr = Porig - ABSC_CURV_MAXI*dicVN[Lnf1[i]]*sens
TlibS[i] = MACR_LIGN_COUPE(RESULTAT=RESULTAT,
NOM_CHAM='DEPL',MODELE=MODEL, MAILLE = ListmaS,
LIGN_COUPE=_F(NB_POINTS=NB_NOEUD_COUPE,COOR_ORIG=(Porig[0],Porig[1],Porig[2],),
else:
# ---------- Dictionnaires des levres -------------
NnormS = aster.getvectjev(string.ljust(FOND_FISS.nom,8)+'.SUPNORM .NOEU ')
- if NnormS==None : UTMESS('F', macro, 'PROBLEME A LA RECUPERATION DES NOEUDS DES LEVRES')
+ if NnormS==None :
+ message= 'PROBLEME A LA RECUPERATION DES NOEUDS DE LA LEVRE SUP : VERIFIER '
+ message=message+'QUE LE MOT CLE LEVRE_SUP EST BIEN RENSEIGNE DANS DEFI_FOND_FISS\n'
+ UTMESS('F', macro, message)
NnormS = map(string.rstrip,NnormS)
- if LNOFO[0]==LNOFO[-1] : Nbfond=Nbfond-1 # Cas fond de fissure ferme
+ if LNOFO[0]==LNOFO[-1] and MODELISATION=='3D' : Nbfond=Nbfond-1 # Cas fond de fissure ferme
NnormS = [[LNOFO[i],NnormS[i*20:(i+1)*20]] for i in range(0,Nbfond)]
NnormS = [(i[0],i[1][0:]) for i in NnormS]
dicoS = dict(NnormS)
if SYME_CHAR=='SANS':
NnormI = aster.getvectjev(string.ljust(FOND_FISS.nom,8)+'.INFNORM .NOEU ')
+ if NnormI==None :
+ message= 'PROBLEME A LA RECUPERATION DES NOEUDS DE LA LEVRE INF : VERIFIER '
+ message=message+'QUE LE MOT CLE LEVRE_INF EST BIEN RENSEIGNE DANS DEFI_FOND_FISS\n'
+ UTMESS('F', macro, message)
NnormI = map(string.rstrip,NnormI)
NnormI = [[LNOFO[i],NnormI[i*20:(i+1)*20]] for i in range(0,Nbfond)]
NnormI = [(i[0],i[1][0:]) for i in NnormI]
nbt = len(tcoor['NOEUD'].values()['NOEUD'])
xs=array(tcoor['COOR_X'].values()['COOR_X'][:nbt],Float)
ys=array(tcoor['COOR_Y'].values()['COOR_Y'][:nbt],Float)
- if ndim==2 : zs=Numeric.zeros(nbval,Float)
+ if ndim==2 : zs=Numeric.zeros(nbt,Float)
elif ndim==3 : zs=array(tcoor['COOR_Z'].values()['COOR_Z'][:nbt],Float)
ns = tcoor['NOEUD'].values()['NOEUD'][:nbt]
ns = map(string.rstrip,ns)
if SYME_CHAR=='SANS' : Lnoinf[Nbnofo] = Tmpinf
Lnofon.append(Lnf1[i])
Nbnofo = Nbnofo+1
-
+ if Nbnofo == 0 :
+ message= 'CALCUL POSSIBLE POUR AUCUN NOEUD DU FOND :'
+ message=message+' VERIFIER LES DONNEES'
+ UTMESS('F',macro, message)
+
else :
Nbnofo = 1
-
+
# ----------Recuperation de la temperature au fond -------------
if Tempe3D :
resuth = map(string.rstrip,resuth)
l_inst=None
l_inst_tab=tabsup['INST'].values()['INST']
l_inst_tab=dict([(i,0) for i in l_inst_tab]).keys() #elimine les doublons
+ l_inst_tab.sort()
if LIST_ORDRE !=None or NUME_ORDRE !=None :
l_ord_tab = tabsup['NUME_ORDRE'].values()['NUME_ORDRE']
+ l_ord_tab.sort()
l_ord_tab=dict([(i,0) for i in l_ord_tab]).keys()
d_ord_tab= [[l_ord_tab[i],l_inst_tab[i]] for i in range(0,len(l_ord_tab))]
d_ord_tab= [(i[0],i[1]) for i in d_ord_tab]
else :
v = aster.__version__
titre = 'ASTER %s - CONCEPT CALCULE PAR POST_K1_K2_K3 LE &DATE A &HEURE \n'%v
- if FOND_FISS :
+ if FOND_FISS and MODELISATION=='3D':
mcfact.append(_F(PARA='NOEUD_FOND',LISTE_K=[Lnofon[ino],]*3))
mcfact.append(_F(PARA='ABSC_CURV',LISTE_R=[dicoF[Lnofon[ino]]]*3))
mcfact.append(_F(PARA='METHODE',LISTE_I=(1,2,3)))
__tabi=CREA_TABLE(LISTE=mcfact,)
npara = ['K1_MAX','METHODE']
if inst!=None : npara.append('INST')
- if FOND_FISS : npara.append('NOEUD_FOND')
+ if FOND_FISS and MODELISATION=='3D' : npara.append('NOEUD_FOND')
tabout=CALC_TABLE(reuse=tabout,TABLE=tabout,TITRE = titre,
ACTION=_F(OPERATION = 'COMB',NOM_PARA=npara,TABLE=__tabi,))
# Tri pour conserver le meme ordre que operateur initial en fortran
- if len(l_inst)!=1 and FOND_FISS :
+ if len(l_inst)!=1 and FOND_FISS and MODELISATION=='3D':
tabout=CALC_TABLE(reuse=tabout,TABLE=tabout,
ACTION=_F(OPERATION = 'TRI',NOM_PARA=('INST','ABSC_CURV','METHODE'),ORDRE='CROISSANT'))
--- /dev/null
+#@ MODIF post_k_trans_ops Macro DATE 31/10/2006 AUTEUR REZETTE C.REZETTE
+# -*- coding: iso-8859-1 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+
+def post_k_trans_ops(self,RESU_TRANS,K_MODAL,TOUT_ORDRE, NUME_ORDRE, LIST_ORDRE,
+ INST, LIST_INST,INFO,**args):
+ """
+ Ecriture de la macro post_k_trans
+ """
+ import aster
+ import string
+ from Accas import _F
+ from Utilitai.Utmess import UTMESS
+ from types import ListType, TupleType
+ from Utilitai.Table import Table, merge
+ EnumTypes = (ListType, TupleType)
+
+ macro = 'POST_K_TRANS'
+ ier=0
+#------------------------------------------------------------------
+ # On importe les definitions des commandes a utiliser dans la macro
+ CALC_G =self.get_cmd('CALC_G' )
+ IMPR_TABLE =self.get_cmd('IMPR_TABLE' )
+ CREA_TABLE =self.get_cmd('CREA_TABLE' )
+
+ # La macro compte pour 1 dans la numerotation des commandes
+ self.set_icmd(1)
+
+ # Le concept sortant (de type table_sdaster ou dérivé) est tab
+ self.DeclareOut('tabout', self.sd)
+
+#------------------------------------------------------------------
+ TABK = K_MODAL['TABL_K_MODA']
+ F2D = K_MODAL['FOND_FISS']
+ F3D = K_MODAL['FISSURE']
+#
+# Calcul du tableau des K modaux
+#
+ if TABK == None :
+ montit = 'Calcul des K modaux'
+ resumod = K_MODAL['RESU_MODA']
+ thet = K_MODAL['THETA']
+
+ motscles={}
+ motscles2={}
+ motscles['THETA'] = []
+ mcthet = {}
+ if F2D != None : mcthet['FOND_FISS'] = F2D
+ if thet != None : mcthet['THETA'] = thet
+ if F3D != None : mcthet['FISSURE'] = F3D
+ if K_MODAL['DIRECTION']!=None : mcthet['DIRECTION'] = K_MODAL['DIRECTION']
+ if K_MODAL['DIRE_THETA']!=None: mcthet['DIRE_THETA'] = K_MODAL['DIRE_THETA']
+ if K_MODAL['R_SUP']!=None : mcthet['R_SUP'] = K_MODAL['R_SUP']
+ if K_MODAL['R_SUP_FO']!=None : mcthet['R_SUP_FO'] = K_MODAL['R_SUP_FO']
+ if K_MODAL['R_INF']!=None : mcthet['R_INF'] = K_MODAL['R_INF']
+ if K_MODAL['R_INF_FO']!=None : mcthet['R_INF_FO'] = K_MODAL['R_INF_FO']
+ if K_MODAL['MODULE']!=None : mcthet['MODULE'] = K_MODAL['MODULE']
+ if K_MODAL['MODULE']==None and F2D : mcthet['MODULE'] = 1
+ if K_MODAL['MODULE_FO']!=None : mcthet['MODULE_FO'] = K_MODAL['MODULE_FO']
+
+ if thet == None and F3D :
+ motscles2['LISSAGE'] = []
+ if K_MODAL['LISSAGE_G'] == None : K_MODAL['LISSAGE_G']='LEGENDRE'
+ if K_MODAL['LISSAGE_THETA'] == None : K_MODAL['LISSAGE_THETA']='LEGENDRE'
+ if K_MODAL['DEGRE'] : K_MODAL['DEGRE'] = 5
+ motscles2['LISSAGE'].append(_F(LISSAGE_G =K_MODAL['LISSAGE_G'],
+ LISSAGE_THETA =K_MODAL['LISSAGE_G'],
+ DEGRE = K_MODAL['DEGRE'] ))
+
+ __kgtheta = CALC_G( RESULTAT = resumod,
+ OPTION = 'K_G_MODA',
+ TOUT_MODE = 'OUI',
+ INFO = INFO,
+ TITRE = montit,
+ THETA=mcthet,
+ **motscles2)
+
+
+#
+# Recuperation du tableau des K modaux
+#
+ else :
+ __kgtheta=TABK
+
+#-----------------------------------------
+#
+# Verification de cohérence sur le nombre de modes
+#
+# RESULTAT TRANSITOIRE
+ nomresu=RESU_TRANS.nom
+ coef=aster.getvectjev(nomresu.ljust(19)+'.DEPL')
+ nmodtr=aster.getvectjev(nomresu.ljust(19)+'.DESC')[1]
+# BASE MODALE
+ if F2D :
+ n_mode = len((__kgtheta.EXTR_TABLE())['K1'])
+ nbno = 1
+ if F3D :
+ n_mode = max((__kgtheta.EXTR_TABLE())['NUME_MODE'].values()['NUME_MODE'])
+ nbno = max((__kgtheta.EXTR_TABLE())['NUM_PT'].values()['NUM_PT'])
+ labsc = (__kgtheta.EXTR_TABLE())['ABS_CURV'].values()['ABS_CURV'][0:nbno]
+
+ if nmodtr != n_mode :
+ n_mode = min(nmodtr,n_mode)
+ message = 'NOMBRE DE MODES DIFFERENT ENTRE LA BASE MODALE'
+ message = message +'ET %s : ON PREND LE MINIMUM DES DEUX (%i)\n'%(nomresu,n_mode)
+ UTMESS('A', macro, message)
+
+#
+# Traitement des mots clés ORDRE/INST/LIST_INST et LIST_ORDRE
+#
+ l0_inst = aster.getvectjev(nomresu.ljust(19)+'.INST')
+ l0_ord = aster.getvectjev(nomresu.ljust(19)+'.ORDR')
+ nbtrans = len(l0_ord)
+ li = [[l0_ord[i],l0_inst[i]] for i in range(nbtrans)]
+ ln = [[l0_ord[i],i] for i in range(nbtrans)]
+ lo = [[l0_inst[i],l0_ord[i]] for i in range(nbtrans)]
+ li = [(i[0],i[1:]) for i in li]
+ ln = [(i[0],i[1:]) for i in ln]
+ lo = [(i[0],i[1:]) for i in lo]
+ d_ord = dict(lo)
+ d_ins = dict(li)
+ d_num = dict(ln)
+
+
+ l_ord =[]
+ l_inst =[]
+ if LIST_ORDRE or NUME_ORDRE :
+ if NUME_ORDRE :
+ if type(NUME_ORDRE) not in EnumTypes : NUME_ORDRE=(NUME_ORDRE,)
+ ltmp = list(NUME_ORDRE)
+ elif LIST_ORDRE :
+ ltmp = aster.getvectjev(string.ljust(LIST_ORDRE.nom,19)+'.VALE')
+ for ord in ltmp :
+ if ord in l0_ord :
+ l_ord.append(ord)
+ l_inst.append(d_ins[ord][0])
+ else :
+ message = 'LE NUMERO D ORDRE %i N APPARTIENT PAS AU RESULTAT %s'%(ord,nomresu)
+ UTMESS('A', macro, message)
+ elif LIST_INST or INST :
+ CRITERE = args['CRITERE']
+ PRECISION = args['PRECISION']
+ if INST :
+ if type(INST) not in EnumTypes : INST=(INST,)
+ ltmp = list(INST)
+ elif LIST_INST :
+ ltmp = aster.getvectjev(string.ljust(LIST_INST.nom,19)+'.VALE')
+ for ins in ltmp :
+ if CRITERE=='RELATIF' and ins!=0.: match=[x for x in l0_inst if abs((ins-x)/ins)<PRECISION]
+ else : match=[x for x in l0_inst if abs(ins-x)<PRECISION]
+ if len(match)==0 :
+ message = 'PAS D INSTANT TROUVE DANS LA TABLE POUR L INSTANT %f\n'%ins
+ UTMESS('A', macro, message)
+ elif len(match)>=2 :
+ message = 'PLUSIEURS INSTANTS TROUVES DANS LA TABLE POUR L INSTANT %f\n'%ins
+ UTMESS('A', macro, message)
+ else :
+ l_inst.append(match[0])
+ l_ord.append(d_ord[match[0]][0])
+ else :
+ l_ord = l0_ord
+ l_inst = l0_inst
+ nbarch = len(l_ord)
+ if nbarch ==0 : UTMESS('F', macro, 'AUCUN INSTANT OU NUMERO D ORDRE TROUVE')
+
+
+#
+# Calcul des K(t)
+#
+
+ K1mod = [None]*n_mode*nbno
+ K2mod = [None]*n_mode*nbno
+ K1t = [None]*nbarch*nbno
+ K2t = [None]*nbarch*nbno
+ if F3D :
+ K3mod = [None]*n_mode*nbno
+ K3t = [None]*nbarch*nbno
+ k1 = 'K1_LOCAL'
+ k2 = 'K2_LOCAL'
+ k3 = 'K3_LOCAL'
+ else :
+ k1 = 'K1'
+ k2 = 'K2'
+
+
+ for x in range(0,nbno) :
+ for k in range(0,n_mode) :
+ K1mod[k*nbno + x] = __kgtheta[k1,k*nbno + x+1]
+ K2mod[k*nbno + x] = __kgtheta[k2,k*nbno + x+1]
+ if F3D : K3mod[k*nbno + x] = __kgtheta[k3,k*nbno + x+1]
+
+ for num in range(0,nbarch) :
+ K1t[num*nbno + x] = 0.0
+ K2t[num*nbno + x] = 0.0
+ if F3D : K3t[num*nbno + x] = 0.0
+ for k in range(0,n_mode) :
+ num_ord = d_num[l_ord[num]][0]
+ alpha = coef[n_mode*num_ord+k]
+ K1t[num*nbno + x] = K1t[num*nbno + x] + alpha*K1mod[k*nbno + x]
+ K2t[num*nbno + x] = K2t[num*nbno + x] + alpha*K2mod[k*nbno + x]
+ if F3D : K3t[num*nbno + x] = K3t[num*nbno + x] + alpha*K3mod[k*nbno + x]
+
+ v = aster.__version__
+ titre = 'ASTER %s - CONCEPT CALCULE PAR POST_K_TRANS LE &DATE A &HEURE \n'%v
+ if F2D :
+ tabout = CREA_TABLE(LISTE = (_F(LISTE_I =l_ord, PARA = 'NUME_ORDRE'),
+ _F(LISTE_R =l_inst, PARA = 'INST'),
+ _F(LISTE_R =K1t, PARA = k1),
+ _F(LISTE_R =K2t, PARA = k2),),
+ TITRE = titre, );
+ if F3D :
+ lo = []
+ li = []
+ for i in range(nbarch) :
+ for j in range(nbno) :
+ lo.append(l_ord[i])
+ li.append(l_inst[i])
+ tabout = CREA_TABLE(LISTE = (_F(LISTE_I =lo, PARA = 'NUME_ORDRE'),
+ _F(LISTE_R =li, PARA = 'INST'),
+ _F(LISTE_I =range(nbno)*nbarch, PARA ='NUM_PT' ),
+ _F(LISTE_R =labsc*nbarch, PARA = 'ABS_CURV'),
+ _F(LISTE_R =K1t, PARA = k1),
+ _F(LISTE_R =K2t, PARA = k2),
+ _F(LISTE_R =K3t, PARA = k3),),
+ TITRE = titre,
+ );
+
+#------------------------------------------------------------------
+ return ier
-#@ MODIF reca_algo Macro DATE 31/01/2006 AUTEUR MCOURTOI M.COURTOIS
+#@ MODIF reca_algo Macro DATE 14/11/2006 AUTEUR ASSIRE A.ASSIRE
# -*- coding: iso-8859-1 -*-
+# RESPONSABLE ASSIRE A.ASSIRE
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
-
-
-import Numeric
+import Numeric, MLab
from Numeric import take, size
-import copy,os
+import copy, os
import LinearAlgebra
-from Cata.cata import INFO_EXEC_ASTER
-from Cata.cata import DETRUIRE
-from Accas import _F
-from Utilitai.Utmess import UTMESS
+
+try:
+ import aster
+ from Cata.cata import INFO_EXEC_ASTER
+ from Cata.cata import DETRUIRE
+ from Accas import _F
+except: pass
+
+try:
+ from Utilitai.Utmess import UTMESS
+except ImportError:
+ def UTMESS(code,sprg,texte):
+ fmt='\n <%s> <%s> %s\n\n'
+ print fmt % (code,sprg,texte)
+ if code=='F': sys.exit()
+
def calcul_gradient(A,erreur):
return grad
-#-------------------------------------------
-#classe gérant l'adimensionnement et le dimensionnemnt
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+
class Dimension:
- #le constructeur calcul la matrice D et son inverse
+ """
+ Classe gérant l'adimensionnement et le dimensionnement
+ """
+
def __init__(self,val_initiales,para):
+ """
+ Le constructeur calcul la matrice D et son inverse
+ """
self.val_init = val_initiales
dim =len(self.val_init)
self.D = Numeric.zeros((dim,dim),Numeric.Float)
self.inv_D=LinearAlgebra.inverse(self.D)
+# ------------------------------------------------------------------------------
+
def adim_sensi(self,A):
for i in range(A.shape[0]):
for j in range(A.shape[1]):
return A
+# ------------------------------------------------------------------------------
def redim_sensi(self,A):
for i in range(A.shape[0]):
return A
+# ------------------------------------------------------------------------------
+
def adim(self,tab):
tab_adim = Numeric.dot(self.inv_D,copy.copy(tab))
return tab_adim
+# ------------------------------------------------------------------------------
+
def redim(self,tab_adim):
tab = Numeric.dot(self.D,tab_adim)
return tab
-
-#------------------------------------------
+
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+
+
+
+
+
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+
def cond(matrix):
e1=LinearAlgebra.eigenvalues(matrix)
e=map(abs,e1)
condi=0.0
return condi,e[size-1],e[0]
-#-----------------------------------------
+
+
+
+
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+
def norm(matrix):
e=LinearAlgebra.Heigenvalues(matrix)
size=len(e)
norm=e[size-1]
return norm
-#-----------------------------------------
+
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+
def lambda_init(matrix):
-# Routine qui calcule la valeur initial du parametre
-# de regularisation l.
+ """
+ Routine qui calcule la valeur initial du parametre de regularisation l.
+ """
condi,emax,emin=cond(matrix)
id=Numeric.identity(matrix.shape[0])
if (condi==0.0):
l=abs(10000.*emin-emax)/10001.
return l
-#-----------------------------------------
-
-
-def temps_CPU(self,restant_old,temps_iter_old):
- # Fonction controlant le temps CPU restant
- CPU=INFO_EXEC_ASTER(LISTE_INFO = ("CPU_RESTANT",))
- TEMPS=CPU['CPU_RESTANT',1]
- DETRUIRE(CONCEPT=_F(NOM='CPU'),INFO=1)
- err=0
- # Indique une execution interactive
- if (TEMPS>1.E+9):
- return 0.,0.,0
- # Indique une execution en batch
- else:
- restant=TEMPS
- # Initialisation
- if (restant_old==0.):
- temps_iter=-1.
- else:
- # Première mesure
- if (temps_iter_old==-1.):
- temps_iter=(restant_old-restant)
- # Mesure courante
- else:
- temps_iter=(temps_iter_old + (restant_old-restant))/2.
- if ((temps_iter>0.96*restant)or(restant<0.)):
- err=1
- UTMESS('F', "MACR_RECAL", 'Arret de MACR_RECAL par manque de temps CPU')
- return restant,temps_iter,err
-
-
-
-
-def Levenberg_bornes(self,val,Dim,val_init,borne_inf,borne_sup,A,erreur,l,ul_out):
- # on resoud le système par contraintes actives:
- # Q.dval + s + d =0
- # soumis à :
- # borne_inf < dval < borne_sup
- # 0 < s
- # s.(borne_inf - dval)=0
- # s.(borne_sup - dval)=0
+
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+
+def Levenberg_bornes(val,Dim,val_init,borne_inf,borne_sup,A,erreur,l,ul_out):
+ """
+ On resoud le système par contraintes actives:
+ Q.dval + s + d =0
+ soumis à :
+ borne_inf < dval < borne_sup
+ 0 < s
+ s.(borne_inf - dval)=0
+ s.(borne_sup - dval)=0
+ """
dim = len(val)
id = Numeric.identity(dim)
# Matrice du système
res.write('\n\nval_ini= '+Numeric.array2string(val_init,array_output=1,separator=','))
res.write('\n\nborne_inf= '+Numeric.array2string(borne_inf,array_output=1,separator=','))
res.write('\n\nborne_sup= '+Numeric.array2string(borne_sup,array_output=1,separator=','))
- UTMESS('F', "MACR_RECAL", "Erreur dans l'algorithme de bornes de MACR_RECAL")
+ UTMESS('F','MACR_RECAL',"Erreur dans l'algorithme de bornes de MACR_RECAL")
return
newval=copy.copy(val+dval)
return newval,s,l,Act
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+
def actualise_lambda(l,val,new_val,A,erreur,new_J,old_J):
dim = len(val)
id = Numeric.identity(dim)
return l
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+
def test_convergence(gradient_init,erreur,A,s):
+ """
+ Renvoie le residu
+ """
gradient = calcul_gradient(A,erreur)+s
- epsilon = Numeric.dot(gradient,gradient)/Numeric.dot(gradient_init,gradient_init)
+ try:
+ epsilon = Numeric.dot(gradient,gradient)/Numeric.dot(gradient_init,gradient_init)
+ except:
+ UTMESS('F', "MACR_RECAL", "Erreur dans le test de convergence de MACR_RECAL")
+ return
epsilon = epsilon**0.5
return epsilon
-# fonction appellée quand la convergence est atteinte
-# on calcule le Hessien et les valeurs propres et vecteurs
-# propre associés au Hessien
-# A = sensibilite
-# At*A = hessien
-def calcul_etat_final(para,A,iter,max_iter,prec,residu,Messg,ul_out):
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+
+def calcul_etat_final(para,A,iter,max_iter,prec,residu,Messg):
+ """
+ Fonction appelée quand la convergence est atteinte
+ on calcule le Hessien et les valeurs propres et vecteurs
+ propre associés au Hessien
+ A = sensibilite
+ At*A = hessien
+ """
+
if ((iter < max_iter) or (residu < prec)):
Hessien = Numeric.matrixmultiply(Numeric.transpose(A),A)
+
+ # Desactive temporairement les FPE qui pourraient etre generees (a tord!) par blas
+ aster.matfpe(-1)
valeurs_propres,vecteurs_propres = LinearAlgebra.eigenvectors(Hessien)
+# valeurs_propres,vecteurs_propres = MLab.eig(Hessien)
sensible=Numeric.nonzero(Numeric.greater(abs(valeurs_propres/max(abs(valeurs_propres))),1.E-1))
insensible=Numeric.nonzero(Numeric.less(abs(valeurs_propres/max(abs(valeurs_propres))),1.E-2))
- Messg.affiche_calcul_etat_final(para,Hessien,valeurs_propres,vecteurs_propres,sensible,insensible,ul_out)
-
-
-
-
+ # Reactive les FPE
+ aster.matfpe(1)
+ Messg.affiche_calcul_etat_final(para,Hessien,valeurs_propres,vecteurs_propres,sensible,insensible)
--- /dev/null
+#@ MODIF reca_calcul_aster Macro DATE 14/11/2006 AUTEUR ASSIRE A.ASSIRE
+# -*- coding: iso-8859-1 -*-
+# RESPONSABLE ASSIRE A.ASSIRE
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2006 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.
+# ======================================================================
+
+# mode_include = False
+# __follow_output = False
+# table_sensibilite = False
+debug = False
+
+__commandes_aster__ = False
+
+
+import copy, Numeric, types, os, sys, pprint, math
+from glob import glob
+
+try:
+ import aster
+except: pass
+
+try:
+ from Utilitai.Utmess import UTMESS
+except ImportError:
+ def UTMESS(code,sprg,texte):
+ fmt='\n <%s> <%s> %s\n\n'
+ print fmt % (code,sprg,texte)
+ if code=='F': sys.exit()
+
+from Utilitai.System import ExecCommand
+
+# Nom de la routine
+nompro = 'MACR_RECAL'
+
+
+# ------------------------------------------------------------------------------
+
+class PARAMETRES:
+
+ def __init__(self, METHODE, UNITE_RESU, INFO=1, fich_output='./REPE_OUT/output_esclave.txt', mode_include=False, follow_output=False, table_sensibilite=False, memjeveux_esclave=None, PARA_DIFF_FINI=1.E-3, ITER_MAXI=10, ITER_FONC_MAXI=100):
+
+ self.METHODE = METHODE
+ self.UNITE_RESU = UNITE_RESU
+ self.INFO = INFO
+ self.fich_output = fich_output
+ self.PARA_DIFF_FINI = PARA_DIFF_FINI
+ self.ITER_FONC_MAXI = ITER_FONC_MAXI
+ self.ITER_MAXI = ITER_MAXI,
+
+ try:
+ import Cata, aster
+ from Cata.cata import INCLUDE, DETRUIRE, FIN, DEFI_FICHIER, IMPR_TABLE, LIRE_TABLE, INFO_EXEC_ASTER, EXTR_TABLE, CREA_TABLE
+ from Accas import _F
+ except:
+ mode_include = False
+
+ if not mode_include:
+ try:
+ from Macro.lire_table_ops import lecture_table
+ mode_aster = True
+ except:
+ try:
+ sys.path.append( './Python/Macro' )
+ from Macro.lire_table_ops import lecture_table
+ mode_aster = False
+ except:
+ UTMESS('F','MACR_RECAL',"Probleme : impossible d'importer le module de lecture des tables!")
+ self.mode_include = mode_include
+ self.follow_output = follow_output
+ self.mode_aster = mode_aster
+ self.memjeveux_esclave = memjeveux_esclave
+ self.table_sensibilite = table_sensibilite
+
+ self.vector_output = False
+ self.error_output = False
+
+
+# ------------------------------------------------------------------------------
+
+class CALCUL_ASTER:
+
+ def __init__(self, PARAMETRES, UL, para, reponses, LIST_SENSI=[], LIST_DERIV=[]):
+
+ self.UL = UL
+ self.para = para
+ self.reponses = reponses
+ self.LIST_SENSI = LIST_SENSI
+ self.LIST_DERIV = LIST_DERIV
+
+ self.METHODE = PARAMETRES.METHODE
+ self.UNITE_RESU = PARAMETRES.UNITE_RESU
+ self.INFO = PARAMETRES.INFO
+ self.fich_output = PARAMETRES.fich_output
+ self.mode_include = PARAMETRES.mode_include
+ self.follow_output = PARAMETRES.follow_output
+ self.table_sensibilite = PARAMETRES.table_sensibilite
+ self.mode_aster = PARAMETRES.mode_aster
+ self.memjeveux_esclave = PARAMETRES.memjeveux_esclave
+ self.PARA_DIFF_FINI = PARAMETRES.PARA_DIFF_FINI
+ self.ITER_FONC_MAXI = PARAMETRES.ITER_FONC_MAXI
+ self.vector_output = PARAMETRES.vector_output
+ self.error_output = PARAMETRES.vector_output
+
+ self.UNITE_GRAPHIQUE = None
+ self.new_export = 'tmp_export'
+ self.nom_fichier_mess_fils = None
+ self.nom_fichier_resu_fils = None
+
+ self.fichier_esclave = None
+
+ self.evaluation_fonction = 0
+
+ self.L_J_init = None
+ self.val = None
+ self.L = None
+ self.L_deriv_sensible = None
+
+
+
+ # ------------------------------------------------------------------------------
+
+ def Lancement_Commande(self, cmd):
+
+ if self.INFO>=1: UTMESS('I','MACR_RECAL',"Lancement de la commande : " + cmd)
+
+ fich_output = self.fich_output
+ follow_output = self.follow_output
+
+ # Lancement d'Aster avec le deuxieme export
+ iret, txt_output = ExecCommand(cmd, follow_output=self.follow_output,verbose=False)
+
+ if fich_output:
+ # Recuperation du .mess 'fils'
+ f=open(fich_output, 'w')
+ f.write( txt_output )
+ f.close()
+
+ if self.INFO>=1: UTMESS('I','MACR_RECAL',"Fin du lancement de la commande : " + cmd)
+
+ diag = self.Recuperation_Diagnostic(txt_output)
+
+ return
+
+
+ # ------------------------------------------------------------------------------
+
+ def Recuperation_Diagnostic(self, output):
+
+ txt = '--- DIAGNOSTIC JOB :'
+ diag = None
+ for ligne in output.splitlines():
+ if ligne.find(txt) > -1:
+ diag = ligne.split(txt)[-1].strip()
+ break
+
+ if self.INFO>=1: UTMESS('I','MACR_RECAL',"Diagnostic du calcul esclave : " + diag)
+
+ if diag in ['OK', 'NOOK_TEST_RESU', '<A>_ALARM', '<F>_COPY_ERROR']: return True
+ else:
+ UTMESS('F','MACR_RECAL',"Le fichier esclave ne s'est pas terminé correctement.")
+
+
+ # ------------------------------------------------------------------------------
+
+ def Remplace_fichier_esclave(self, val_in): pass
+
+
+ # ------------------------------------------------------------------------------
+
+ def calcul_Aster(self, val, INFO=0):
+
+ self.val = val
+ UL = self.UL
+ para = self.para
+ reponses = self.reponses
+ UNITE_RESU = self.UNITE_RESU
+ LIST_SENSI = self.LIST_SENSI
+ LIST_DERIV = self.LIST_DERIV
+
+ mode_include = self.mode_include
+ follow_output = self.follow_output
+ table_sensibilite = self.table_sensibilite
+
+ if self.evaluation_fonction > self.ITER_FONC_MAXI:
+ UTMESS('F', nompro, "Le nombre d'evaluation de la fonctionnelle depasse le critere ITER_FONC_MAXI.")
+ self.evaluation_fonction += 1
+
+
+ if not mode_include:
+
+ # Creation du repertoire temporaire pour l'execution de l'esclave
+ tmp_macr_recal = self.Creation_Temporaire_Esclave()
+
+ # Creation du fichier .export de l'esclave
+ self.Creation_Fichier_Export_Esclave(tmp_macr_recal)
+
+ # Fichier esclave a modifier (si methode EXTERNE alors on prend directement le fichier esclave, sinon c'est le fort.UL dans le repertoire d'execution
+ try:
+ if self.METHODE=='EXTERNE':
+ fic = open(self.fichier_esclave,'r')
+ else:
+ fic = open('fort.'+str(UL),'r')
+
+ # On stocke le contenu de fort.UL dans la variable fichier qui est une string
+ fichier=fic.read()
+ # On stocke le contenu initial de fort.UL dans la variable fichiersauv
+ fichiersauv=copy.copy(fichier)
+ fic.close()
+ except:
+ UTMESS('F', nompro, "Impossible de relire le fichier esclave : \n " + str(self.fichier_esclave))
+
+ # chemin vers as_run
+ if os.environ.has_key('ASTER_ROOT'):
+ as_run = os.path.join(os.environ['ASTER_ROOT'], 'ASTK', 'ASTK_SERV', 'bin', 'as_run')
+ elif os.path.isfile(aster.repout() + os.sep + 'as_run'):
+ as_run = aster.repout() + os.sep + 'as_run'
+ else:
+ as_run = 'as_run'
+ if INFO>=1: UTMESS('A', nompro, "Variable d'environnement ASTER_ROOT absente, " \
+ "on essaiera avec 'as_run' dans le $PATH.")
+
+ if __commandes_aster__:
+ try:
+ from Cata.cata import INCLUDE, DETRUIRE, FIN, DEFI_FICHIER, IMPR_TABLE, LIRE_TABLE, INFO_EXEC_ASTER, EXTR_TABLE, CREA_TABLE
+ except:
+ message = "Erreur"
+ UTMESS('F', nompro, message)
+
+ # Utilisation du module Python de LIRE_TABLE
+ if self.mode_aster:
+ from Macro.lire_table_ops import lecture_table
+ else:
+ try:
+ sys.path.append( './Python/Macro' )
+ from lire_table_ops import lecture_table
+ except:
+ UTMESS('F','MACR_RECAL',"Probleme : impossible d'importer le module de lecture des tables!")
+
+ txt = []
+ for i in para:
+ txt.append( "\t\t\t%s : %s" % (i, val[para.index(i)]) )
+ if INFO>=1: UTMESS('I','MACR_RECAL',"Calcul de F avec les parametres:\n%s" % '\n'.join(txt))
+
+
+ # MARCHE PAS !!
+# # Quelques verifications/modifications sur le fichier esclave, pour blindage
+# fichiernew=[]
+# for ligne in fichier.split('\n'):
+# # DEBUT et FIN (on retire les espaces entre le mot-clé et la premiere parenthese)
+# for (txt1, txt2) in [('DEBUT','('), ('FIN','(')]:
+# if ligne.find( txt1 )!=-1 and ligne.find( txt2 )!=-1:
+# index_deb1 = ligne.index(txt1)
+# ligne1 = ligne[ index_deb1+len(txt1):]
+# if ligne.find( txt1 )!=-1:
+#
+#
+# for (txt1, txt2) in [('DEBUT','('), ('FIN','(')]:
+# if ligne.find( txt1 )!=-1 and ligne.find( txt2 )!=-1:
+# index_deb1 = ligne.index(txt1)
+# index_fin1 = index_deb1 + len(txt1)
+# index_deb2 = ligne.index(txt2)
+# index_fin2 = index_deb1 + len(txt2)
+# ligne = ligne[:index_fin1]+ligne[index_deb2:]
+# # on retire les parametes en commentaires
+# for txt in para:
+# if ligne.find(txt)!=-1:
+# if ligne.replace(' ', '')[0] == '#': ligne = ''
+# fichiernew.append(ligne)
+# fichier = '\n'.join(fichiernew)
+
+ #Fichier_Resu est une liste ou l'on va stocker le fichier modifié
+ #idée générale :on délimite des 'blocs' dans fichier
+ #on modifie ou non ces blocs suivant les besoins
+ #on ajoute ces blocs dans la liste Fichier_Resu
+ Fichier_Resu=[]
+
+ # Dans le cas du mode INCLUDE on enleve le mot-clé DEBUT
+ if mode_include:
+ try:
+ #cherche l'indice de DEBUT()
+ index_deb=fichier.index('DEBUT(')
+ while( fichier[index_deb]!='\n'):
+ index_deb=index_deb+1
+ #on restreint fichier en enlevant 'DEBUT();'
+ fichier = fichier[index_deb+1:]
+ except:
+ #on va dans l'except si on a modifié le fichier au moins une fois
+ pass
+
+# print 60*'o'
+# print fichier
+# print 60*'o'
+
+ # On enleve le mot-clé FIN()
+ try:
+ #cherche l'indice de FIN()
+ index_fin = fichier.index('FIN(')
+ #on restreint fichier en enlevant 'FIN();'
+ fichier = fichier[:index_fin]
+ except : pass
+
+# print 60*'o'
+# print fichier
+# print 60*'o'
+
+ #--------------------------------------------------------------------------------
+ #on cherche à délimiter le bloc des parametres dans le fichier
+ #Tout d'abord on cherche les indices d'apparition des paras dans le fichier
+ #en effet l'utilisateur n'est pas obligé de rentrer les paras dans optimise
+ #avec le meme ordre que son fichier de commande
+ index_para = Numeric.zeros(len(para))
+ for i in range(len(para)):
+ index_para[i] = fichier.index(para[i])
+
+ #On range les indices par ordre croissant afin de déterminer
+ #les indice_max et indice_min
+ index_para = Numeric.sort(index_para)
+ index_first_para = index_para[0]
+ index_last_para = index_para[len(index_para)-1]
+
+
+ #on va délimiter les blocs intermédiaires entre chaque para "utiles" à l'optimsation
+ bloc_inter ='\n'
+ for i in range(len(para)-1):
+ j = index_para[i]
+ k = index_para[i+1]
+ while(fichier[j]!= '\n'):
+ j=j+1
+ bloc_inter=bloc_inter + fichier[j:k] + '\n'
+
+ #on veut se placer sur le premier retour chariot que l'on trouve sur la ligne du dernier para
+ i = index_last_para
+ while(fichier[i] != '\n'):
+ i = i + 1
+ index_last_para = i
+ #on délimite les blocs suivants:
+ pre_bloc = fichier[:index_first_para] #fichier avant premier parametre
+ post_bloc = fichier[ index_last_para+ 1:] #fichier après dernier parametre
+
+ #on ajoute dans L tous ce qui est avant le premier paramètre
+ Fichier_Resu.append(pre_bloc)
+ Fichier_Resu.append('\n')
+
+ # Liste des parametres utilisant la SENSIBILITE
+ liste_sensibilite = []
+ if len(LIST_SENSI)>0:
+ for i in LIST_SENSI:
+ liste_sensibilite.append( i )
+
+ #On ajoute la nouvelle valeur des parametres
+ dim_para=len(para)
+ for j in range(dim_para):
+ if not para[j] in liste_sensibilite:
+ Fichier_Resu.append(para[j]+'='+str(val[j]) + ';' + '\n')
+ else:
+ Fichier_Resu.append(para[j]+'=DEFI_PARA_SENSI(VALE='+str(val[j]) + ',);' + '\n')
+
+
+ #On ajoute à Fichier_Resu tous ce qui est entre les parametres
+ Fichier_Resu.append(bloc_inter)
+
+ Fichier_Resu.append(post_bloc)
+
+ #--------------------------------------------------------------------------------
+ #on va ajouter la fonction d'extraction du numarray de la table par la méthode Array
+ #et on stocke les réponses calculées dans la liste Lrep
+ #qui va etre retournée par la fonction calcul_Aster
+ if mode_include:
+ self.g_context['Lrep'] = []
+ Fichier_Resu.append('Lrep=[]'+'\n')
+ for i in range(len(reponses)):
+ Fichier_Resu.append('t'+str(reponses[i][0])+'='+str(reponses[i][0])+'.EXTR_TABLE()'+'\n')
+ Fichier_Resu.append('F = '+'t'+str(reponses[i][0])+'.Array('+"'"+str(reponses[i][1])+"'"+','+"'"+str(reponses[i][2])+"'"+')'+'\n')
+ Fichier_Resu.append('Lrep.append(F)'+'\n')
+
+ #ouverture du fichier fort.3 et mise a jour de celui ci
+ x=open('fort.'+str(UL),'w')
+ if mode_include:
+ x.writelines('from Accas import _F \nfrom Cata.cata import * \n')
+ x.writelines(Fichier_Resu)
+ x.close()
+
+ del(pre_bloc)
+ del(post_bloc)
+ del(fichier)
+
+ # ----------------------------------------------------------------------------------
+ # Execution d'une deuxieme instance d'Aster
+
+ if not mode_include:
+
+ # Ajout des commandes d'impression des tables Resultats et Derivees à la fin du fichier esclave
+ Fichier_Resu = []
+ num_ul = '99'
+
+ # Tables correspondant aux Resultats
+ for i in range(len(reponses)):
+ _ul = str(int(100+i))
+
+ try: os.remove( tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+_ul )
+ except: pass
+
+ Fichier_Resu.append("\n# Recuperation de la table : " + str(reponses[i][0]) + "\n")
+ Fichier_Resu.append("DEFI_FICHIER(UNITE="+num_ul+", FICHIER='"+tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+_ul+"',);\n")
+ Fichier_Resu.append("IMPR_TABLE(TABLE="+str(reponses[i][0])+", FORMAT='ASTER', UNITE="+num_ul+", INFO=1, FORMAT_R='E30.20',);\n")
+ Fichier_Resu.append("DEFI_FICHIER(ACTION='LIBERER', UNITE="+num_ul+",);\n")
+
+ # Tables correspondant aux Derivees
+ if len(LIST_SENSI)>0:
+ i = 0
+ for _para in LIST_SENSI:
+ _lst_tbl = LIST_DERIV[_para][0]
+ for _lst_tbl in LIST_DERIV[_para]:
+ i += 1
+ _tbl = _lst_tbl[0]
+
+ _ul = str(int(100+len(reponses)+i))
+ try: os.remove( tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+_ul )
+ except: pass
+
+ Fichier_Resu.append("\n# Recuperation de la table derivee : " + _tbl + " (parametre " + _para + ")\n")
+ Fichier_Resu.append("DEFI_FICHIER(UNITE="+num_ul+", FICHIER='"+tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+_ul+"',);\n")
+ if table_sensibilite:
+ Fichier_Resu.append("IMPR_TABLE(TABLE="+_tbl+", SENSIBILITE="+_para+", FORMAT='ASTER', UNITE="+num_ul+", INFO=1, FORMAT_R='E30.20',);\n")
+ else:
+ Fichier_Resu.append("IMPR_TABLE(TABLE="+_tbl+", FORMAT='ASTER', UNITE="+num_ul+", INFO=1, FORMAT_R='E30.20',);\n")
+ Fichier_Resu.append("DEFI_FICHIER(ACTION='LIBERER', UNITE="+num_ul+",);\n")
+
+ # Ecriture du "nouveau" fichier .comm
+ x=open('fort.'+str(UL),'a')
+ x.write( '\n'.join(Fichier_Resu) )
+ x.write('\nFIN();\n')
+ x.close()
+
+# os.system("cat %s" % self.new_export)
+
+ # Lancement du calcul Aster esclave
+ cmd = '%s %s' % (as_run, self.new_export)
+ self.Lancement_Commande(cmd)
+
+ # Recuperation du .mess et du .resu 'fils'
+ if self.METHODE != 'EXTERNE':
+ if self.nom_fichier_mess_fils:
+ cmd = 'cp ' + tmp_macr_recal + os.sep + self.nom_fichier_mess_fils + ' ./REPE_OUT/'
+ os.system( cmd )
+ if self.nom_fichier_resu_fils:
+ cmd = 'cp ' + tmp_macr_recal + os.sep + self.nom_fichier_resu_fils + ' ./REPE_OUT/'
+ os.system( cmd )
+
+ if __commandes_aster__:
+ # Unite logique libre
+ _tbul_libre=INFO_EXEC_ASTER(LISTE_INFO='UNITE_LIBRE')
+ _ul_libre=_tbul_libre['UNITE_LIBRE',1]
+
+
+ # ------------------------------------------------------
+ # Recuperation des tableaux resultats
+ Lrep=[]
+ _TB = [None]*len(reponses)
+ for i in range(len(reponses)):
+
+ if __commandes_aster__:
+
+ # Version par des commandes Aster
+ # -------
+
+
+ DEFI_FICHIER(UNITE=_ul_libre, FICHIER=tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+str(int(100+i)), );
+ try:
+ _TB[i]=LIRE_TABLE(UNITE=_ul_libre,
+ FORMAT='ASTER',
+ NUME_TABLE=1,
+ SEPARATEUR=' ',);
+ DEFI_FICHIER(ACTION='LIBERER', UNITE=_ul_libre,);
+ tREPONSE=_TB[i].EXTR_TABLE()
+
+ F = tREPONSE.Array( str(reponses[i][1]), str(reponses[i][2]) )
+ Lrep.append(F)
+ except:
+ message = "Impossible de recuperer les resultats de calcul esclave!"
+ UTMESS('F', nompro, message)
+
+ else:
+
+ # Version par utilisation directe du python de lire_table
+ # -------
+
+ # Chemin vers le fichier contenant la table
+ _fic_table = tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+str(int(100+i))
+
+ try:
+ file=open(_fic_table,'r')
+ texte=file.read()
+ file.close()
+ except Exception, err:
+ ier=1
+ message = """Impossible de recuperer les resultats de calcul esclave (lecture des tables)!
+Le calcul esclave n'a pas du se terminer correctement (ajouter un repertoire en Resultat avec
+le type repe et voir l'output du fichier esclave dans ce repertoire.
+Message:
+"""
+ message += str(err)
+ UTMESS('F', nompro, message)
+
+ try:
+ ier, message, table_lue = lecture_table(texte, 1, ' ')
+ list_para = table_lue.para
+ tab_lue = table_lue.values()
+ except Exception, err:
+ ier=1
+ message = "Impossible de recuperer les resultats de calcul esclave (lecture des tables)!\nMessage:\n" + str(err)
+
+ if ier!=0 :
+ UTMESS('F', nompro, message)
+
+ try:
+ nb_val = len(tab_lue[ list_para[0] ])
+ F = Numeric.zeros((nb_val,2), Numeric.Float)
+ for k in range(nb_val):
+# F[k][0] = tab_lue[ list_para[0] ][1][k]
+# F[k][1] = tab_lue[ list_para[1] ][1][k]
+ F[k][0] = tab_lue[ str(reponses[i][1]) ][k]
+ F[k][1] = tab_lue[ str(reponses[i][2]) ][k]
+ Lrep.append(F)
+ except Exception, err:
+ message = "Impossible de recuperer les resultats de calcul esclave (recuperation des tables)!\nMessage:\n" + str(err)
+ UTMESS('F', nompro, message)
+
+
+ # ------------------------------------------------------
+ # Recuperation des tableaux des derivees (SENSIBILITE)
+ L_deriv={}
+ if len(LIST_SENSI)>0:
+ _lon = 0
+ for _para in LIST_SENSI:
+ _lon += len(LIST_DERIV[_para])
+ _TBD = [None]*_lon
+
+ i = 0
+ for _para in LIST_SENSI:
+
+ L_deriv[_para] = []
+ _lst_tbl = LIST_DERIV[_para][0]
+
+ for _lst_tbl in LIST_DERIV[_para]:
+ j = LIST_DERIV[_para].index(_lst_tbl)
+ _tbl = _lst_tbl[0]
+
+ if __commandes_aster__:
+
+ # Version par des commandes Aster
+ # -------
+
+ DEFI_FICHIER(UNITE=_ul_libre, FICHIER=tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+str(int(100+len(reponses)+1+i)),);
+ _TBD[i]=LIRE_TABLE(UNITE=_ul_libre,
+ FORMAT='ASTER',
+ NUME_TABLE=1,
+ SEPARATEUR=' ',);
+ DEFI_FICHIER(ACTION='LIBERER', UNITE=_ul_libre,);
+ tREPONSE=_TBD[i].EXTR_TABLE()
+ DF = tREPONSE.Array( str(LIST_DERIV[_para][j][1]), str(LIST_DERIV[_para][j][2]) )
+ L_deriv[_para].append(DF)
+ i+=1
+
+ else:
+
+ # Version par utilisation directe du python de lire_table
+ # -------
+
+ # Chemin vers le fichier contenant la table
+ _fic_table = tmp_macr_recal+os.sep+"REPE_TABLE"+os.sep+"fort."+str(int(100+len(reponses)+1+i))
+
+ try:
+ file=open(_fic_table,'r')
+ texte=file.read()
+ file.close()
+ except Exception, err:
+ message = """Impossible de recuperer les resultats de calcul esclave (lecture des tables)!
+Le calcul esclave n'a pas du se terminer correctement (ajouter un repertoire en Resultat avec
+le type repe et voir l'output du fichier esclave dans ce repertoire.
+Message:
+"""
+ message += str(err)
+ UTMESS('F', nompro, message)
+
+ try:
+ ier, message, table_lue = lecture_table(texte, 1, ' ')
+ list_para = table_lue.para
+ tab_lue = table_lue.values()
+ except Exception, err:
+ ier=1
+ message = "Impossible de recuperer les resultats de calcul esclave (lecture des tables)!\nMessage:\n" + str(err)
+
+
+ if ier!=0 :
+ UTMESS('F', nompro, message)
+
+ try:
+ nb_val = len(tab_lue[ list_para[0] ])
+ DF = Numeric.zeros((nb_val,2), Numeric.Float)
+ for k in range(nb_val):
+# DF[k][0] = tab_lue[ list_para[0] ][1][k]
+# DF[k][1] = tab_lue[ list_para[1] ][1][k]
+ DF[k][0] = tab_lue[ str(LIST_DERIV[_para][j][1]) ][k]
+ DF[k][1] = tab_lue[ str(LIST_DERIV[_para][j][2]) ][k]
+ L_deriv[_para].append(DF)
+ i+=1
+ except Exception, err:
+ message = "Impossible de recuperer les resultats de calcul esclave (recuperation des tables)!\nMessage:\n" + str(err)
+ UTMESS('F', nompro, message)
+
+
+ # Nettoyage du export
+ try: os.remove(self.new_export)
+ except: pass
+
+ # Nettoyage du repertoire temporaire
+ if self.METHODE == 'EXTERNE': listdir = ['REPE_TABLE', 'base', 'REPE_IN']
+ else: listdir = ['.', 'REPE_TABLE', 'base', 'REPE_OUT', 'REPE_IN']
+ for dir in listdir:
+ try:
+ for fic in os.listdir(tmp_macr_recal+os.sep+dir):
+ try: os.remove(tmp_macr_recal+os.sep+dir+os.sep+fic)
+ except: pass
+ except: pass
+
+
+
+ # ----------------------------------------------------------------------------------
+ # Ou bien on inclue le fichier Esclave
+
+ elif mode_include:
+
+ if debug: os.system('cp fort.'+str(UL)+' REPE_OUT/')
+
+ INCLUDE(UNITE = UL)
+
+ Lrep = self.g_context['Lrep']
+ L_deriv = None
+
+ # Destruction des concepts Aster
+ reca_utilitaires.detr_concepts(self)
+
+
+ # ----------------------------------------------------------------------------------
+ # Ou alors probleme ?
+ else: sys.exit(1)
+
+
+ del(Fichier_Resu)
+
+ # on remet le fichier dans son etat initial
+ x=open('fort.'+str(UL),'w')
+ x.writelines(fichiersauv)
+ x.close()
+
+ return Lrep, L_deriv
+
+
+
+ # ------------------------------------------------------------------------------
+
+ def calcul_FG(self, val):
+
+ self.L, self.L_deriv_sensible = self.calcul_Aster(val, INFO=self.INFO)
+ self.L_J, self.erreur = self.Simul.multi_interpole(self.L, self.reponses)
+ if not self.L_J_init: self.L_J_init = copy.copy(self.L_J)
+ self.J = self.Simul.norme_J(self.L_J_init, self.L_J, self.UNITE_RESU)
+
+ # Calcul des derivees
+ self.A_nodim = self.Simul.sensibilite(self, self.L, self.L_deriv_sensible, val, self.PARA_DIFF_FINI)
+
+# print 50*'+'
+# print self.A_nodim
+# print 50*'+'
+# print 50*'+'
+# print 'self.L=', self.L
+# print 50*'+'
+# print 'self.reponses=', self.reponses
+# print 50*'+'
+# print 'self.resu_exp=', self.Simul.resu_exp
+# print 50*'+'
+# print 'self.L_J=', self.L_J
+# print 50*'+'
+# print 'self.erreur=', self.erreur
+# print 50*'+'
+
+# A_nodim = copy.copy(self.A_nodim)
+ self.A = self.Dim.adim_sensi( copy.copy(self.A_nodim) )
+# self.residu = self.reca_algo.test_convergence(self.gradient_init, self.erreur, self.A, Numeric.zeros(len(self.gradient_init),Numeric.Float) )
+ self.residu = 0.
+
+# print 50*'+'
+# print self.A_nodim
+# print 50*'+'
+# print self.A
+# print 50*'+'
+# print "Numeric.sum(self.A_nodim,0)=", Numeric.sum(self.A_nodim,0)
+# print "Numeric.sum(self.A,0)=", Numeric.sum(self.A,0)
+
+ if self.vector_output:
+ return self.erreur, self.residu, self.A_nodim, self.A
+ else:
+ # norme de l'erreur
+ self.norme = Numeric.dot(self.erreur, self.erreur)**0.5
+
+ self.norme_A_nodim = Numeric.zeros( (1,len(self.para)), Numeric.Float )
+ self.norme_A = Numeric.zeros( (1,len(self.para)), Numeric.Float )
+ for c in range(len(self.A[0,:])):
+ norme_A_nodim = 0
+ norme_A = 0
+ for l in range(len(self.A[:,0])):
+ norme_A_nodim += self.A_nodim[l,c] * self.A_nodim[l,c]
+ norme_A += self.A[l,c] * self.A[l,c]
+ self.norme_A_nodim[0,c] = math.sqrt( norme_A_nodim )
+ self.norme_A[0,c] = math.sqrt( norme_A )
+
+# print self.norme_A_nodim
+# print self.norme_A
+
+ return self.norme, self.residu, self.norme_A_nodim, self.norme_A
+
+
+ # ------------------------------------------------------------------------------
+
+ def calcul_F(self, val):
+
+ self.L, self.L_deriv_sensible = self.calcul_Aster(val, INFO=self.INFO)
+ L_J, erreur = self.Simul.multi_interpole(self.L, self.reponses)
+ if not self.L_J_init: self.L_J_init = copy.copy(L_J)
+ J = self.Simul.norme_J(self.L_J_init, L_J, self.UNITE_RESU)
+
+ # norme de l'erreur
+ norme = Numeric.sum( [x**2 for x in erreur] )
+
+ if debug:
+ print 'erreur=', erreur
+ print "norme de l'erreur=", norme
+ print "norme de J (fonctionnelle)=", str(J)
+
+ if self.INFO>=1:
+ txt = "Informations de convergence :"
+ txt += '\n=======================================================\n'
+ if self.evaluation_fonction >1: txt += "\n Nombre d'evaluation de la fonction = " + str(self.evaluation_fonction)
+ txt += "\n=> Fonctionnelle = "+str(J)
+
+ if self.vector_output:
+ if self.INFO>=1:
+ txt += "\n=> Norme de l'erreur = " + str(norme)
+ txt += '\n=======================================================\n'
+ UTMESS('I','MACR_RECAL',txt)
+ return erreur
+ else:
+ if self.INFO>=1:
+ txt += "\n=> Erreur = " + str(norme)
+ txt += '\n=======================================================\n'
+ UTMESS('I','MACR_RECAL',txt)
+ return norme
+
+# if self.error_output:
+# print "erreur:", erreur
+# return erreur
+# else:
+# print "norme:", norme
+# return norme
+
+
+
+ # ------------------------------------------------------------------------------
+
+ def calcul_G(self, val):
+
+ # Si le calcul Aster est deja effectue pour val on ne le refait pas
+ if (self.val == val) and self.L and self.L_deriv_sensible: pass
+ else:
+ self.L, self.L_deriv_sensible = self.calcul_Aster(val, INFO=self.INFO)
+ A = self.Simul.sensibilite(self, self.L, self.L_deriv_sensible, val, self.PARA_DIFF_FINI)
+ A = self.Dim.adim_sensi(A)
+ L_J, erreur = self.Simul.multi_interpole(self.L, self.reponses)
+ grad = Numeric.dot(Numeric.transpose(A),erreur)
+ if debug: print 'grad=', grad
+ print 'grad=', grad
+ return grad
+
+
+ # ------------------------------------------------------------------------------
+
+ def Creation_Temporaire_Esclave(self):
+ """
+ Creation du repertoire temporaire d'execution du calcul esclace
+ """
+
+
+ # Creation du repertoire temporaire
+ tmp_macr_recal = os.getcwd() + os.sep + 'tmp_macr_recal'
+ try: os.mkdir(tmp_macr_recal)
+ except: pass
+ if not os.path.exists(tmp_macr_recal): UTMESS('F','MACR_RECAL',"Probleme : Impossible de creer le repertoire temporaire : " + tmp_macr_recal)
+ try: os.mkdir(tmp_macr_recal + os.sep + 'REPE_TABLE')
+ except: pass
+ if not os.path.exists(tmp_macr_recal + os.sep + 'REPE_TABLE'): UTMESS('F','MACR_RECAL',"Probleme : Impossible de creer le repertoire temporaire : " + tmp_macr_recal + os.sep + 'REPE_TABLE')
+
+ return tmp_macr_recal
+
+
+ # ------------------------------------------------------------------------------
+
+ def Creation_Fichier_Export_Esclave(self, tmp_macr_recal):
+ """
+ Creation du fichier .export pour le calcul esclave
+ """
+
+ from as_profil import ASTER_PROFIL
+
+ # Recuperation du fichier .export
+ list_export = glob('*.export')
+
+ if len(list_export) == 0: UTMESS('F','MACR_RECAL',"Probleme : il n'y a pas de fichier .export dans le repertoire de travail!")
+ elif len(list_export) >1: UTMESS('F','MACR_RECAL',"Probleme : il y a plus d'un fichier .export dans le repertoire de travail!")
+
+ # On modifie le profil
+ prof = ASTER_PROFIL(list_export[0])
+
+ # xterm
+ if prof.param.has_key('xterm'):
+ del prof.param['xterm']
+ # memjeveux
+ prof.args['memjeveux'] = self.memjeveux_esclave
+
+ # fichier/répertoire
+ for lab in ('data', 'resu'):
+ l_fr = getattr(prof, lab)
+ l_tmp = l_fr[:]
+
+ for dico in l_tmp:
+
+ print dico
+
+ # répertoires
+ if dico['isrep']:
+
+ # base non prise en compte
+ if dico['type'] in ('base', 'bhdf'):
+ l_fr.remove(dico)
+
+ if lab == 'resu':
+ dico['path'] = os.path.join(tmp_macr_recal, os.path.basename(dico['path']))
+
+ # fichiers
+ else:
+
+ # Nom du fichier .mess (pour recuperation dans REPE_OUT)
+ if dico['ul'] == '6':
+ self.nom_fichier_mess_fils = os.path.basename(dico['path'])
+# self.nom_fichier_mess_fils = os.path.join(os.getcwd(), 'fort.%d' % self.UL)
+
+ # Nom du fichier .resu (pour recuperation dans REPE_OUT)
+ if dico['ul'] == '8':
+ self.nom_fichier_resu_fils = os.path.basename(dico['path'])
+
+ # Ancien .comm non pris en compte
+ # Fichier d'unite logique UNITE_RESU (rapport de MACR_RECAL) non pris en compte
+ if dico['type'] == 'comm' or (dico['ul'] == str(self.UNITE_RESU) and lab == 'resu'):
+ l_fr.remove(dico)
+
+ # Fichier d'unite logique UL devient le nouveau .comm
+ elif dico['ul'] == str(self.UL):
+ self.fichier_esclave = dico['path']
+ dico['type'] = 'comm'
+ dico['ul'] = '1'
+ dico['path'] = os.path.join(os.getcwd(), 'fort.%d' % self.UL)
+
+ # Tous les autres fichiers en Resultat
+ elif lab == 'resu':
+ if self.UNITE_GRAPHIQUE and dico['ul'] == str(self.UNITE_GRAPHIQUE): l_fr.remove(dico)
+ else:
+ dico['path'] = os.path.join(tmp_macr_recal, os.path.basename(dico['path']))
+
+ # Tous les autres fichiers en Donnees
+ elif lab == 'data':
+ dico['path'] = os.path.join(os.getcwd(), 'fort.%s' % dico['ul'])
+
+ # sinon on garde la ligne
+ setattr(prof, lab, l_fr)
+
+ # Ecriture du nouveau fichier export
+ prof.WriteExportTo(self.new_export)
+
+# os.system('cp ' + self.new_export + ' /tmp')
+
+ # --FIN CLASSE ----------------------------------------------------------------------------
+
+
+
--- /dev/null
+#@ MODIF reca_controles Macro DATE 31/10/2006 AUTEUR ASSIRE A.ASSIRE
+# -*- coding: iso-8859-1 -*-
+# RESPONSABLE ASSIRE A.ASSIRE
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2006 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, copy, Numeric, types, os, sys, pprint
+
+try:
+ from Utilitai.Utmess import UTMESS
+except ImportError:
+ def UTMESS(code,sprg,texte):
+ fmt='\n <%s> <%s> %s\n\n'
+ print fmt % (code,sprg,texte)
+ if code=='F': sys.exit()
+
+
+# Nom de la routine
+nompro = 'MACR_RECAL'
+
+
+
+#_____________________________________________
+#
+# CONTROLE DES ENTREES UTILISATEUR
+#_____________________________________________
+
+# ------------------------------------------------------------------------------
+
+def erreur_de_type(code_erreur,X):
+ #code_erreur ==0 --> X est une liste
+ #code erreur ==1 --> X est un char
+ #code erreur ==2 --> X est un float
+ #test est un boolean (test = 0 défaut et 1 si un test if est verifier
+ txt=""
+ if(code_erreur == 0 ):
+ if type(X) is not types.ListType:
+ txt="\nCette entrée: " +str(X)+" n'est pas une liste valide"
+ if(code_erreur == 1 ):
+ if type(X) is not types.StringType:
+ txt="\nCette entrée: " +str(X)+" n'est pas une chaine de caractère valide ; Veuillez la ressaisir en lui appliquant le type char de python"
+ if(code_erreur == 2 ):
+ if type(X) is not types.FloatType:
+ txt="\nCette entrée: " +str(X)+" n'est pas une valeur float valide ; Veuillez la ressaisir en lui appliquant le type float de python"
+ return txt
+
+
+# ------------------------------------------------------------------------------
+
+def erreur_dimension(PARAMETRES,REPONSES):
+#On verifie que la dimension de chaque sous_liste de parametre est 4
+#et que la dimension de chaque sous_liste de REPONSES est 3
+ txt=""
+ for i in range(len(PARAMETRES)):
+ if (len(PARAMETRES[i]) != 4):
+ txt=txt + "\nLa sous-liste de la variable paramètre numéro " + str(i+1)+" n'est pas de longueur 4"
+ for i in range(len(REPONSES)):
+ if (len(REPONSES[i]) != 3):
+ txt=txt + "\nLa sous-liste de la variable réponse numéro " + str(i+1)+" n'est pas de longueur 3"
+ return txt
+
+
+# ------------------------------------------------------------------------------
+
+def compare__dim_rep__dim_RESU_EXP(REPONSES,RESU_EXP):
+ # X et Y sont deux arguments qui doivent avoir la meme dimension
+ # pour éviter l'arret du programme
+ txt=""
+ if( len(REPONSES) != len(RESU_EXP)):
+ txt="\nVous avez entré " +str(len(REPONSES))+ " réponses et "+str(len(RESU_EXP))+ " expériences ; On doit avoir autant de réponses que de résultats expérimentaux"
+ return txt
+
+
+# ------------------------------------------------------------------------------
+
+def compare__dim_poids__dim_RESU_EXP(POIDS,RESU_EXP):
+ # POIDS et Y sont deux arguments qui doivent avoir la meme dimension
+ # pour éviter l'arret du programme
+ txt=""
+ if( len(POIDS) != len(RESU_EXP)):
+ txt="\nVous avez entré " +str(len(POIDS))+ " poids et "+str(len(RESU_EXP))+ " expériences ; On doit avoir autant de poids que de résultats expérimentaux"
+ return txt
+
+
+# ------------------------------------------------------------------------------
+
+def verif_fichier(UL,PARAMETRES,REPONSES):
+#On verifie les occurences des noms des PARAMETRES et REPONSES
+#dans le fichier de commande ASTER
+ txt=""
+
+ try:
+ fichier = open('fort.'+str(UL),'r')
+ fic=fichier.read()
+ except:
+ txt += "\nImpossible d'ouvrir le fichier esclave declare avec l'unite logique " + str(UL)
+ return txt
+ for i in range(len(PARAMETRES)):
+ if((string.find(fic,PARAMETRES[i][0])==-1) or ((string.find(fic,PARAMETRES[i][0]+'=')==-1) and (string.find(fic,PARAMETRES[i][0]+' ')==-1))):
+ txt += "\nLe paramètre "+PARAMETRES[i][0]+" que vous avez entré pour la phase d'optimisation n'a pas été trouvé dans votre fichier de commandes ASTER"
+ for i in range(len(REPONSES)):
+ if((string.find(fic,REPONSES[i][0])==-1) or ((string.find(fic,REPONSES[i][0]+'=')==-1) and (string.find(fic,REPONSES[i][0]+' ')==-1))):
+ txt += "\nLa réponse "+REPONSES[i][0]+" que vous avez entrée pour la phase d'optimisation n'a pas été trouvée dans votre fichier de commandes ASTER"
+ return txt
+
+
+# ------------------------------------------------------------------------------
+
+def verif_valeurs_des_PARAMETRES(PARAMETRES):
+#On verifie que pour chaque PARAMETRES de l'optimisation
+# les valeurs entrées par l'utilisateur sont telles que :
+# val_inf<val_sup
+# val_init appartient à [borne_inf, borne_sup]
+# val_init!=0
+# borne_sup!=0
+# borne_inf!=0
+ txt=""
+ #verification des bornes
+ for i in range(len(PARAMETRES)):
+ if( PARAMETRES[i][2] >PARAMETRES[i][3]):
+ txt=txt + "\nLa borne inférieure "+str(PARAMETRES[i][2])+" de "+PARAMETRES[i][0]+ "est plus grande que sa borne supérieure"+str(PARAMETRES[i][3])
+ #verification de l'encadrement de val_init
+ for i in range(len(PARAMETRES)):
+ if( (PARAMETRES[i][1] < PARAMETRES[i][2]) or (PARAMETRES[i][1] > PARAMETRES[i][3])):
+ txt=txt + "\nLa valeur initiale "+str(PARAMETRES[i][1])+" de "+PARAMETRES[i][0]+ " n'est pas dans l'intervalle [borne_inf,born_inf]=["+str(PARAMETRES[i][2])+" , "+str(PARAMETRES[i][3])+"]"
+ #verification que val_init !=0
+ for i in range(len(PARAMETRES)):
+ if (PARAMETRES[i][1] == 0. ):
+ txt=txt + "\nProblème de valeurs initiales pour le paramètre "+PARAMETRES[i][0]+" : ne pas donner de valeur initiale nulle mais un ordre de grandeur."
+ #verification que borne_sup !=0
+ for i in range(len(PARAMETRES)):
+ if (PARAMETRES[i][3] == 0. ):
+ txt=txt + "\nProblème de borne supérieure pour le paramètre "+PARAMETRES[i][0]+" : ne pas donner de valeur strictement nulle."
+ #verification que borne_inf !=0
+ for i in range(len(PARAMETRES)):
+ if (PARAMETRES[i][2] == 0. ):
+ txt=txt + "\nProblème de borne inférieure pour le paramètre "+PARAMETRES[i][0]+" : ne pas donner de valeur strictement nulle."
+ return txt
+
+
+# ------------------------------------------------------------------------------
+
+def verif_UNITE(GRAPHIQUE,UNITE_RESU):
+ # On vérifie que les unités de résultat et
+ # de graphique sont différentes
+ txt=""
+ if GRAPHIQUE:
+ GRAPHE_UL_OUT=GRAPHIQUE['UNITE']
+ if (GRAPHE_UL_OUT==UNITE_RESU):
+ txt=txt + "\nLes unités logiques des fichiers de résultats graphiques et de résultats d'optimisation sont les memes."
+ return txt
+
+
+# ------------------------------------------------------------------------------
+
+def gestion(UL,PARAMETRES,REPONSES,RESU_EXP,POIDS,GRAPHIQUE,UNITE_RESU,METHODE):
+ #Cette methode va utiliser les methodes de cette classe declarée ci-dessus
+ #test est un boolean: test=0 -> pas d'erreur
+ # test=1 -> erreur détectée
+
+ texte=""
+ #On vérifie d'abord si PARAMETRES, REPONSES, RESU_EXP sont bien des listes au sens python
+ #test de PARAMETRES
+ texte = texte + erreur_de_type(0,PARAMETRES)
+ #test de REPONSES
+ texte = texte + erreur_de_type(0,REPONSES)
+ #test de RESU_EXP
+ texte = texte + erreur_de_type(0,RESU_EXP)
+
+ #On vérifie si chaque sous liste de PARAMETRES, REPONSES, possède le type adéquat
+ #test des sous_listes de PARAMETRES
+ for i in range(len(PARAMETRES)):
+ texte = texte + erreur_de_type(0,PARAMETRES[i])
+ #test des sous_listes de REPONSES
+ for i in range(len(REPONSES)):
+ texte = texte + erreur_de_type(0,REPONSES[i])
+
+ #On verifie si la dimension de chaque sous-liste de : PARAMETRES, REPONSES
+ #il faut que:la dimension d'une sous-liste de PARAMETRES = 4
+ #et que la dimension d'une sous liste de REPONSES = 3
+ texte = texte + erreur_dimension(PARAMETRES,REPONSES)
+
+ #on verifie que l'on a autant de réponses que de résultats expérimentaux
+ texte = texte + compare__dim_rep__dim_RESU_EXP(REPONSES,RESU_EXP)
+ #on verifie que l'on a autant de poids que de résultats expérimentaux
+ texte = texte + compare__dim_poids__dim_RESU_EXP(POIDS,RESU_EXP)
+
+ #on verifie les types des arguments de chaque sous liste de PARAMETRES et REPONSES
+ #verification du type stringet type float des arguments de PARAMETRES
+ for i in range(len(PARAMETRES)):
+ texte = texte + erreur_de_type(1,PARAMETRES[i][0])
+ for k in [1,2,3]:
+ texte = texte + erreur_de_type(2,PARAMETRES[i][k])
+
+ #verification du type string pour les arguments de REPONSES
+ for i in range(len(REPONSES)):
+ for j in range(len(REPONSES[i])):
+ texte = texte + erreur_de_type(1,REPONSES[i][j])
+
+ #verification du fichier de commndes ASTER
+ if METHODE != 'EXTERNE': # pour celui-ci le fort.UL n'est pas l'esclave... voir comment faire
+ texte = texte + verif_fichier(UL,PARAMETRES,REPONSES)
+
+ #verification des valeurs des PARAMETRES entrées par l'utilisteur
+ if METHODE == 'LEVENBERG':
+ texte = texte + verif_valeurs_des_PARAMETRES(PARAMETRES)
+
+ #verification des unités logiques renseignées par l'utilisateur
+ if METHODE != 'EXTERNE':
+ texte = texte + verif_UNITE(GRAPHIQUE,UNITE_RESU)
+
+ return texte
+
-#@ MODIF reca_interp Macro DATE 05/09/2005 AUTEUR DURAND C.DURAND
+#@ MODIF reca_interp Macro DATE 31/10/2006 AUTEUR ASSIRE A.ASSIRE
# -*- coding: iso-8859-1 -*-
+# RESPONSABLE ASSIRE A.ASSIRE
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
-import os
+import os, sys, pprint
import Numeric
-import Macro
-from Macro.recal import calcul_F
-from Utilitai.Utmess import UTMESS
+
+try: import Macro
+except: pass
+
+try:
+ from Utilitai.Utmess import UTMESS
+except ImportError:
+ def UTMESS(code,sprg,texte):
+ fmt='\n <%s> <%s> %s\n\n'
+ print fmt % (code,sprg,texte)
+ if code=='F': sys.exit()
+
#===========================================================================================
self.resu_exp = result_exp
self.poids = poids
-# Distance verticale d'un point M à une ligne brisée composée de n points
-
+# ------------------------------------------------------------------------------
+
+ def InterpolationLineaire (self, x0, points) :
+ """
+ Interpolation Lineaire de x0 sur la fonction discrétisée yi=points(xi) i=1,..,n
+ """
+ # x0 = Une abscisse (1 colonne, 1 ligne)
+ # points = Tableau de n points (2 colonnes, n lignes)
+ # on suppose qu'il existe au moins 2 points,
+ # et que les points sont classés selon les abscisses croissantes
+
+ n = len(points)
+ if ( x0 < points[0][0] ) or ( x0 > points[n-1][0] ) :
+ txt = "Problème lors de l'interpolation du calcul dérivé sur les données expérimentale!"
+ txt += "\nValeur à interpoler : " + str(x0)
+ txt += "\nDomaine couvert par l'experience : [" + str(points[0][0]) + ":" + str(points[n-1][0]) + "]"
+ UTMESS('F','MACR_RECAL', txt)
+
+ i = 1
+ while x0 > points[i][0]:
+ i = i+1
+
+ y0 = (x0-points[i-1][0]) * (points[i][1]-points[i-1][1]) / (points[i][0]-points[i-1][0]) + points[i-1][1]
+
+ return y0
+
+
+
+
+# ------------------------------------------------------------------------------
+
def DistVertAdimPointLigneBrisee (self, M, points) :
- # M = Point (2 colonnes, 1 ligne)
- # points = Tableau de n points (2 colonnes, n lignes)
- # on suppose qu'il existe au moins 2 points,
- # et que les points sont classés selon les abscisses croissantes
- n = len(points)
- if ( M[0] < points[0][0] ) or ( M[0] > points[n-1][0] ) :
- return 0.
- i = 1
- while M[0] > points[i][0] :
- i = i+1
- y_proj_vert = (M[0]-points[i-1][0]) * (points[i][1]-points[i-1][1]) / (points[i][0]-points[i-1][0]) + points[i-1][1]
- d = (M[1] - y_proj_vert)
- # Attention: la distance n'est pas normalisée
- # Attention: problème si points[0][0] = points[1][0] = M[0]
- # Attention: problème si M[1] = 0
- return d
-
-
-# La Fonction Interpole ,interpole une et une seule F_calc sur F_exp et renvoie l'erreur seulement
- def Interpole (self, F_calc,experience,poids) : #ici on passe en argument "une" experience
+ """
+ Distance verticale d'un point M à une ligne brisée composée de n points
+ """
+ # M = Point (2 colonnes, 1 ligne)
+ # points = Tableau de n points (2 colonnes, n lignes)
+ # on suppose qu'il existe au moins 2 points,
+ # et que les points sont classés selon les abscisses croissantes
+ n = len(points)
+ if ( M[0] < points[0][0] ) or ( M[0] > points[n-1][0] ):
+ return 0.
+ i = 1
+ while M[0] > points[i][0]:
+ i = i+1
+ y_proj_vert = (M[0]-points[i-1][0]) * (points[i][1]-points[i-1][1]) / (points[i][0]-points[i-1][0]) + points[i-1][1]
+ d = (M[1] - y_proj_vert)
+ # Attention: la distance n'est pas normalisée
+ # Attention: problème si points[0][0] = points[1][0] = M[0]
+ # Attention: problème si M[1] = 0
+ return d
+
+
+# ------------------------------------------------------------------------------
+
+ def _Interpole(self, F_calc,experience,poids) : #ici on passe en argument "une" experience
+ """
+ La Fonction Interpole interpole une et une seule F_calc sur F_exp et renvoie l'erreur seulement
+ """
+
n = 0
resu_num = F_calc
n_exp = len(experience) # nombre de points sur la courbe expérimentale num.i
stockage[n] = d/experience[j][1]
except ZeroDivisionError:
stockage[n] = d
+
n = n + 1 # on totalise le nombre de points valables
err = Numeric.ones(n, Numeric.Float)
+
for i in xrange(n) :
err[i] = poids*stockage[i]
return err
- #cette fonction appelle la fonction interpole et retourne les sous fonctionnelle J et l'erreur
- def multi_interpole(self,L_F, reponses): #on interpole toutes les reponses une à une en appelent la methode interpole
+
+# ------------------------------------------------------------------------------
+
+ def multi_interpole(self, L_F, reponses):
+ """
+ Cette fonction appelle la fonction interpole et retourne les sous-fonctionnelles J et l'erreur.
+ On interpole toutes les reponses une à une en appelant la methode interpole.
+ """
+
L_erreur=[]
for i in range(len(reponses)):
- err = self.Interpole(L_F[i],self.resu_exp[i],self.poids[i])
+ err = self._Interpole(L_F[i],self.resu_exp[i],self.poids[i])
L_erreur.append(err)
- #on transforme L_erreur en tab num
+
+# print "L_erreur=", L_erreur
+
+ # On transforme L_erreur en tab num
dim=[]
J=[]
for i in range(len(L_erreur)):
del(L_erreur) #on vide la liste puisqu'on n'en a plus besoin
return L_J,erreur
- #cette fonction retourne seulement l'erreur ,je l'appelle dans la methode sensibilité
- #on interpole toutes les reponses une à une en appelent la methode interpole
- def multi_interpole_sensib(self,L_F,reponses):
+
+# ------------------------------------------------------------------------------
+
+ def multi_interpole_sensib(self, L_F, reponses):
+ """
+ Cette fonction retourne seulement l'erreur, elle est appelée dans la methode sensibilité.
+ On interpole toutes les reponses une à une en appelant la methode interpole.
+ """
+
L_erreur=[]
for i in range(len(reponses)):
- err = self.Interpole(L_F[i],self.resu_exp[i],self.poids[i])
+ err = self._Interpole(L_F[i], self.resu_exp[i], self.poids[i])
L_erreur.append(err)
- #on transforme L_erreur en tab num
+ # On transforme L_erreur en tab num
return L_erreur
+
+# ------------------------------------------------------------------------------
+
def calcul_J(self,L_erreur):
L_J = []
for i in range(len(L_erreur)):
total = total + L_erreur[i][j]**2
L_J.append(total)
return L_J
-
- def norme_J(self,L_J_init,L_J,unite_resu):
- #cette fonction calcul une valeur normée de J
+
+
+# ------------------------------------------------------------------------------
+
+ def norme_J(self,L_J_init,L_J,unite_resu=None):
+ """
+ Cette fonction calcul une valeur normée de J
+ """
for i in range(len(L_J)):
try:
L_J[i] = L_J[i]/L_J_init[i]
except ZeroDivisionError:
message= 'Problème de division par zéro dans la normalisation de la fonctionnelle.\n'
message=message+'Une des valeurs de la fonctionnelle initiale est nulle ou inférieure à la précision machine : %.2f \n'%L_J_init
- fic=open(os.getcwd()+'/fort.'+str(unite_resu),'a')
- fic.write(message)
- fic.close()
+ if unite_resu:
+ fic=open(os.getcwd()+'/fort.'+str(unite_resu),'a')
+ fic.write(message)
+ fic.close()
UTMESS('F', "MACR_RECAL", message)
-
+ return
+
J = Numeric.sum(L_J)
J = J/len(L_J)
- return J
-
- def sensibilite(self,objet,UL,F,val,para,reponses,pas,unite_resu):
- F_interp=self.multi_interpole_sensib(F, reponses) #F_interp est une liste contenant des tab num des reponses interpolés
- L_A=[] #creation de la liste des matrices de sensibilités
+ return J
+
+
+# ------------------------------------------------------------------------------
+
+# def sensibilite(self,objet,UL,F,L_deriv_sensible,val,para,reponses,pas,unite_resu,LIST_SENSI=[],LIST_DERIV=[],INFO=1):
+
+ def sensibilite(self, CALCUL_ASTER, F, L_deriv_sensible, val, pas):
+
+ # CALCUL_ASTER est l'objet regroupant le calcul de F et des derivées, ainsi que les options
+ UL = CALCUL_ASTER.UL
+ para = CALCUL_ASTER.para
+ reponses = CALCUL_ASTER.reponses
+ unite_resu = CALCUL_ASTER.UNITE_RESU
+ LIST_SENSI = CALCUL_ASTER.LIST_SENSI
+ LIST_DERIV = CALCUL_ASTER.LIST_DERIV
+ INFO = CALCUL_ASTER.INFO
+
+
+
+ # Erreur de l'interpolation de F_interp : valeur de F interpolée sur les valeurs experimentales
+ F_interp = self.multi_interpole_sensib(F, reponses) #F_interp est une liste contenant des tab num des reponses interpolés
+
+ # Creation de la liste des matrices de sensibilités
+ L_A=[]
for i in range(len(reponses)):
L_A.append(Numeric.zeros((len(self.resu_exp[i]),len(val)),Numeric.Float) )
- #calcul de la sensibilité
- fic=open(os.getcwd()+'/fort.'+str(unite_resu),'a')
- fic.write('\nCalcul de la sensibilité par rapport à :')
- fic.close()
- for k in range(len(val)): #pour une colone de A
- h = val[k]*pas
- val[k] = val[k] + h
- F_perturbe = calcul_F(objet,UL,para,val,reponses)
- fic=open(os.getcwd()+'/fort.'+str(unite_resu),'a')
- fic.write(' '+para[k])
- fic.close()
- F_perturbe_interp =self.multi_interpole_sensib(F_perturbe, reponses)
- val[k] = val[k] - h
- for j in range(len(reponses)):
- for i in range(len(self.resu_exp[j])):
- try:
- L_A[j][i,k] = -1*(F_interp[j][i] - F_perturbe_interp[j][i])/h
- except ZeroDivisionError:
- message= 'Probleme de division par zéro dans le calcul de la matrice de sensiblité\n '
- message=message+'Le parametre '+para[k]+'est nul ou plus petit que la précision machine \n'
- fic=open(os.getcwd()+'/fort.'+str(unite_resu),'a')
- fic.write(message)
- fic.close()
- UTMESS('F', "MACR_RECAL", message)
- #on construit la matrice de sensiblité sous forme d'un tab num
+
+ for k in range(len(val)): # pour une colone de A (dim = nb parametres)
+
+ # On utilise les differences finies pour calculer la sensibilité
+ # --------------------------------------------------------------
+ # Dans ce cas, un premier calcul_Aster pour val[k] a deja ete effectué, on effectue un autre calcul_Aster pour val[k]+h
+
+ if para[k] not in LIST_SENSI:
+
+ # Message
+ if INFO>=2: UTMESS('I','MACR_RECAL','On utilise les differences finies pour calculer la sensibilite de : %s ' % para[k])
+
+ fic=open(os.getcwd()+'/fort.'+str(unite_resu),'a')
+ fic.write('\nCalcul de la sensibilité par differences finies pour : '+para[k])
+ fic.close()
+
+ # Perturbation
+ h = val[k]*pas
+ val[k] = val[k] + h
+
+ # Calcul_Aster pour la valeur perturbée
+ F_perturbe, L_deriv = CALCUL_ASTER.calcul_Aster(val)
+
+ # Erreur de l'interpolation de F_perturb : valeur de F (perturbée) interpolée sur les valeurs experimentales
+ F_perturbe_interp =self.multi_interpole_sensib(F_perturbe, reponses)
+
+ # On replace les parametres a leurs valeurs initiales
+ val[k] = val[k] - h
+
+ # Calcul de L_A (matrice sensibilité des erreurs sur F interpolée)
+ for j in range(len(reponses)):
+ for i in range(len(self.resu_exp[j])):
+ try:
+ L_A[j][i,k] = -1*(F_interp[j][i] - F_perturbe_interp[j][i])/h
+ except ZeroDivisionError:
+ fic=open(os.getcwd()+'/fort.'+str(unite_resu),'a')
+ fic.write('\n Probleme de division par zéro dans le calcul de la matrice de sensiblité')
+ fic.write('\n Le parametre '+para[k]+'est nul ou plus petit que la précision machine')
+ fic.close()
+ UTMESS('F','MACR_RECAL',"Probleme de division par zéro dans le calcul de la matrice de sensiblité.\n Le parametre "+para[k]+"est nul ou plus petit que la précision machine")
+ return
+
+
+ # On utilise le calcul de SENSIBILITE
+ # --------------------------------------------------------------
+ # Dans ce cas, L_deriv_sensible a deja ete calculé pour le premier calcul pour val[k], aucun autre calcul_F n'est a lancer
+ else:
+ if INFO>=2: UTMESS('I','MACR_RECAL','On utilise le calcul de SENSIBILITE pour : %s ' % para[k])
+
+ # Message
+ fic=open(os.getcwd()+'/fort.'+str(unite_resu),'a')
+ fic.write('\nCalcul de la sensibilité par la SENSIBILITE pour : '+para[k])
+ fic.close()
+
+ L_deriv_sensible_interp = L_deriv_sensible
+
+ # Calcul de L_A (matrice sensibilité des erreurs sur F interpolée)
+ for j in range(len(reponses)):
+ for i in range(len(self.resu_exp[j])):
+
+ # On interpole la fonction derivée aux points experimentaux
+ val_derivee_interpolee = self.InterpolationLineaire( self.resu_exp[j][i][0], L_deriv_sensible_interp[ para[k] ][:][j] )
+
+ # Application du poids de la reponse courante j
+ val_derivee_interpolee = val_derivee_interpolee*self.poids[j]
+
+ try:
+ L_A[j][i,k] = -1.* ( val_derivee_interpolee ) / self.resu_exp[j][i][1]
+ except ZeroDivisionError:
+ L_A[j][i,k] = -1.* ( val_derivee_interpolee )
+
+ # fin
+ # --------------------------------------------------------------
+
+ # On construit la matrice de sensiblité sous forme d'un tab num
dim =[]
for i in range(len(L_A)):
dim.append(len(L_A[i]))
for i in range(dim[n]):
A[i+a][k] = L_A[n][i,k]
a=dim[n]
- del(L_A) #on ecrase tout ce qu'il y a dans L_A puisqu'on n'en a plus besoin
- return A
-
+ del(L_A) # On ecrase tout ce qu'il y a dans L_A puisqu'on n'en a plus besoin
+ return A
-#@ MODIF reca_message Macro DATE 14/09/2004 AUTEUR MCOURTOI M.COURTOIS
+#@ MODIF reca_message Macro DATE 31/10/2006 AUTEUR ASSIRE A.ASSIRE
# -*- coding: iso-8859-1 -*-
+# RESPONSABLE ASSIRE A.ASSIRE
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
-import os,Numeric
+import os, Numeric
+
+try:
+ from Utilitai.Utmess import UTMESS
+except:
+ def UTMESS(code,sprg,texte):
+ fmt='\n <%s> <%s> %s\n\n'
+ print fmt % (code,sprg,texte)
+ if code=='F': sys.exit()
#===========================================================================================
class Message :
"""classe gérant l'affichage des messages concernant le déroulement de l'optmisation """
#Constructeur de la classe
+
+# ------------------------------------------------------------------------------
+
def __init__(self,para,val_init,resu_exp,ul_out):
self.nom_para = para
- self.res_exp = resu_exp
- res=open(os.getcwd()+'/fort.'+str(ul_out),'a')
- res.write(' <INFO> MACR_RECAL V1.1 \n\n\n')
+ self.resu_exp = resu_exp
+ self.val_init = val_init
+ self.resu_exp = resu_exp
+ self.ul_out = ul_out
+
+# ------------------------------------------------------------------------------
+
+ def initialise(self):
+ res=open(os.getcwd()+'/fort.'+str(self.ul_out),'w')
res.close()
-
+
+ txt = ' <INFO> MACR_RECAL\n\n'
+ self.ecrire(txt)
+
+# ------------------------------------------------------------------------------
- def affiche_result_iter(self,iter,J,val,residu,Act,ul_out):
- res=open(os.getcwd()+'/fort.'+str(ul_out),'a')
- res.write('\n=======================================================\n')
- res.write('Iteration '+str(iter)+' :\n')
- res.write('\n=> Fonctionnelle = '+str(J))
- res.write('\n=> Résidu = '+str(residu))
- res.write('\n=> Paramètres = ')
+ def ecrire(self,txt):
+ res=open(os.getcwd()+'/fort.'+str(self.ul_out),'a')
+ res.write(txt+'\n')
+ res.flush()
+ res.close()
+
+
+# ------------------------------------------------------------------------------
+
+ def affiche_valeurs(self,val):
+
+ txt = '\n=> Paramètres = '
for i in range(len(val)):
- res.write('\n '+ self.nom_para[i]+' = '+str(val[i]) )
+ txt += '\n '+ self.nom_para[i]+' = '+str(val[i])
+ self.ecrire(txt)
+
+# ------------------------------------------------------------------------------
+
+ def affiche_fonctionnelle(self,J):
+
+ txt = '\n=> Fonctionnelle = '+str(J)
+ self.ecrire(txt)
+
+# ------------------------------------------------------------------------------
+
+ def affiche_result_iter(self,iter,J,val,residu,Act=[],):
+
+ txt = '\n=======================================================\n'
+ txt += 'Iteration '+str(iter)+' :\n'
+ txt += '\n=> Fonctionnelle = '+str(J)
+ txt += '\n=> Résidu = '+str(residu)
+
+ self.ecrire(txt)
+
+ txt = ''
+ self.affiche_valeurs(val)
+
if (len(Act)!=0):
if (len(Act)==1):
- res.write('\n\n Le paramètre ')
+ txt += '\n\n Le paramètre '
else:
- res.write('\n\n Les paramètres ')
+ txt += '\n\n Les paramètres '
for i in Act:
- res.write(self.nom_para[i]+' ')
+ txt += self.nom_para[i]+' '
if (len(Act)==1):
- res.write('\n est en butée sur un bord de leur domaine admissible.')
+ txt += '\n est en butée sur un bord de leur domaine admissible.'
else:
- res.write('\n sont en butée sur un bord de leur domaine admissible.')
- res.write('\n=======================================================\n\n')
- res.close()
-
- def affiche_etat_final_convergence(self,iter,max_iter,prec,residu,Act,ul_out):
- res=open(os.getcwd()+'/fort.'+str(ul_out),'a')
- if ((iter < max_iter) or (residu < prec)):
- res.write('\n=======================================================\n')
- res.write(' CONVERGENCE ATTEINTE ')
+ txt += '\n sont en butée sur un bord de leur domaine admissible.'
+ txt += '\n=======================================================\n\n'
+ self.ecrire(txt)
+
+
+# ------------------------------------------------------------------------------
+
+ def affiche_etat_final_convergence(self,iter,max_iter,iter_fonc,max_iter_fonc,prec,residu,Act=[]):
+
+ txt = ''
+ if ((iter <= max_iter) or (residu <= prec) or (iter_fonc <= max_iter_fonc) ):
+ txt += '\n=======================================================\n'
+ txt += ' CONVERGENCE ATTEINTE '
if (len(Act)!=0):
- res.write("\n\n ATTENTION : L'OPTIMUM EST ATTEINT AVEC ")
- res.write("\n DES PARAMETRES EN BUTEE SUR LE BORD ")
- res.write("\n DU DOMAINE ADMISSIBLE ")
- res.write('\n=======================================================\n')
- res.close()
+ txt += "\n\n ATTENTION : L'OPTIMUM EST ATTEINT AVEC "
+ txt += "\n DES PARAMETRES EN BUTEE SUR LE BORD "
+ txt += "\n DU DOMAINE ADMISSIBLE "
+ txt += '\n=======================================================\n'
else:
- res.write("\n=======================================================\n")
- res.write(' CONVERGENCE NON ATTEINTE ')
- res.write("\n Le nombre maximal d'itération ("+str(max_iter)+") a été dépassé")
- res.write('\n=======================================================\n')
- res.close()
-
- def affiche_calcul_etat_final(self,para,Hessien,valeurs_propres,vecteurs_propres,sensible,insensible,ul_out):
- res=open(os.getcwd()+'/fort.'+str(ul_out),'a')
- res.write('\n\nValeurs propres du Hessien:\n')
- res.write(str( valeurs_propres))
- res.write('\n\nVecteurs propres associés:\n')
- res.write(str( vecteurs_propres))
- res.write('\n\n --------')
- res.write('\n\nOn peut en déduire que :')
+ txt += "\n=======================================================\n"
+ txt += ' CONVERGENCE NON ATTEINTE '
+ if (iter > max_iter):
+ txt += "\n Le nombre maximal d'itération ("+str(max_iter)+") a été dépassé"
+ if (iter_fonc > max_iter_fonc):
+ txt += "\n Le nombre maximal d'evaluation de la fonction ("+str(max_iter_fonc)+") a été dépassé"
+ txt += '\n=======================================================\n'
+ self.ecrire(txt)
+
+
+# ------------------------------------------------------------------------------
+
+ def affiche_calcul_etat_final(self,para,Hessien,valeurs_propres,vecteurs_propres,sensible,insensible):
+
+ txt = '\n\nValeurs propres du Hessien:\n'
+ txt += str( valeurs_propres)
+ txt += '\n\nVecteurs propres associés:\n'
+ txt += str( vecteurs_propres)
+ txt += '\n\n --------'
+ txt += '\n\nOn peut en déduire que :'
# Paramètres sensibles
if (len(sensible)!=0):
- res.write('\n\nLes combinaisons suivantes de paramètres sont prépondérantes pour votre calcul :\n')
+ txt += '\n\nLes combinaisons suivantes de paramètres sont prépondérantes pour votre calcul :\n'
k=0
for i in sensible:
k=k+1
colonne=vecteurs_propres[:,i]
numero=Numeric.nonzero(Numeric.greater(abs(colonne/max(abs(colonne))),1.E-1))
- res.write('\n '+str(k)+') ')
+ txt += '\n '+str(k)+') '
for j in numero:
- res.write('%+3.1E ' %colonne[j]+'* '+para[j]+' ')
- res.write('\n associée à la valeur propre %3.1E \n' %valeurs_propres[i])
+ txt += '%+3.1E ' %colonne[j]+'* '+para[j]+' '
+ txt += '\n associée à la valeur propre %3.1E \n' %valeurs_propres[i]
# Paramètres insensibles
if (len(insensible)!=0):
- res.write('\n\nLes combinaisons suivantes de paramètres sont insensibles pour votre calcul :\n')
+ txt += '\n\nLes combinaisons suivantes de paramètres sont insensibles pour votre calcul :\n'
k=0
for i in insensible:
k=k+1
colonne=vecteurs_propres[:,i]
numero=Numeric.nonzero(Numeric.greater(abs(colonne/max(abs(colonne))),1.E-1))
- res.write('\n '+str(k)+') ')
+ txt += '\n '+str(k)+') '
for j in numero:
- res.write('%+3.1E ' %colonne[j]+'* '+para[j]+' ')
- res.write('\n associée à la valeur propre %3.1E \n' %valeurs_propres[i])
- res.close()
+ txt += '%+3.1E ' %colonne[j]+'* '+para[j]+' '
+ txt += '\n associée à la valeur propre %3.1E \n' %valeurs_propres[i]
-
+ self.ecrire(txt)
--- /dev/null
+#@ MODIF reca_utilitaires Macro DATE 31/10/2006 AUTEUR ASSIRE A.ASSIRE
+# -*- coding: iso-8859-1 -*-
+# RESPONSABLE ASSIRE A.ASSIRE
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2006 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 Numeric, LinearAlgebra, copy, os, string, types, sys, glob
+from Numeric import take
+
+try:
+ from Cata.cata import INFO_EXEC_ASTER, DEFI_FICHIER, IMPR_FONCTION, DETRUIRE
+ from Accas import _F
+except: pass
+
+try: import Gnuplot
+except: pass
+
+try:
+ from Utilitai.Utmess import UTMESS
+except ImportError:
+ def UTMESS(code,sprg,texte):
+ fmt='\n <%s> <%s> %s\n\n'
+ print fmt % (code,sprg,texte)
+ if code=='F': sys.exit()
+
+
+
+# ------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+
+#_____________________________________________
+#
+# DIVERS UTILITAIRES POUR LA MACRO
+#_____________________________________________
+
+
+def transforme_list_Num(parametres,res_exp):
+ """
+ Transforme les données entrées par l'utilisateur en tableau Numeric
+ """
+
+ dim_para = len(parametres) #donne le nb de parametres
+ val_para = Numeric.zeros(dim_para,Numeric.Float)
+ borne_inf = Numeric.zeros(dim_para,Numeric.Float)
+ borne_sup = Numeric.zeros(dim_para,Numeric.Float)
+ para = []
+ for i in range(dim_para):
+ para.append(parametres[i][0])
+ val_para[i] = parametres[i][1]
+ borne_inf[i] = parametres[i][2]
+ borne_sup[i] = parametres[i][3]
+ return para,val_para,borne_inf,borne_sup
+
+
+# ------------------------------------------------------------------------------
+
+def mes_concepts(list_concepts=[],base=None):
+ """
+ Fonction qui liste les concepts créés
+ """
+ for e in base.etapes:
+ if e.nom in ('INCLUDE','MACR_RECAL',) :
+ list_concepts=list(mes_concepts(list_concepts=list_concepts,base=e))
+ elif (e.sd != None) and (e.parent.nom=='INCLUDE') :
+ nom_concept=e.sd.get_name()
+ if not(nom_concept in list_concepts):
+ list_concepts.append( nom_concept )
+ return tuple(list_concepts)
+
+
+# ------------------------------------------------------------------------------
+
+def detr_concepts(self):
+ """
+ Fonction qui detruit les concepts créés
+ """
+ liste_concepts=mes_concepts(base=self.parent)
+ for e in liste_concepts:
+ nom = string.strip(e)
+ DETRUIRE( CONCEPT =self.g_context['_F'](NOM = nom), INFO=1, ALARME='NON')
+ if self.jdc.g_context.has_key(nom) : del self.jdc.g_context[nom]
+ del(liste_concepts)
+
+
+# ------------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+#_____________________________________________
+#
+# CALCUL DU TEMPS CPU RESTANT
+#_____________________________________________
+
+
+#def temps_CPU(self,restant_old,temps_iter_old):
+def temps_CPU(restant_old,temps_iter_old):
+ """
+ Fonction controlant le temps CPU restant
+ """
+ CPU=INFO_EXEC_ASTER(LISTE_INFO = ("CPU_RESTANT",))
+ TEMPS=CPU['CPU_RESTANT',1]
+ DETRUIRE(CONCEPT=_F(NOM='CPU'),INFO=1)
+ err=0
+ # Indique une execution interactive
+ if (TEMPS>1.E+9):
+ return 0.,0.,0
+ # Indique une execution en batch
+ else:
+ restant=TEMPS
+ # Initialisation
+ if (restant_old==0.):
+ temps_iter=-1.
+ else:
+ # Première mesure
+ if (temps_iter_old==-1.):
+ temps_iter=(restant_old-restant)
+ # Mesure courante
+ else:
+ temps_iter=(temps_iter_old + (restant_old-restant))/2.
+ if ((temps_iter>0.96*restant)or(restant<0.)):
+ err=1
+ UTMESS('F','MACR_RECAL',"Arret de MACR_RECAL par manque de temps CPU.")
+
+ return restant,temps_iter,err
+
+
+
+
+#_____________________________________________
+#
+# IMPRESSIONS GRAPHIQUES
+#_____________________________________________
+
+
+def graphique(FORMAT, L_F, res_exp, reponses, iter, UL_out, interactif, fichier=None, INFO=0):
+
+ if iter: txt_iter = 'Iteration : ' + str(iter)
+ else: txt_iter = ''
+
+ # Le try/except est la pour eviter de planter betement dans un trace de courbes (DISPLAY non defini, etc...)
+ try:
+ if FORMAT=='XMGRACE':
+ for i in range(len(L_F)):
+ _tmp = []
+ courbe1 = res_exp[i]
+ _tmp.append( { 'ABSCISSE': courbe1[:,0].tolist(), 'ORDONNEE': courbe1[:,1].tolist(), 'COULEUR': 1 } )
+ courbe2 = L_F[i]
+ _tmp.append( { 'ABSCISSE': courbe2[:,0].tolist(), 'ORDONNEE': courbe2[:,1].tolist(), 'COULEUR': 2 } )
+
+ motscle2= {'COURBE': _tmp }
+ if interactif: motscle2['PILOTE']= 'INTERACTIF'
+ else: motscle2['PILOTE']= 'POSTSCRIPT'
+
+ IMPR_FONCTION(FORMAT='XMGRACE',
+ UNITE=int(UL_out),
+ TITRE='Courbe de : ' + reponses[i][0],
+ SOUS_TITRE=txt_iter,
+ LEGENDE_X=reponses[i][1],
+ LEGENDE_Y=reponses[i][2],
+ **motscle2
+ );
+
+ elif FORMAT=='GNUPLOT':
+ if INFO>=2: UTMESS('I','MACR_RECAL',"Trace des courbes dans le fichier " + fichier )
+
+ if fichier:
+ # On efface les anciens graphes
+ liste = glob.glob(fichier + '*.ps')
+ for fic in liste:
+ try: os.remove(fic)
+ except: pass
+
+ graphe=[]
+ impr=Gnuplot.Gnuplot()
+ Gnuplot.GnuplotOpts.prefer_inline_data=1
+ impr('set data style linespoints')
+ impr('set grid')
+ impr('set pointsize 2.')
+ impr('set terminal postscript color')
+ impr('set output "fort.'+str(UL_out)+'"')
+
+ for i in range(len(L_F)):
+ graphe.append(Gnuplot.Gnuplot(persist=0))
+ graphe[i]('set data style linespoints')
+ graphe[i]('set grid')
+ graphe[i]('set pointsize 2.')
+ graphe[i].xlabel(reponses[i][1])
+ graphe[i].ylabel(reponses[i][2])
+ graphe[i].title(reponses[i][0]+' ' + txt_iter)
+ graphe[i].plot(Gnuplot.Data(L_F[i],title='Calcul'),Gnuplot.Data(res_exp[i],title='Experimental'))
+ if interactif:
+ graphe[i]('pause 5')
+ else:
+ if fichier:
+ if INFO>=2: UTMESS('I','MACR_RECAL',"Trace des courbes dans le fichier " + fichier + '_' + str(i) + '.ps' )
+ graphe[i].hardcopy(fichier + '_' + str(i) + '.ps', enhanced=1, color=1)
+
+ impr.xlabel(reponses[i][1])
+ impr.ylabel(reponses[i][2])
+ impr.title(reponses[i][0]+' Iteration '+str(iter))
+ impr.plot(Gnuplot.Data(L_F[i],title='Calcul'),Gnuplot.Data(res_exp[i],title='Experimental'))
+
+ except Exception, err:
+ UTMESS('A','MACR_RECAL',"Probleme lors de l'affichage des courbes. On ignore et on continue. Erreur :\n" + str(err) )
+
-#@ MODIF recal Macro DATE 08/11/2005 AUTEUR ASSIRE A.ASSIRE
+#@ MODIF recal Macro DATE 29/08/2006 AUTEUR MCOURTOI M.COURTOIS
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
import string, copy, Numeric, types
-# import Gnuplot
import Cata
-from Cata.cata import INCLUDE, DETRUIRE, FIN, EXEC_LOGICIEL, DEFI_FICHIER, IMPR_TABLE, LIRE_TABLE, INFO_EXEC_ASTER, EXTR_TABLE
-from Utilitai.Utmess import UTMESS
-from Accas import _F
-
-import os, aster, cPickle, sys
-
-# try:
-# import Gnuplot
-# except: pass
-
-try:
- from Utilitai.Utmess import UTMESS
-except ImportError:
- def UTMESS(code,sprg,texte):
- fmt='\n <%s> <%s> %s\n\n'
- print fmt % (code,sprg,texte)
+from Cata.cata import INCLUDE, DETRUIRE
#_____________________________________________
txt="\nVous avez entré " +str(len(REPONSES))+ " réponses et "+str(len(RESU_EXP))+ " expériences ; On doit avoir autant de réponses que de résultats expérimentaux"
return txt
+def verif_RESU_EXP(RESU_EXP):
+ # RESU_EXP doit etre une liste de tableaux Numeric de taille Nx2
+ # pour éviter l'arret du programme
+ txt=""
+ for index,resu in enumerate(RESU_EXP):
+ if (isinstance(resu,Numeric.ArrayType)):
+ if (len(Numeric.shape(resu)) != 2):
+ txt="\nLa courbe experimentale no " +str(index+1)+ " n'est pas un tableau de N lignes et 2 colonnes."
+ else:
+ if (Numeric.shape(resu)[1] != 2):
+ txt="\nLa courbe experimentale no " +str(index+1)+ " n'est pas un tableau de N lignes et 2 colonnes."
+ else:
+ txt="\nLa courbe experimentale no " +str(index+1)+ " n'est pas un tableau Numeric."
+ return txt
+
def compare__dim_poids__dim_RESU_EXP(POIDS,RESU_EXP):
# POIDS et Y sont deux arguments qui doivent avoir la meme dimension
# pour éviter l'arret du programme
#et que la dimension d'une sous liste de REPONSES = 3
texte = texte + erreur_dimension(PARAMETRES,REPONSES)
+ #on verifie le type et la dimension des résultats expérimentaux
+ texte = texte + verif_RESU_EXP(RESU_EXP)
#on verifie que l'on a autant de réponses que de résultats expérimentaux
texte = texte + compare__dim_rep__dim_RESU_EXP(REPONSES,RESU_EXP)
#on verifie que l'on a autant de poids que de résultats expérimentaux
--- /dev/null
+#@ MODIF simu_point_mat_ops Macro DATE 10/10/2006 AUTEUR REZETTE C.REZETTE
+# -*- coding: iso-8859-1 -*-
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2006 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 simu_point_mat_ops(self, COMP_INCR, MATER, INCREMENT, NEWTON,CONVERGENCE,
+ SUIVI_DDL,SIGM_IMPOSE,EPSI_IMPOSE, INFO, **args) :
+
+ """Simulation de la reponse d'un point materiel"""
+
+ ier = 0
+ # La macro compte pour 1 dans la numerotation des commandes
+ self.set_icmd(1)
+
+ # On importe les definitions des commandes a utiliser dans la macro
+ # Le nom de la variable doit etre obligatoirement le nom de la commande
+ DEFI_FONCTION = self.get_cmd('DEFI_FONCTION')
+ LIRE_MAILLAGE = self.get_cmd('LIRE_MAILLAGE')
+ AFFE_MATERIAU = self.get_cmd('AFFE_MATERIAU')
+ AFFE_MODELE = self.get_cmd('AFFE_MODELE')
+ AFFE_CHAR_MECA = self.get_cmd('AFFE_CHAR_MECA')
+ STAT_NON_LINE = self.get_cmd('STAT_NON_LINE')
+ STAT_NON_LINE = self.get_cmd('STAT_NON_LINE')
+ POST_RELEVE_T = self.get_cmd('POST_RELEVE_T')
+ CALC_TABLE = self.get_cmd('CALC_TABLE')
+ CALC_ELEM = self.get_cmd('CALC_ELEM')
+
+ from Accas import _F
+ from Utilitai.UniteAster import UniteAster
+
+
+# -- Tests de cohérence
+ __fonczero = DEFI_FONCTION(NOM_PARA = 'INST',
+ VALE = ( 0,0, 10,0 ),PROL_DROITE='CONSTANT',PROL_GAUCHE='CONSTANT')
+
+ EPS={}
+ SIG={}
+
+ CMP_EPS=['EPXX','EPYY','EPZZ','EPXY','EPXZ','EPYZ']
+ CMP_SIG=['SIXX','SIYY','SIZZ','SIXY','SIXZ','SIYZ']
+
+ if SIGM_IMPOSE:
+ SIG=SIGM_IMPOSE[0].cree_dict_valeurs(SIGM_IMPOSE[0].mc_liste)
+ for i in SIG.keys():
+ if SIG[i]==None : SIG[i]=__fonczero
+ else:
+ for i in range(6):
+ SIG[CMP_SIG[i]]=__fonczero
+
+ if EPSI_IMPOSE:
+ EPS=EPSI_IMPOSE[0].cree_dict_valeurs(EPSI_IMPOSE[0].mc_liste)
+# for i in EPS.keys():
+# if EPS[i]==None : EPS[i]=__fonczero
+ else:
+ for i in range(6):
+ EPS[CMP_EPS[i]]=None
+
+ for index in range(6):
+ iks=CMP_SIG[index]
+ ike=CMP_EPS[index]
+ if EPS[ike]!=None and SIG[iks] != __fonczero :
+ raise ' un seul parmi :' + str(iks) +' '+ str(ike)
+
+# print 'EPS=',EPS
+# print 'SIG=',SIG
+# -- Definition du maillage
+
+ texte_ma = """
+ COOR_3D
+ P0 0.0 0.0 0.0
+ P1 1.0 0.0 0.0
+ P2 0.0 1.0 0.0
+ P3 0.0 0.0 1.0
+ FINSF
+ TRIA3
+ F1 P0 P3 P2
+ F2 P0 P1 P3
+ F3 P0 P2 P1
+ F4 P1 P2 P3
+ FINSF
+ TETRA4
+ VOLUME = P0 P1 P2 P3
+ FINSF
+ FIN
+ """
+ UL = UniteAster()
+ umail = UL.Libre(action='ASSOCIER', nom='simu.mail' )
+
+ fi_mail = open('simu.mail','w')
+ fi_mail.write(texte_ma)
+ fi_mail.close()
+
+ __MA = LIRE_MAILLAGE(UNITE=umail)
+ UL.EtatInit()
+
+
+# -- Materiau et modele
+
+ __CHMAT = AFFE_MATERIAU(
+ MAILLAGE = __MA,
+ AFFE = _F(
+ MAILLE = 'VOLUME',
+ MATER = MATER
+ )
+ )
+
+
+ __MO = AFFE_MODELE(
+ MAILLAGE = __MA,
+ AFFE = _F(
+ MAILLE = ('VOLUME','F1','F2','F3','F4'),
+ PHENOMENE = 'MECANIQUE',
+ MODELISATION = '3D'
+ )
+ )
+
+
+# -- Mouvement de corps rigide
+
+ __C_RIGIDE = AFFE_CHAR_MECA(
+ MODELE = __MO,
+ DDL_IMPO = _F(NOEUD = 'P0',DX = 0,DY = 0,DZ = 0),
+ LIAISON_DDL = (
+ _F(NOEUD=('P2','P1'),DDL=('DX','DY'),COEF_MULT=(1,-1),COEF_IMPO=0),
+ _F(NOEUD=('P3','P1'),DDL=('DX','DZ'),COEF_MULT=(1,-1),COEF_IMPO=0),
+ _F(NOEUD=('P3','P2'),DDL=('DY','DZ'),COEF_MULT=(1,-1),COEF_IMPO=0),
+ )
+ )
+
+# -- Chargement en deformation
+
+ __E = [None]*6
+
+ __E[0] = AFFE_CHAR_MECA(
+ MODELE = __MO,
+ DDL_IMPO = _F(NOEUD='P1', DX=1)
+ )
+
+ __E[1] = AFFE_CHAR_MECA(
+ MODELE = __MO,
+ DDL_IMPO = _F(NOEUD='P2', DY=1)
+ )
+
+ __E[2] = AFFE_CHAR_MECA(
+ MODELE = __MO,
+ DDL_IMPO = _F(NOEUD='P3', DZ=1)
+ )
+
+ __E[3] = AFFE_CHAR_MECA(
+ MODELE = __MO,
+ DDL_IMPO = _F(NOEUD='P1', DY=1)
+ )
+
+ __E[4] = AFFE_CHAR_MECA(
+ MODELE = __MO,
+ DDL_IMPO = _F(NOEUD='P1', DZ=1)
+ )
+
+ __E[5] = AFFE_CHAR_MECA(
+ MODELE = __MO,
+ DDL_IMPO = _F(NOEUD='P2', DZ=1)
+ )
+
+
+# -- Chargement en contrainte
+
+ __S = [None]*6
+
+ r33 = 3**-0.5
+
+ __S[0] = AFFE_CHAR_MECA(
+ MODELE = __MO,
+ FORCE_FACE = (
+ _F(MAILLE='F1', FX=-1),
+ _F(MAILLE='F4', FX= r33),
+ )
+ )
+
+ __S[1] = AFFE_CHAR_MECA(
+ MODELE = __MO,
+ FORCE_FACE = (
+ _F(MAILLE='F2', FY=-1),
+ _F(MAILLE='F4', FY= r33),
+ )
+ )
+
+ __S[2] = AFFE_CHAR_MECA(
+ MODELE = __MO,
+ FORCE_FACE = (
+ _F(MAILLE='F3', FZ=-1),
+ _F(MAILLE='F4', FZ= r33),
+ )
+ )
+
+ __S[3] = AFFE_CHAR_MECA(
+ MODELE = __MO,
+ FORCE_FACE = (
+ _F(MAILLE='F1', FY=-1),
+ _F(MAILLE='F2', FX=-1),
+ _F(MAILLE='F4', FX= r33, FY=r33),
+ )
+ )
+
+ __S[4] = AFFE_CHAR_MECA(
+ MODELE = __MO,
+ FORCE_FACE = (
+ _F(MAILLE='F1', FZ=-1),
+ _F(MAILLE='F3', FX=-1),
+ _F(MAILLE='F4', FX= r33, FZ=r33),
+ )
+ )
+
+ __S[5] = AFFE_CHAR_MECA(
+ MODELE = __MO,
+ FORCE_FACE = (
+ _F(MAILLE='F2', FZ=-1),
+ _F(MAILLE='F3', FY=-1),
+ _F(MAILLE='F4', FY= r33, FZ=r33),
+ )
+ )
+
+
+# -- Construction de la charge
+
+ l_char = [ _F(CHARGE=__C_RIGIDE) ]
+
+ for i in xrange(6) :
+ ike=CMP_EPS[i]
+ if EPS[ike]:
+ l_char.append( _F(CHARGE=__E[i],FONC_MULT=EPS[ike]) )
+
+ for i in xrange(6) :
+ iks=CMP_SIG[i]
+ l_char.append( _F(CHARGE=__S[i],FONC_MULT=SIG[iks]) )
+
+# -- Deroulement du calcul
+ motscles={}
+ motscles['COMP_INCR'] = COMP_INCR.List_F()
+ motscles['CONVERGENCE'] = CONVERGENCE.List_F()
+ motscles['NEWTON'] = NEWTON.List_F()
+ motscles['INCREMENT'] = INCREMENT.List_F()
+
+ if SUIVI_DDL :
+ motscles['SUIVI_DDL'] = SUIVI_DDL.List_F()
+
+
+ __EVOL = STAT_NON_LINE(
+ MODELE = __MO,
+ CHAM_MATER = __CHMAT,
+ EXCIT = l_char,
+ ARCHIVAGE = _F(ARCH_ETAT_INIT = 'OUI'),**motscles)
+
+
+ __EVOL = CALC_ELEM(reuse = __EVOL,
+ RESULTAT = __EVOL,
+ OPTION = ('SIEF_ELNO_ELGA','EPSI_ELNO_DEPL','VARI_ELNO_ELGA')
+ )
+
+
+# -- Recuperation des courbes
+
+ __REP_VARI = POST_RELEVE_T(
+ ACTION = (
+ _F(
+ INTITULE = 'VARI_INT',
+ RESULTAT = __EVOL,
+ NOM_CHAM = 'VARI_ELNO_ELGA',
+ TOUT_CMP = 'OUI',
+ OPERATION = 'EXTRACTION',
+ NOEUD = 'P0'
+ ),
+ )
+ )
+
+
+ __REP_EPSI = POST_RELEVE_T(
+ ACTION = (
+ _F(
+ INTITULE = 'EPSILON',
+ RESULTAT = __EVOL,
+ NOM_CHAM = 'EPSI_ELNO_DEPL',
+ TOUT_CMP = 'OUI',
+ OPERATION = 'EXTRACTION',
+ NOEUD = 'P0'
+ ),
+ )
+ )
+
+ __REP_SIGM = POST_RELEVE_T(
+ ACTION = (
+ _F(
+ INTITULE = 'SIGMA',
+ RESULTAT = __EVOL,
+ NOM_CHAM = 'SIEF_ELNO_ELGA',
+ TOUT_CMP = 'OUI',
+ OPERATION = 'EXTRACTION',
+ NOEUD = 'P0'
+ ),
+ )
+ )
+ self.DeclareOut('REPONSE',self.sd)
+ REPONSE=CALC_TABLE( TABLE=__REP_EPSI,
+ ACTION=_F(OPERATION='COMB',TABLE=__REP_SIGM,NOM_PARA=('INST'), ) )
+
+ REPONSE=CALC_TABLE(reuse=REPONSE, TABLE=REPONSE,
+ ACTION=_F(OPERATION='COMB',TABLE=__REP_VARI,NOM_PARA=('INST'), ) )
+
+
+ return ier
+
+
+
+
-#@ MODIF stanley_ops Macro DATE 15/05/2006 AUTEUR ASSIRE A.ASSIRE
+#@ MODIF stanley_ops Macro DATE 12/09/2006 AUTEUR ASSIRE A.ASSIRE
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
from Utilitai.Utmess import UTMESS
from Utilitai.UniteAster import UniteAster
+ prev_onFatalError = aster.onFatalError()
+ aster.onFatalError('EXCEPTION')
+
ier=0
# La macro compte pour 1 dans la numerotation des commandes
STANLEY(DISPLAY='adresse_ip:0.0');""")
+ aster.onFatalError(prev_onFatalError)
+
return ier
import os,sys
-import prefs
-import sys
-rep_macro = os.path.join(prefs.REPINI,'Cata/cataSTA8')
+sys.modules["Cata"]=sys.modules[__name__]
+rep_macro = os.path.dirname(__file__)
sys.path.insert(0,rep_macro)
+
from cata import *
from math import ceil
from Extensions import param2
-#& MODIF ENTETE DATE 22/05/2006 AUTEUR MCOURTOI M.COURTOIS
+#& MODIF ENTETE DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
pass
__version__="$Name: $"
-__Id__="$Id: cata.py,v 1.1.6.2 2006/06/20 12:14:36 pnoyret Exp $"
+__Id__="$Id: cata.py,v 1.2.4.3 2006/12/14 17:30:02 pnoyret Exp $"
EnumTypes = (ListType, TupleType)
class melasflu_sdaster(ASSD):pass
class nume_ddl_sdaster(ASSD):pass
class nume_ddl_gene (ASSD):pass
-class obstacle_sdaster(ASSD):pass
class sd_feti_sdaster (ASSD):pass
class spectre_sdaster (ASSD):pass
class surface_sdaster (ASSD):pass
raise Accas.AsException("Erreur dans mater.RCVALE en PAR_LOT='OUI'")
from Utilitai.Utmess import UTMESS
# vérification des arguments
- if not nompar in EnumTypes:
- nompar = tuple(nompar)
- if not valpar in EnumTypes:
- valpar = tuple(valpar)
- if not nomres in EnumTypes:
- nomres = tuple(nomres)
+ if not type(nompar) in EnumTypes:
+ nompar = [nompar,]
+ if not type(valpar) in EnumTypes:
+ valpar = [valpar,]
+ if not type(nomres) in EnumTypes:
+ nomres = [nomres,]
+ nompar = tuple(nompar)
+ valpar = tuple(valpar)
+ nomres = tuple(nomres)
if len(nompar) != len(valpar):
UTMESS('F', 'RCVALE', """Arguments incohérents :
Nom des paramètres : %s
else:
raise Accas.AsException("Le type de la matrice est incorrect")
ncham=nommacr+(8-len(nommacr))*' '+ext
- print ncham
desc=Numeric.array(aster.getvectjev(ncham+'_DESC'))
# On teste si le DESC du vecteur existe
class dyna_harmo (resultat_sdaster):pass
class dyna_trans (resultat_sdaster):pass
class fourier_elas (resultat_sdaster):pass
+class fourier_ther (resultat_sdaster):pass
class harm_gene (resultat_sdaster):pass
class mode_acou (resultat_sdaster):pass
class mode_cycl (resultat_sdaster):pass
if lbl == None:
UTMESS('F', 'fonction.Valeurs', "Objet '%s' inexistant" % vale)
lbl = list(lbl)
- dim=len(lbl)/2
- lx=lbl[0:dim]
- ly=lbl[dim:2*dim]
- return [lx,ly]
- elif hasattr(self,'etape') and self.etape.nom=='DEFI_FONCTION' :
- if self.etape['VALE']!=None:
- lbl=list(self.etape['VALE'])
- dim=len(lbl)
- lx=[lbl[i] for i in range(0,dim,2)]
- ly=[lbl[i] for i in range(1,dim,2)]
- return [lx,ly]
- elif self.etape['VALE_PARA']!=None:
- return [self.etape['VALE_PARA'].Valeurs(),self.etape['VALE_FONC'].Valeurs()]
- else :
- raise Accas.AsException("Erreur dans fonction.Valeurs en PAR_LOT='OUI'")
+ dim = len(lbl)/2
+ lx = lbl[0:dim]
+ ly = lbl[dim:2*dim]
+ elif hasattr(self, 'etape') and self.etape.nom == 'DEFI_FONCTION' :
+ if self.etape['VALE'] != None:
+ lbl = list(self.etape['VALE'])
+ dim = len(lbl)
+ lx = [lbl[i] for i in range(0,dim,2)]
+ ly = [lbl[i] for i in range(1,dim,2)]
+ elif self.etape['VALE_PARA']!=None:
+ lx = self.etape['VALE_PARA'].Valeurs()
+ ly = self.etape['VALE_FONC'].Valeurs()
+ else:
+ raise Accas.AsException("Erreur (fonction.Valeurs) : ne fonctionne en " \
+ "PAR_LOT='OUI' que sur des fonctions produites par DEFI_FONCTION " \
+ "dans le jdc courant.")
+ return [lx, ly]
def Absc(self):
"""Retourne la liste des abscisses"""
return self.Valeurs()[0]
Retourne trois listes de valeurs : abscisses, parties reelles et imaginaires.
"""
if not self.par_lot():
- vale = '%-19s.VALE' % self.get_name()
- lbl = aster.getvectjev(vale)
- if lbl == None:
- UTMESS('F', 'fonction.Valeurs', "Objet '%s' inexistant" % vale)
- lbl = list(lbl)
- dim=len(lbl)/3
- lx=lbl[0:dim]
- lr=[]
- li=[]
- for i in range(dim):
- lr.append(lbl[dim+2*i])
- li.append(lbl[dim+2*i+1])
- return [lx,lr,li]
- if self.etape.nom=='DEFI_FONCTION' :
- lbl=list(self.etape['VALE_C'])
- dim=len(lbl)
- lx=[lbl[i] for i in range(0,dim,3)]
- lr=[lbl[i] for i in range(1,dim,3)]
- li=[lbl[i] for i in range(2,dim,3)]
- return [lx,lr,li]
- else :
- raise Accas.AsException("Erreur dans fonction_c.Valeurs en PAR_LOT='OUI'")
+ vale = '%-19s.VALE' % self.get_name()
+ lbl = aster.getvectjev(vale)
+ if lbl == None:
+ UTMESS('F', 'fonction.Valeurs', "Objet '%s' inexistant" % vale)
+ lbl = list(lbl)
+ dim=len(lbl)/3
+ lx=lbl[0:dim]
+ lr=[]
+ li=[]
+ for i in range(dim):
+ lr.append(lbl[dim+2*i])
+ li.append(lbl[dim+2*i+1])
+ elif hasattr(self, 'etape') and self.etape.nom == 'DEFI_FONCTION':
+ lbl=list(self.etape['VALE_C'])
+ dim=len(lbl)
+ lx=[lbl[i] for i in range(0,dim,3)]
+ lr=[lbl[i] for i in range(1,dim,3)]
+ li=[lbl[i] for i in range(2,dim,3)]
+ else:
+ raise Accas.AsException("Erreur (fonction_c.Valeurs) : ne fonctionne en " \
+ "PAR_LOT='OUI' que sur des fonctions produites par DEFI_FONCTION " \
+ "dans le jdc courant.")
+ return [lx, lr, li]
def Absc(self):
"""Retourne la liste des abscisses"""
return self.Valeurs()[0]
return Table(lisdic, lpar, ltyp, titr)
# -----------------------------------------------------------------------------
+class table_fonction(table_sdaster):
+ """Table contenant en plus une colonne FONCTION et/ou FONCTION_C dont les
+ valeurs des cellules sont des noms de fonction_sdaster ou fonction_c.
+ """
+
class table_jeveux(table_sdaster):
"""Classe permettant d'accéder à une table jeveux qui n'a pas d'ASSD associée,
c'est le cas des concepts résultats (table, evol_xxxx) dérivés."""
class vect_elem_pres_r(vect_elem):pass
class vect_elem_temp_r(vect_elem):pass
-#& MODIF COMMUN DATE 09/05/2006 AUTEUR JMBHH01 J.M.PROIX
+#& MODIF COMMUN DATE 07/11/2006 AUTEUR MARKOVIC D.MARKOVIC
# CONFIGURATION MANAGEMENT OF EDF VERSION
# RESPONSABLE JMBHH01 J.M.PROIX
# ======================================================================
"VISC_ISOT_TRAC",
"VMIS_ISOT_LINE",
"VISC_ISOT_LINE",
+ "VMIS_ISOT_PUIS",
"VMIS_ECMI_TRAC",
"VMIS_ECMI_LINE",
"LABORD_1D",
"VMIS_CIN2_CHAB",
"VISC_CIN1_CHAB",
"VISC_CIN2_CHAB",
- "POLY_CFC",
"LMARC",
"LMARC_IRRA",
"ROUSSELIER",
"VMIS_ASYM_LINE",
"ELAS_THER",
"KIT_DDI",
- "GLRC",
+ "GLRC_DAMAGE",
+ "GLRC_DM",
"SANS",
"CORR_ACIER",
"MONOCRISTAL",
VISC_ISOT_TRAC =SIMP(statut='c',typ='I',defaut=3,into=(3,)),
VMIS_ISOT_LINE =SIMP(statut='c',typ='I',defaut=2,into=(2,)),
VISC_ISOT_LINE =SIMP(statut='c',typ='I',defaut=3,into=(3,)),
+ VMIS_ISOT_PUIS =SIMP(statut='c',typ='I',defaut=2,into=(2,)),
VMIS_ECMI_TRAC =SIMP(statut='c',typ='I',defaut=8,into=(8,)),
VMIS_ECMI_LINE =SIMP(statut='c',typ='I',defaut=8,into=(8,)),
LABORD_1D =SIMP(statut='c',typ='I',defaut=5,into=(5,)),
ENDO_ISOT_BETON =SIMP(statut='c',typ='I',defaut=2,into=(2,)),
ENDO_ORTH_BETON =SIMP(statut='c',typ='I',defaut=7,into=(7,)),
BETON_REGLE_PR =SIMP(statut='c',typ='I',defaut=1,into=(1,)),
- MAZARS =SIMP(statut='c',typ='I',defaut=3,into=(3,)),
+ MAZARS =SIMP(statut='c',typ='I',defaut=4,into=(4,)),
JOINT_BA =SIMP(statut='c',typ='I',defaut=6,into=(6,)),
RUPT_FRAG =SIMP(statut='c',typ='I',defaut=1,into=(1,)),
CZM_EXP_REG =SIMP(statut='c',typ='I',defaut=4,into=(4,)),
VMIS_CIN2_CHAB =SIMP(statut='c',typ='I',defaut=14,into=(14,)),
VISC_CIN1_CHAB =SIMP(statut='c',typ='I',defaut=8,into=(8,)),
VISC_CIN2_CHAB =SIMP(statut='c',typ='I',defaut=14,into=(14,)),
- POLY_CFC =SIMP(statut='c',typ='I',defaut=1688,into=(1688,)),
LMARC =SIMP(statut='c',typ='I',defaut=20,into=(20,)),
LMARC_IRRA =SIMP(statut='c',typ='I',defaut=20,into=(20,)),
VISC_TAHERI =SIMP(statut='c',typ='I',defaut=9,into=(9,)),
KIT_THHM =SIMP(statut='c',typ='I',defaut=0,into=(0,)),
VMIS_ASYM_LINE =SIMP(statut='c',typ='I',defaut=4,into=(4,)),
BETON_UMLV_FP =SIMP(statut='c',typ='I',defaut=21,into=(21,)),
- GLRC =SIMP(statut='c',typ='I',defaut=7,into=(7,)),
+ GLRC_DAMAGE =SIMP(statut='c',typ='I',defaut=21,into=(21,)),
+ GLRC_DM =SIMP(statut='c',typ='I',defaut=4,into=(4,)),
GATT_MONERIE =SIMP(statut='c',typ='I',defaut=2,into=(2,)),
b_monox = BLOC(condition = "RELATION == 'MONOCRISTAL' ",
"VMIS_ISOT_TRAC",
"VMIS_ISOT_LINE",
"VMIS_ISOT_CINE",
+ "VMIS_ISOT_PUIS",
"GRANGER_FP",
"GRANGER_FP_INDT",
"GRANGER_FP_V",
ZIRC =SIMP(statut='c',typ='I',defaut=3,into=(3,)),
DEFORMATION =SIMP(statut='f',typ='TXM',defaut="PETIT",
- into=("PETIT","PETIT_REAC","SIMO_MIEHE","GREEN_GR","GREEN","COROTATIONNEL")),
+ into=("PETIT","PETIT_REAC","SIMO_MIEHE","GREEN_GR","GREEN","COROTATIONNEL","REAC_GEOM")),
ALGO_C_PLAN =SIMP(statut='f',typ='TXM',defaut="ANALYTIQUE",into=("DEBORST","ANALYTIQUE",)),
ALGO_1D =SIMP(statut='f',typ='TXM',defaut="ANALYTIQUE",into=("DEBORST","ANALYTIQUE",)),
regles=(PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),),
ITER_INTE_PAS =SIMP(statut='f',typ='I',defaut= 0 ),
RESO_INTE =SIMP(statut='f',typ='TXM',defaut="IMPLICITE",
into=("RUNGE_KUTTA_2","RUNGE_KUTTA_4","IMPLICITE")),
+ PARM_THETA =SIMP(statut='f',typ='R',defaut= 1. ),
) ;
-#& MODIF COMMUN DATE 04/04/2006 AUTEUR CIBHHLV L.VIVAN
+#& MODIF COMMUN DATE 07/11/2006 AUTEUR CIBHHLV L.VIVAN
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2003 EDF R&D WWW.CODE-ASTER.ORG
"ACCE_ABSOLU",
"ALPH0_ELGA_EPSP",
"ALPHP_ELGA_ALPH0",
+ "ARCO_ELNO_SIGM",
+ "ARCO_NOEU_SIGM",
"COMPORTEMENT",
"COMPORTHER",
"CRIT_ELNO_RUPT",
"ENEL_ELNO_ELGA",
"ENEL_NOEU_ELGA",
"EPEQ_ELNO_TUYO",
- "EPGR_ELGA",
- "EPGR_ELNO",
+ "EPVC_ELGA",
+ "EPVC_ELNO",
+ "EPFD_ELGA",
+ "EPFD_ELNO",
+ "EPFP_ELGA",
+ "EPFP_ELNO",
"EPME_ELGA_DEPL",
"EPME_ELNO_DEPL",
"EPMG_ELGA_DEPL",
l.append(typ+"_"+gd)
return tuple(l)
-#& MODIF COMMANDE DATE 09/05/2006 AUTEUR JMBHH01 J.M.PROIX
+#& MODIF COMMANDE DATE 19/09/2006 AUTEUR A3BHHAE H.ANDRIAMBOLOLONA
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
EPAIS =SIMP(statut='o',typ='R' ),
ANGL_REP =SIMP(statut='f',typ='R',min=2,max=2),
+ VECTEUR =SIMP(statut='f',typ='R',min=3,max=3),
A_CIS =SIMP(statut='c',typ='R',defaut= 0.8333333E0),
COEF_RIGI_DRZ =SIMP(statut='f',typ='R',defaut= 1.0E-5 ),
COQUE_NCOU =SIMP(statut='f',typ='I',defaut= 1 ),
# affection des caractéristiques de RIGIDITE/AMORTISSEMENT
b_K_T_D_N =BLOC(condition = "(CARA=='K_T_D_N')or(CARA=='A_T_D_N')",
- regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),),
+ regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+ AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('VALE','VALE_F',),),
NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
- VALE =SIMP(statut='o',typ='R',min=3 ,max=3 ),),
+ VALE =SIMP(statut='f',typ='R',min=3 ,max=3 ),
+ VALE_F =SIMP(statut='f',typ=(para_sensi,),min=3 ,max=3 ),),
b_K_T_D_L =BLOC(condition = "(CARA=='K_T_D_L')or(CARA=='A_T_D_L')",
- regles=(UN_PARMI('MAILLE','GROUP_MA'),),
+ regles=(UN_PARMI('MAILLE','GROUP_MA'),
+ AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('VALE','VALE_F',),),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
- VALE =SIMP(statut='o',typ='R',min=3 ,max=3 ),),
+ VALE =SIMP(statut='f',typ='R',min=3 ,max=3 ),
+ VALE_F =SIMP(statut='f',typ=(para_sensi,),min=3 ,max=3 ),),
b_K_TR_D_N =BLOC(condition = "(CARA=='K_TR_D_N')or(CARA=='A_TR_D_N')",
- regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),),
+ regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+ AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('VALE','VALE_F',),),
NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
- VALE =SIMP(statut='o',typ='R',min=6 ,max=6 ),),
+ VALE =SIMP(statut='f',typ='R',min=6 ,max=6 ),
+ VALE_F =SIMP(statut='f',typ=(para_sensi,),min=6 ,max=6 ),),
b_K_TR_D_L =BLOC(condition = "(CARA=='K_TR_D_L')or(CARA=='A_TR_D_L')",
- regles=(UN_PARMI('MAILLE','GROUP_MA'),),
+ regles=(UN_PARMI('MAILLE','GROUP_MA'),
+ AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('VALE','VALE_F',),),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
- VALE =SIMP(statut='o',typ='R',min=6 ,max=6 ),),
+ VALE =SIMP(statut='f',typ='R',min=6 ,max=6 ),
+ VALE_F =SIMP(statut='f',typ=(para_sensi,),min=6 ,max=6 ),),
b_K_T_N =BLOC(condition = "(CARA=='K_T_N')or(CARA=='A_T_N')",
- regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),),
+ regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+ AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('VALE','VALE_F',),),
NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
- VALE =SIMP(statut='o',typ='R',min=6 ,max=6 ),),
+ VALE =SIMP(statut='f',typ='R',min=6 ,max=6 ),
+ VALE_F =SIMP(statut='f',typ=(para_sensi,),min=6 ,max=6 ),),
b_K_T_L =BLOC(condition = "(CARA=='K_T_L')or(CARA=='A_T_L')",
- regles=(UN_PARMI('MAILLE','GROUP_MA'),),
+ regles=(UN_PARMI('MAILLE','GROUP_MA'),
+ AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('VALE','VALE_F',),),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
- VALE =SIMP(statut='o',typ='R',min=21,max=21),),
+ VALE =SIMP(statut='f',typ='R',min=21,max=21),
+ VALE_F =SIMP(statut='f',typ=(para_sensi,),min=21 ,max=21 ),),
b_K_TR_N =BLOC(condition = "(CARA=='K_TR_N')or(CARA=='A_TR_N')",
- regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),),
+ regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+ AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('VALE','VALE_F',),),
NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
- VALE =SIMP(statut='o',typ='R',min=21,max=21),),
+ VALE =SIMP(statut='f',typ='R',min=21,max=21),
+ VALE_F =SIMP(statut='f',typ=(para_sensi,),min=21 ,max=21 ),),
b_K_TR_L =BLOC(condition = "(CARA=='K_TR_L')or(CARA=='A_TR_L')",
- regles=(UN_PARMI('MAILLE','GROUP_MA'),),
+ regles=(UN_PARMI('MAILLE','GROUP_MA'),
+ AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('VALE','VALE_F',),),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
- VALE =SIMP(statut='o',typ='R',min=78,max=78),),
+ VALE =SIMP(statut='f',typ='R',min=78,max=78),
+ VALE_F =SIMP(statut='f',typ=(para_sensi,),min=78 ,max=78 ),),
# affection des caractéristiques de MASSE
b_M_T_D_N =BLOC(condition = "CARA=='M_T_D_N'",
fr="NOEUD: 1 valeur de masse",
- regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),),
+ regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+ AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('VALE','VALE_F',),),
NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
- VALE =SIMP(statut='o',typ='R',min=1 ,max=1 ),),
+ VALE =SIMP(statut='f',typ='R',min=1 ,max=1 ),
+ VALE_F =SIMP(statut='f',typ=(para_sensi,),min=1 ,max=1 ),),
b_M_TR_D_N =BLOC(condition = "CARA=='M_TR_D_N'",
fr="NOEUD: 1 valeur de masse, 6 valeurs du tenseur d'inertie, 3 composantes du vecteur d'excentricité",
- regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),),
+ regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+ AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('VALE','VALE_F',),),
NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
- VALE =SIMP(statut='o',typ='R',min=10,max=10),),
+ VALE =SIMP(statut='f',typ='R',min=10,max=10),
+ VALE_F =SIMP(statut='f',typ=(para_sensi,),min=10 ,max=10 ),),
b_M_T_N =BLOC(condition = "CARA=='M_T_N'",
fr="NOEUD: 6 valeurs de masse (triangulaire supérieure par colonne)",
- regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),),
+ regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+ AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('VALE','VALE_F',),),
NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
- VALE =SIMP(statut='o',typ='R',min=6 ,max=6 ),),
+ VALE =SIMP(statut='f',typ='R',min=6 ,max=6 ),
+ VALE_F =SIMP(statut='f',typ=(para_sensi,),min=6 ,max=6 ),),
b_M_T_L =BLOC(condition = "CARA=='M_T_L'",
fr="SEGMENT: 21 valeurs de masse (triangulaire supérieure par colonne)",
- regles=(UN_PARMI('MAILLE','GROUP_MA'),),
+ regles=(UN_PARMI('MAILLE','GROUP_MA'),
+ AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('VALE','VALE_F',),),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
- VALE =SIMP(statut='o',typ='R',min=21,max=21),),
+ VALE =SIMP(statut='f',typ='R',min=21,max=21),
+ VALE_F =SIMP(statut='f',typ=(para_sensi,),min=21 ,max=21 ),),
b_M_TR_N =BLOC(condition = "CARA=='M_TR_N'",
fr="NOEUD: 21 valeurs de masse (triangulaire supérieure par colonne)",
- regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),),
+ regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+ AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('VALE','VALE_F',),),
NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
- VALE =SIMP(statut='o',typ='R',min=21,max=21),),
+ VALE =SIMP(statut='f',typ='R',min=21,max=21),
+ VALE_F =SIMP(statut='f',typ=(para_sensi,),min=21 ,max=21 ),),
b_M_TR_L =BLOC(condition = "CARA=='M_TR_L'",
fr="SEGMENT: 78 valeurs de masse (triangulaire supérieure par colonne)",
- regles=(UN_PARMI('MAILLE','GROUP_MA'),),
+ regles=(UN_PARMI('MAILLE','GROUP_MA'),
+ AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('VALE','VALE_F',),),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
- VALE =SIMP(statut='o',typ='R',min=78,max=78),),
+ VALE =SIMP(statut='f',typ='R',min=78,max=78),
+ VALE_F =SIMP(statut='f',typ=(para_sensi,),min=78 ,max=78 ),),
),
#============================================================================
# affection des caractéristiques de RIGIDITE/AMORTISSEMENT
b_K_T_D_N =BLOC(condition = "(CARA=='K_T_D_N')or(CARA=='A_T_D_N')",
- regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),),
+ regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+ AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('VALE','VALE_F',),),
NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
- VALE =SIMP(statut='o',typ='R',min=2 ,max=2 ),),
+ VALE =SIMP(statut='f',typ='R',min=2 ,max=2 ),
+ VALE_F =SIMP(statut='f',typ=(para_sensi,),min=2 ,max=2 ),),
b_K_T_D_L =BLOC(condition = "(CARA=='K_T_D_L')or(CARA=='A_T_D_L')",
- regles=(UN_PARMI('MAILLE','GROUP_MA'),),
+ regles=(UN_PARMI('MAILLE','GROUP_MA'),
+ AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('VALE','VALE_F',),),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
- VALE =SIMP(statut='o',typ='R',min=2 ,max=2 ),),
+ VALE =SIMP(statut='f',typ='R',min=2 ,max=2 ),
+ VALE_F =SIMP(statut='f',typ=(para_sensi,),min=2 ,max=2 ),),
b_K_TR_D_N =BLOC(condition = "(CARA=='K_TR_D_N')or(CARA=='A_TR_D_N')",
- regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),),
+ regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+ AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('VALE','VALE_F',),),
NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
- VALE =SIMP(statut='o',typ='R',min=3 ,max=3 ),),
+ VALE =SIMP(statut='f',typ='R',min=3 ,max=3 ),
+ VALE_F =SIMP(statut='f',typ=(para_sensi,),min=3 ,max=3 ),),
b_K_TR_D_L =BLOC(condition = "(CARA=='K_TR_D_L')or(CARA=='A_TR_D_L')",
- regles=(UN_PARMI('MAILLE','GROUP_MA'),),
+ regles=(UN_PARMI('MAILLE','GROUP_MA'),
+ AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('VALE','VALE_F',),),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
- VALE =SIMP(statut='o',typ='R',min=3 ,max=3 ),),
+ VALE =SIMP(statut='f',typ='R',min=3 ,max=3 ),
+ VALE_F =SIMP(statut='f',typ=(para_sensi,),min=3 ,max=3 ),),
b_K_T_N =BLOC(condition = "(CARA=='K_T_N')or(CARA=='A_T_N')",
- regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),),
+ regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+ AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('VALE','VALE_F',),),
NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
- VALE =SIMP(statut='o',typ='R',min=3 ,max=3 ),),
+ VALE =SIMP(statut='f',typ='R',min=3 ,max=3 ),
+ VALE_F =SIMP(statut='f',typ=(para_sensi,),min=3 ,max=3 ),),
b_K_T_L =BLOC(condition = "(CARA=='K_T_L')or(CARA=='A_T_L')",
- regles=(UN_PARMI('MAILLE','GROUP_MA'),),
+ regles=(UN_PARMI('MAILLE','GROUP_MA'),
+ AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('VALE','VALE_F',),),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
- VALE =SIMP(statut='o',typ='R',min=10,max=10),),
+ VALE =SIMP(statut='f',typ='R',min=10,max=10),
+ VALE_F =SIMP(statut='f',typ=(para_sensi,),min=10 ,max=10 ),),
b_K_TR_N =BLOC(condition = "(CARA=='K_TR_N')or(CARA=='A_TR_N')",
- regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),),
+ regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+ AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('VALE','VALE_F',),),
NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
- VALE =SIMP(statut='o',typ='R',min=6 ,max=6),),
+ VALE =SIMP(statut='f',typ='R',min=6 ,max=6),
+ VALE_F =SIMP(statut='f',typ=(para_sensi,),min=6 ,max=6 ),),
b_K_TR_L =BLOC(condition = "(CARA=='K_TR_L')or(CARA=='A_TR_L')",
- regles=(UN_PARMI('MAILLE','GROUP_MA'),),
+ regles=(UN_PARMI('MAILLE','GROUP_MA'),
+ AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('VALE','VALE_F',),),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
- VALE =SIMP(statut='o',typ='R',min=21,max=21),),
+ VALE =SIMP(statut='f',typ='R',min=21,max=21),
+ VALE_F =SIMP(statut='f',typ=(para_sensi,),min=21 ,max=21 ),),
# affection des caractéristiques de MASSE
b_M_T_D_N =BLOC(condition = "CARA=='M_T_D_N'",
fr="NOEUD: 1 valeur de masse",
- regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),),
+ regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+ AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('VALE','VALE_F',),),
NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
- VALE =SIMP(statut='o',typ='R',min=1 ,max=1 ),),
+ VALE =SIMP(statut='f',typ='R',min=1 ,max=1 ),
+ VALE_F =SIMP(statut='f',typ=(para_sensi,),min=1 ,max=1 ),),
b_M_TR_D_N =BLOC(condition = "CARA=='M_TR_D_N'",
fr="NOEUD: 1 valeur de masse(m), 1 valeur d'inertie(Izz), 2 composantes du vecteur d'excentricité(ex,ey) ",
- regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),),
+ regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+ AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('VALE','VALE_F',),),
NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
- VALE =SIMP(statut='o',typ='R',min=4 ,max=4 ),),
+ VALE =SIMP(statut='f',typ='R',min=4 ,max=4 ),
+ VALE_F =SIMP(statut='f',typ=(para_sensi,),min=4 ,max=4 ),),
b_M_T_N =BLOC(condition = "CARA=='M_T_N'",
fr="NOEUD: 3 valeurs de masse (triangulaire supérieure par colonne)",
- regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),),
+ regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+ AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('VALE','VALE_F',),),
NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
- VALE =SIMP(statut='o',typ='R',min=3 ,max=3 ),),
+ VALE =SIMP(statut='f',typ='R',min=3 ,max=3 ),
+ VALE_F =SIMP(statut='f',typ=(para_sensi,),min=3 ,max=3 ),),
b_M_T_L =BLOC(condition = "CARA=='M_T_L'",
fr="SEGMENT: 10 valeurs de masse (triangulaire supérieure par colonne)",
- regles=(UN_PARMI('MAILLE','GROUP_MA'),),
+ regles=(UN_PARMI('MAILLE','GROUP_MA'),
+ AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('VALE','VALE_F',),),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
- VALE =SIMP(statut='o',typ='R',min=10,max=10),),
+ VALE =SIMP(statut='f',typ='R',min=10,max=10),
+ VALE_F =SIMP(statut='f',typ=(para_sensi,),min=10 ,max=10 ),),
b_M_TR_N =BLOC(condition = "CARA=='M_TR_N'",
fr="NOEUD: 6 valeurs de masse (triangulaire supérieure par colonne)",
- regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),),
+ regles=(UN_PARMI('MAILLE','GROUP_MA','NOEUD','GROUP_NO'),
+ AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('VALE','VALE_F',),),
NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
- VALE =SIMP(statut='o',typ='R',min=6 ,max=6 ),),
+ VALE =SIMP(statut='f',typ='R',min=6 ,max=6 ),
+ VALE_F =SIMP(statut='f',typ=(para_sensi,),min=6 ,max=6 ),),
b_M_TR_L =BLOC(condition = "CARA=='M_TR_L'",
fr="SEGMENT: 21 valeurs de masse (triangulaire supérieure par colonne)",
- regles=(UN_PARMI('MAILLE','GROUP_MA'),),
+ regles=(UN_PARMI('MAILLE','GROUP_MA'),
+ AU_MOINS_UN('VALE','VALE_F',),PRESENT_ABSENT('VALE','VALE_F',),),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
- VALE =SIMP(statut='o',typ='R',min=21,max=21),),
+ VALE =SIMP(statut='f',typ='R',min=21,max=21),
+ VALE_F =SIMP(statut='f',typ=(para_sensi,),min=21 ,max=21 ),),
),
#============================================================================
#============================================================================
MASSIF =FACT(statut='f',max='**',
regles=(UN_PARMI('MAILLE','GROUP_MA'),
- UN_PARMI('ANGL_REP','ANGL_AXE'),
+ UN_PARMI('ANGL_REP','ANGL_AXE','ANGL_EULER'),
+ EXCLUS('ANGL_REP','ANGL_EULER'),
EXCLUS('ANGL_REP','ANGL_AXE'),
EXCLUS('ANGL_REP','ORIG_AXE'),
PRESENT_PRESENT('ANGL_AXE','ORIG_AXE'), ),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
ANGL_REP =SIMP(statut='f',typ='R',max=3),
+ ANGL_EULER =SIMP(statut='f',typ='R',min=3,max=3),
ANGL_AXE =SIMP(statut='f',typ='R',max=2),
ORIG_AXE =SIMP(statut='f',typ='R',max=3),
),
+
#============================================================================
POUTRE_FLUI =FACT(statut='f',max='**',
regles=(UN_PARMI('MAILLE','GROUP_MA'),),
DDL =SIMP(statut='o',typ='TXM',max='**'),
),
) ;
-#& MODIF COMMANDE DATE 05/09/2005 AUTEUR CIBHHLV L.VIVAN
+#& MODIF COMMANDE DATE 27/11/2006 AUTEUR PELLET J.PELLET
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
MECA_IMPO =FACT(statut='f',max='**',
regles=(UN_PARMI('TOUT','GROUP_MA','MAILLE','GROUP_NO','NOEUD'),
AU_MOINS_UN('DX','DY','DZ','DRX','DRY','DRZ','GRX','PRES','PHI',
- 'TEMP','PRE1','PRE2','UI2','UI3','VI2','VI3','WI2','WI3','UO2',
- 'UO3','VO2','VO3','WO2','WO3','UI4','UI5','VI4','VI5','WI4',
- 'WI5','UO4','UO5','VO4','VO5','WO4','WO5','UI6','UO6','VI6',
- 'VO6','WI6','WO6','WO','WI1','WO1','GONF','DCX','DCY','DCZ',
- 'H1X','H1Y','H1Z','E1X','E1Y','E1Z','E2X','E2Y','E2Z',
- 'E3X','E3Y','E3Z','E4X','E4Y','E4Z'),),
+ 'TEMP'),),
TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
PRES =SIMP(statut='f',typ='R' ),
PHI =SIMP(statut='f',typ='R' ),
TEMP =SIMP(statut='f',typ='R' ),
- PRE1 =SIMP(statut='f',typ='R' ),
- PRE2 =SIMP(statut='f',typ='R' ),
- UI2 =SIMP(statut='f',typ='R' ),
- UI3 =SIMP(statut='f',typ='R' ),
- UI4 =SIMP(statut='f',typ='R' ),
- UI5 =SIMP(statut='f',typ='R' ),
- UI6 =SIMP(statut='f',typ='R' ),
- UO2 =SIMP(statut='f',typ='R' ),
- UO3 =SIMP(statut='f',typ='R' ),
- UO4 =SIMP(statut='f',typ='R' ),
- UO5 =SIMP(statut='f',typ='R' ),
- UO6 =SIMP(statut='f',typ='R' ),
- VI2 =SIMP(statut='f',typ='R' ),
- VI3 =SIMP(statut='f',typ='R' ),
- VI4 =SIMP(statut='f',typ='R' ),
- VI5 =SIMP(statut='f',typ='R' ),
- VI6 =SIMP(statut='f',typ='R' ),
- VO2 =SIMP(statut='f',typ='R' ),
- VO3 =SIMP(statut='f',typ='R' ),
- VO4 =SIMP(statut='f',typ='R' ),
- VO5 =SIMP(statut='f',typ='R' ),
- VO6 =SIMP(statut='f',typ='R' ),
- WI2 =SIMP(statut='f',typ='R' ),
- WI3 =SIMP(statut='f',typ='R' ),
- WI4 =SIMP(statut='f',typ='R' ),
- WI5 =SIMP(statut='f',typ='R' ),
- WI6 =SIMP(statut='f',typ='R' ),
- WO2 =SIMP(statut='f',typ='R' ),
- WO3 =SIMP(statut='f',typ='R' ),
- WO4 =SIMP(statut='f',typ='R' ),
- WO5 =SIMP(statut='f',typ='R' ),
- WO6 =SIMP(statut='f',typ='R' ),
- WO =SIMP(statut='f',typ='R' ),
- WI1 =SIMP(statut='f',typ='R' ),
- WO1 =SIMP(statut='f',typ='R' ),
- GONF =SIMP(statut='f',typ='R' ),
- DCX =SIMP(statut='f',typ='R' ),
- DCY =SIMP(statut='f',typ='R' ),
- DCZ =SIMP(statut='f',typ='R' ),
- H1X =SIMP(statut='f',typ='R' ),
- H1Y =SIMP(statut='f',typ='R' ),
- H1Z =SIMP(statut='f',typ='R' ),
- E1X =SIMP(statut='f',typ='R' ),
- E1Y =SIMP(statut='f',typ='R' ),
- E1Z =SIMP(statut='f',typ='R' ),
- E2X =SIMP(statut='f',typ='R' ),
- E2Y =SIMP(statut='f',typ='R' ),
- E2Z =SIMP(statut='f',typ='R' ),
- E3X =SIMP(statut='f',typ='R' ),
- E3Y =SIMP(statut='f',typ='R' ),
- E3Z =SIMP(statut='f',typ='R' ),
- E4X =SIMP(statut='f',typ='R' ),
- E4Y =SIMP(statut='f',typ='R' ),
- E4Z =SIMP(statut='f',typ='R' ),
),
THER_IMPO =FACT(statut='f',max='**',
regles=(UN_PARMI('TOUT','GROUP_MA','MAILLE','GROUP_NO','NOEUD'),
),
INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
) ;
-#& MODIF COMMANDE DATE 03/05/2006 AUTEUR MABBAS M.ABBAS
+#& MODIF COMMANDE DATE 14/11/2006 AUTEUR TARDIEU N.TARDIEU
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
'PRES_REP','FORCE_POUTRE','FORCE_COQUE','LIAISON_OBLIQUE',
'FORCE_ELEC','INTE_ELEC','PESANTEUR','ROTATION','IMPE_FACE',
'VITE_FACE','TEMP_CALCULEE','RELA_CINE_BP','EPSI_INIT','CONTACT',
- 'LIAISON_GROUP','LIAISON_UNIF','FLUX_THM_REP',
- 'LIAISON_SOLIDE','LIAISON_ELEM','ONDE_FLUI',
- 'EPSA_CALCULEE','LIAISON_CHAMNO','VECT_ASSE','LIAISON_COQUE',
- 'LIAISON_MAIL','LIAISON_CYCL','FORCE_TUYAU','SECH_CALCULEE',
+ 'LIAISON_GROUP','LIAISON_UNIF','FLUX_THM_REP','LIAISON_SOLIDE',
+ 'LIAISON_ELEM','ONDE_FLUI','LIAISON_CHAMNO','VECT_ASSE','LIAISON_COQUE',
+ 'LIAISON_MAIL','LIAISON_CYCL','FORCE_TUYAU',
'EFFE_FOND','EVOL_CHAR','ARLEQUIN','DDL_POUTRE','GRAPPE_FLUIDE',
'LIAISON_UNILATER'),
),
MODELE =SIMP(statut='o',typ=(modele_sdaster) ),
TEMP_CALCULEE =SIMP(statut='f',fr="Champ de température issu d'un autre calcul",
typ=(evol_ther,cham_no_sdaster,carte_sdaster) ),
- SECH_CALCULEE =SIMP(statut='f',fr="Champ de séchage issu d'un autre calcul",
- typ=(evol_ther,cham_no_sdaster,carte_sdaster ) ),
- EPSA_CALCULEE =SIMP(statut='f',fr="Champ de déformation anélastique issu d'un autre calcul",
- typ=evol_noli ),
EVOL_CHAR =SIMP(statut='f',fr="Champ de pression issu d'un autre calcul",
typ=evol_char ),
fr="Définit les zones soumises à des conditions de contact unilatéral avec ou sans frottement",
regles=(UN_PARMI('GROUP_MA_ESCL','MAILLE_ESCL'),),
APPARIEMENT =SIMP(statut='f',typ='TXM',defaut="MAIT_ESCL",
- into=("NON","NODAL","MAIT_ESCL","MAIT_ESCL_SYME")),
+ into=("RIGIDE","NODAL","MAIT_ESCL","MAIT_ESCL_SYME")),
RECHERCHE =SIMP(statut='f',typ='TXM',defaut="NOEUD_BOUCLE",
into=("NOEUD_BOUCLE","NOEUD_VOISIN")),
LISSAGE =SIMP(statut='f',typ='TXM',defaut="NON",
GROUP_MA_MAIT =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max='**'),
MAILLE_MAIT =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
GROUP_MA_ESCL =SIMP(statut='f',typ=grma ,validators=NoRepeat(),max='**'),
- MAILLE_ESCL =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
+ MAILLE_ESCL =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
+
b_cara =BLOC(condition = "DIST_POUTRE == 'OUI' or DIST_COQUE == 'OUI'",
CARA_ELEM =SIMP(statut='o',typ=(cara_elem) ),
),
b_active =BLOC(condition = "METHODE == 'CONTRAINTE' ",
fr="Paramètres de la méthode des contraintes actives (contact uniquement)",
- regles=(EXCLUS('DIST_ESCL','COEF_IMPO'),
- EXCLUS('DIST_MAIT','COEF_IMPO'),),
- NOM_CHAM =SIMP(statut='f',typ='TXM',defaut="DEPL",
- into=("DEPL","PRES","TEMP","PRE1","PRE2")),
GLISSIERE =SIMP(statut='f',typ='TXM',defaut="NON",
into=("OUI","NON")),
b_glissiere =BLOC(condition = "GLISSIERE == 'OUI' ",
),
SANS_NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
SANS_GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
- SANS_NOEUD_QUAD =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
- COEF_IMPO =SIMP(statut='f',typ='R'),
- COEF_MULT_ESCL =SIMP(statut='f',typ='R'),
+ SANS_NOEUD_QUAD =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
VECT_NORM_ESCL =SIMP(statut='f',typ='R',max=3),
VECT_ORIE_POU =SIMP(statut='f',typ='R',min=3,max=3),
DIST_MAIT =SIMP(statut='f',typ='R'),
),
b_lagrangien =BLOC(condition = "METHODE == 'LAGRANGIEN' ",
fr="Paramètres de la méthode Lagrangienne (contact avec ou sans frottement)",
- NOM_CHAM =SIMP(statut='f',typ='TXM',defaut="DEPL",into=("DEPL",)),
FROTTEMENT =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","COULOMB",) ),
TOLE_PROJ_EXT =SIMP(statut='f',typ='R' ,defaut=0.50),
TOLE_PROJ_INT =SIMP(statut='f',typ='R' ,defaut=0.001),
b_penalisation =BLOC(condition = "METHODE == 'PENALISATION' ",
fr="Paramètres de la méthode pénalisée (contact avec ou sans frottement)",
- NOM_CHAM =SIMP(statut='f',typ='TXM',defaut="DEPL",into=("DEPL",)),
E_N =SIMP(statut='f',typ='R'),
FROTTEMENT =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","COULOMB",) ),
TOLE_PROJ_EXT =SIMP(statut='f',typ='R' ,defaut=0.50),
b_continue =BLOC(condition = "METHODE == 'CONTINUE' ",
fr="Paramètres de la méthode continue (contact avec ou sans frottement)",
# regles=(UN_PARMI('GLISSIERE','FROTTEMENT'),),
- NOM_CHAM =SIMP(statut='f',typ='TXM',defaut="DEPL",into=("DEPL","VITE")),
GLISSIERE =SIMP(statut='f',typ='TXM',defaut="NON",
into=("OUI","NON")),
b_glissiere =BLOC(condition = "GLISSIERE == 'OUI' ",
),
FROTTEMENT =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","COULOMB",) ),
COMPLIANCE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",) ),
+ FOND_FISSURE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",) ),
+ RACCORD_LINE_QUAD=SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",) ),
+
INTEGRATION =SIMP(statut='f',typ='TXM',defaut="NOEUD",into=("GAUSS","NOEUD","SIMPSON","SIMPSON1","SIMPSON2",
"NCOTES","NCOTES1","NCOTES2")),
COEF_REGU_CONT =SIMP(statut='f',typ='R',defaut=100.E+0),
VECT_ORIE_POU =SIMP(statut='f',typ='R',min=3,max=3),
TOLE_PROJ_EXT =SIMP(statut='f',typ='R' ,defaut=0.50),
CONTACT_INIT =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",) ),
+ b_FOND_FISSURE =BLOC(condition = "FOND_FISSURE == 'OUI' ",fr="TRAITEMENT EN FOND DE FISSURE",
+ regles=(UN_PARMI('NOEUD_FOND','GROUP_NO_FOND','MAILLE_FOND','GROUP_MA_FOND'),),
+ NOEUD_FOND =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
+ GROUP_NO_FOND =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+ MAILLE_FOND =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
+ GROUP_MA_FOND =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),),
+ b_RACCORD_SURF =BLOC(condition = "RACCORD_LINE_QUAD == 'OUI' ",fr="TRAITEMENT DU RACCORD SURFACIQUE",
+ regles=(UN_PARMI('NOEUD_RACC','GROUP_NO_RACC'),),
+ NOEUD_RACC =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
+ GROUP_NO_RACC =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),),
+
b_compliance =BLOC(condition = "COMPLIANCE == 'OUI' ",fr="Parametres de la compliance",
ASPERITE =SIMP(statut='o',typ='R',),
E_N =SIMP(statut='o',typ='R',),
b_gcp =BLOC(condition = "METHODE == 'GCP' ",
fr="Paramètres de la méthode du gradient conjugué projeté (contact uniquement)",
- regles=(EXCLUS('DIST_ESCL','COEF_IMPO'),
- EXCLUS('DIST_MAIT','COEF_IMPO'),),
- NOM_CHAM =SIMP(statut='f',typ='TXM',defaut="DEPL",
- into=("DEPL","PRES","TEMP","PRE1","PRE2")),
RESI_ABSO =SIMP(statut='o',typ='R',
fr="Critère de convergence (niveau d'interpénétration autorisé)"),
REAC_ITER =SIMP(statut='f',typ='I',defaut=3, fr="Fréquence de réinitialisation de la conjugaison"),
SANS_NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
SANS_GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
SANS_NOEUD_QUAD =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
- COEF_IMPO =SIMP(statut='f',typ='R'),
- COEF_MULT_ESCL =SIMP(statut='f',typ='R'),
VECT_NORM_ESCL =SIMP(statut='f',typ='R',max=3),
VECT_ORIE_POU =SIMP(statut='f',typ='R',min=3,max=3),
DIST_MAIT =SIMP(statut='f',typ='R'),
),
INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
) ;
-#& MODIF COMMANDE DATE 03/05/2006 AUTEUR MABBAS M.ABBAS
+#& MODIF COMMANDE DATE 14/11/2006 AUTEUR TARDIEU N.TARDIEU
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
LIAISON_DDL =FACT(statut='f',max='**',
fr="Définit une relation linéaire entre des DDLs de deux ou plusieurs noeuds, les valeurs sont fournies par"
+" l'intermediaire d'un concept de type fonction",
- regles=(UN_PARMI('GROUP_NO','NOEUD'),),
+ regles=(UN_PARMI('GROUP_NO','NOEUD'),UN_PARMI('COEF_MULT','COEF_MULT_FONC'),),
GROUP_NO =SIMP(statut='f',typ=grno,max='**'),
NOEUD =SIMP(statut='f',typ=no ,max='**'),
DDL =SIMP(statut='o',typ='TXM',max='**'),
- COEF_MULT =SIMP(statut='o',typ='R',max='**'),
+ COEF_MULT =SIMP(statut='f',typ='R',max='**'),
+ COEF_MULT_FONC =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),max='**'),
COEF_IMPO =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule) ),
),
+" sont données par l'intermédiaire de concept fonction",max='**',
regles=(UN_PARMI('GROUP_MA_ESCL','MAILLE_ESCL'),),
APPARIEMENT =SIMP(statut='f',typ='TXM',defaut="MAIT_ESCL",
- into=("NON","NODAL","MAIT_ESCL","MAIT_ESCL_SYME")),
+ into=("NODAL","MAIT_ESCL","MAIT_ESCL_SYME")),
RECHERCHE =SIMP(statut='f',typ='TXM',defaut="NOEUD_BOUCLE",into=("NOEUD_BOUCLE","NOEUD_VOISIN")),
LISSAGE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
DIST_POUTRE =SIMP(statut='f',typ='TXM',defaut="NON", into=("OUI","NON")),
b_active =BLOC(condition = "METHODE == 'CONTRAINTE' ",
fr="Paramètres de la méthode des contraintes actives (contact uniquement)",
- regles=(EXCLUS('DIST_ESCL','COEF_IMPO'),
- EXCLUS('DIST_MAIT','COEF_IMPO'),),
- NOM_CHAM =SIMP(statut='f',typ='TXM',defaut="DEPL",
- into=("DEPL","PRES","TEMP","PRE1","PRE2")),
GLISSIERE =SIMP(statut='f',typ='TXM',defaut="NON",
into=("OUI","NON")),
b_glissiere =BLOC(condition = "GLISSIERE == 'OUI' ",
),
SANS_NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
SANS_GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
- SANS_NOEUD_QUAD =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
- COEF_IMPO =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
- COEF_MULT_ESCL =SIMP(statut='f',typ='R'),
+ SANS_NOEUD_QUAD =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
VECT_NORM_ESCL =SIMP(statut='f',typ='R',max=3),
VECT_ORIE_POU =SIMP(statut='f',typ='R',min=3,max=3),
DIST_MAIT =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
),
b_lagrangien =BLOC(condition = "METHODE == 'LAGRANGIEN' ",
fr="Paramètres de la méthode Lagrangienne (contact avec ou sans frottement)",
- NOM_CHAM =SIMP(statut='f',typ='TXM',defaut="DEPL",into=("DEPL",)),
FROTTEMENT =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","COULOMB",) ),
TOLE_PROJ_EXT =SIMP(statut='f',typ='R' ,defaut=0.50),
TOLE_PROJ_INT =SIMP(statut='f',typ='R' ,defaut=0.001),
),),
b_penalisation =BLOC(condition = "METHODE == 'PENALISATION' ",
fr="Paramètres de la méthode pénalisée (contact avec ou sans frottement)",
- NOM_CHAM =SIMP(statut='f',typ='TXM',defaut="DEPL",into=("DEPL",)),
E_N =SIMP(statut='f',typ='R'),
FROTTEMENT =SIMP(statut='f',typ='TXM',defaut="SANS",into=("SANS","COULOMB",) ),
TOLE_PROJ_EXT =SIMP(statut='f',typ='R' ,defaut=0.50),
b_continue =BLOC(condition = "METHODE == 'CONTINUE' ",
fr="Paramètres de la méthode continue (contact avec ou sans frottement)",
# regles=(UN_PARMI('GLISSIERE','FROTTEMENT'),),
- NOM_CHAM =SIMP(statut='f',typ='TXM',defaut="DEPL",into=("DEPL",)),
GLISSIERE =SIMP(statut='f',typ='TXM',defaut="NON",
into=("OUI","NON")),
b_glissiere =BLOC(condition = "GLISSIERE == 'OUI' ",
b_gcp =BLOC(condition = "METHODE == 'GCP' ",
fr="Paramètres de la méthode du gradient conjugué projeté (contact uniquement)",
- regles=(EXCLUS('DIST_ESCL','COEF_IMPO'),
- EXCLUS('DIST_MAIT','COEF_IMPO'),),
- NOM_CHAM =SIMP(statut='f',typ='TXM',defaut="DEPL",
- into=("DEPL","PRES","TEMP","PRE1","PRE2")),
RESI_ABSO =SIMP(statut='o',typ='R',
fr="Critère de convergence (niveau d'interpénétration autorisé)"),
REAC_ITER =SIMP(statut='f',typ='I',defaut=3, fr="Fréquence de réinitialisation de la conjugaison"),
SANS_NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
SANS_GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
SANS_NOEUD_QUAD =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
- COEF_IMPO =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
- COEF_MULT_ESCL =SIMP(statut='f',typ='R'),
VECT_NORM_ESCL =SIMP(statut='f',typ='R',max=3),
VECT_ORIE_POU =SIMP(statut='f',typ='R',min=3,max=3),
DIST_MAIT =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
) ;
-#& MODIF COMMANDE DATE 25/04/2006 AUTEUR CIBHHPD L.SALMONA
+#& MODIF COMMANDE DATE 28/08/2006 AUTEUR CIBHHPD L.SALMONA
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
MAILLAGE =SIMP(statut='o',typ=maillage_sdaster),
MODELE =SIMP(statut='f',typ=modele_sdaster),
- # affectation du nom du matériau :
- # -------------------------------
+ # affectation du nom du matériau (par mailles):
+ # ----------------------------------------------
AFFE =FACT(statut='o',max='**',
regles=(UN_PARMI('TOUT','GROUP_MA','MAILLE'),),
TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
MATER =SIMP(statut='o',typ=mater_sdaster,max=30),
TEMP_REF =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
- SECH_REF =SIMP(statut='f',typ='R',val_min=0.E+0),
+ ),
+
+ # affectation du nom du matériau (par noeuds):
+ # ----------------------------------------------
+ AFFE_NOEUD =FACT(statut='f',max='**',
+ regles=(UN_PARMI('TOUT','GROUP_MA','MAILLE'),),
+ TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+ GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+ MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
+ MATER =SIMP(statut='o',typ=mater_sdaster,max=1),
),
# affectation des variables de commande :
# --------------------------------------------------
# un mot clé caché qui ne sert qu'à boucler sur les VARC possibles :
- LIST_NOM_VARC =SIMP(statut='c',typ='TXM', defaut=("CORR","IRRA","HYDR","NEUT1","NEUT2")),
+ LIST_NOM_VARC =SIMP(statut='c',typ='TXM', defaut=("CORR","IRRA","HYDR","SECH","EPSA","M_ACIER","M_ZIRC","NEUT1","NEUT2")),
AFFE_VARC =FACT(statut='f',max='**',
-
- regles=(PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
- PRESENT_ABSENT('GROUP_MA','TOUT'),
- PRESENT_ABSENT('MAILLE','TOUT'),
- UN_PARMI('EVOL','CHAMP_GD'),),
-
- TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ), # [défaut]
- GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
- MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
-
- CHAMP_GD =SIMP(statut='f',typ=cham_gd_sdaster,),
- B_CHAMP_GD =BLOC(condition="CHAMP_GD!=None",
- NOM_VARC =SIMP(statut='o',typ='TXM', into=("CORR","IRRA","HYDR","NEUT1","NEUT2")),
- ),
- EVOL =SIMP(statut='f',typ=evol_sdaster,),
- B_EVOL =BLOC(condition="EVOL!=None",
- NOM_VARC =SIMP(statut='o',typ='TXM', into=("CORR","IRRA","HYDR","NEUT1","NEUT2")),
- B_NOM_CORR =BLOC(condition="NOM_VARC=='CORR'", NOM_CHAM=SIMP(statut='f',typ='TXM',defaut= 'CORR',),),
- B_NOM_IRRA =BLOC(condition="NOM_VARC=='IRRA'", NOM_CHAM=SIMP(statut='f',typ='TXM',defaut= 'IRRA',),),
- B_NOM_HYDR =BLOC(condition="NOM_VARC=='HYDR'", NOM_CHAM=SIMP(statut='f',typ='TXM',defaut= 'HYDR_ELNO_ELGA',),),
- B_NOM_NEUT1 =BLOC(condition="NOM_VARC=='NEUT1'", NOM_CHAM=SIMP(statut='f',typ='TXM',defaut= 'NEUT',),),
- B_NOM_NEUT2 =BLOC(condition="NOM_VARC=='NEUT2'", NOM_CHAM=SIMP(statut='f',typ='TXM',defaut= 'NEUT',),),
- PROL_DROITE =SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ),
- PROL_GAUCHE =SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ),
- ),
- VALE_REF =SIMP(statut='f',typ='R'),
+ regles=(PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),
+ PRESENT_ABSENT('GROUP_MA','TOUT'),
+ PRESENT_ABSENT('MAILLE','TOUT'),
+ UN_PARMI('EVOL','CHAMP_GD'),),
+
+ TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ), # [défaut]
+ GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+ MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
+
+ CHAMP_GD =SIMP(statut='f',typ=cham_gd_sdaster,),
+ B_CHAMP_GD =BLOC(condition="CHAMP_GD!=None",
+ NOM_VARC =SIMP(statut='o',typ='TXM', into=("CORR","IRRA","HYDR","SECH","M_ACIER","M_ZIRC","EPSA","NEUT1","NEUT2")),
+ ),
+ EVOL =SIMP(statut='f',typ=evol_sdaster,),
+ B_EVOL =BLOC(condition="EVOL!=None",
+ NOM_VARC =SIMP(statut='o',typ='TXM', into=("CORR","IRRA","HYDR","SECH","M_ACIER","M_ZIRC","EPSA","NEUT1","NEUT2")),
+ B_NOM_CORR =BLOC(condition="NOM_VARC=='CORR'",NOM_CHAM=SIMP(statut='f',typ='TXM',defaut= 'CORR',),),
+ B_NOM_IRRA =BLOC(condition="NOM_VARC=='IRRA'",NOM_CHAM=SIMP(statut='f',typ='TXM',defaut= 'IRRA',),),
+ B_NOM_HYDR =BLOC(condition="NOM_VARC=='HYDR'",NOM_CHAM=SIMP(statut='f',typ='TXM',defaut= 'HYDR_ELNO_ELGA',),),
+ B_NOM_SECH =BLOC(condition="NOM_VARC=='SECH'",NOM_CHAM=SIMP(statut='f',typ='TXM',defaut= 'TEMP',),),
+ B_NOM_EPSA =BLOC(condition="NOM_VARC=='EPSA'",NOM_CHAM=SIMP(statut='f',typ='TXM',defaut= 'EPSA_ELNO',),),
+ B_NOM_M_ACIER =BLOC(condition="NOM_VARC=='M_ACIER'",NOM_CHAM=SIMP(statut='f',typ='TXM',defaut= 'META_ELNO_TEMP',),),
+ B_NOM_M_ZIRC =BLOC(condition="NOM_VARC=='M_ZIRC'",NOM_CHAM=SIMP(statut='f',typ='TXM',defaut= 'META_ELNO_TEMP',),),
+ B_NOM_NEUT1 =BLOC(condition="NOM_VARC=='NEUT1'",NOM_CHAM=SIMP(statut='f',typ='TXM',defaut= 'NEUT',),),
+ B_NOM_NEUT2 =BLOC(condition="NOM_VARC=='NEUT2'",NOM_CHAM=SIMP(statut='f',typ='TXM',defaut= 'NEUT',),),
+ PROL_DROITE =SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ),
+ PROL_GAUCHE =SIMP(statut='f',typ='TXM',defaut="EXCLU",into=("CONSTANT","LINEAIRE","EXCLU") ),
+ ),
+ VALE_REF =SIMP(statut='f',typ='R'),
),
# mots clés cachés pour les variables de commande NEUTi :
NOM_VARC =SIMP(statut='c',typ='TXM',defaut="EPSA"),
GRANDEUR =SIMP(statut='c',typ='TXM',defaut="EPSI_R"),
CMP_GD =SIMP(statut='c',typ='TXM',max=6,min=6,defaut=("EPXX","EPYY","EPZZ","EPXY","EPXZ","EPYZ",)),
- CMP_VARC =SIMP(statut='c',typ='TXM',max=6,min=6,defaut=("EPXX","EPYY","EPZZ","EPXY","EPXZ","EPYZ",)),
+ CMP_VARC =SIMP(statut='c',typ='TXM',max=6,min=6,defaut=("EPSAXX","EPSAYY","EPSAZZ","EPSAXY","EPSAXZ","EPSAYZ",)),
VALE_DEF =SIMP(statut='c',typ='R',max=6,min=6,defaut=( 0., 0., 0., 0., 0., 0., )),
),
+ # mots clés cachés pour variable de commande metallurgique ACIER :
+ # -----------------------------------------------------------------
+ VARC_M_ACIER =FACT(statut='d',
+ NOM_VARC =SIMP(statut='c',typ='TXM',defaut="M_ACIER"),
+ GRANDEUR =SIMP(statut='c',typ='TXM',defaut="VARI_R"),
+ CMP_GD =SIMP(statut='c',typ='TXM',max=7,min=7,defaut=("V1","V2","V3","V4","V5","V6","V7")),
+ CMP_VARC =SIMP(statut='c',typ='TXM',max=7,min=7,defaut=("PFERRITE","PPERLITE","PBAINITE",
+ "PMARTENS","TAUSTE","TRANSF","TACIER",)),
+ VALE_DEF =SIMP(statut='c',typ='R',max=7,min=7,defaut=( 0., 0., 0., 0., 0., 0., 0. )),
+ ),
+ # mots clés cachés pour variable de commande metallurgique ZIRCALOY :
+ # --------------------------------------------------------------------
+ VARC_M_ZIRC =FACT(statut='d',
+ NOM_VARC =SIMP(statut='c',typ='TXM',defaut="M_ZIRC"),
+ GRANDEUR =SIMP(statut='c',typ='TXM',defaut="VARI_R"),
+ CMP_GD =SIMP(statut='c',typ='TXM',max=3,min=3,defaut=("V1","V2","V3")),
+ CMP_VARC =SIMP(statut='c',typ='TXM',max=3,min=3,defaut=("ALPHPUR","ALPHBETA","TZIRC",)),
+ VALE_DEF =SIMP(statut='c',typ='R',max=3,min=3,defaut=( 0., 0., 0. )),
+ ),
) ;
-#& MODIF COMMANDE DATE 09/05/2006 AUTEUR JMBHH01 J.M.PROIX
+#& MODIF COMMANDE DATE 31/10/2006 AUTEUR A3BHHAE H.ANDRIAMBOLOLONA
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
VERIF =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=2,into=("MAILLE","NOEUD") ),
AFFE_SOUS_STRUC =FACT(statut='f',
- regles=(UN_PARMI('TOUT','MAILLE'),),
+ regles=(UN_PARMI('TOUT','SUPER_MAILLE'),),
TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
- MAILLE =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'),
+ SUPER_MAILLE =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'),
PHENOMENE =SIMP(statut='f',typ='TXM',defaut="MECANIQUE",into=("MECANIQUE",) ),
),
AFFE =FACT(statut='f',max='**',
PHENOMENE =SIMP(statut='o',typ='TXM',
into=("MECANIQUE","THERMIQUE","ACOUSTIQUE") ),
b_mecanique =BLOC( condition = "PHENOMENE=='MECANIQUE'",
- fr="modelisations mécaniques",
+ fr="modélisations mécaniques",
MODELISATION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',into=(
"2D_DIS_T",
"2D_DIS_TR",
"3D_FLUI_ABSO",
"3D_FLUIDE",
"3D_INCO",
- "3D_JOINT_CT",
"3D_SI",
"3D_GRAD_EPSI",
"3D_GRAD_VARI",
"D_PLAN_THH2MS",
"D_PLAN_THHMS",
"D_PLAN_THMS",
+ "D_PLAN_HM_P",
"AXIS_THH",
"AXIS_THHM",
"AXIS_THM",
"3D_HH2MS",
"3D_THH2S",
"3D_THH2D",
-
) ) ),
b_thermique =BLOC( condition = "PHENOMENE=='THERMIQUE'",
- fr="modelisations thermiques",
+ fr="modélisations thermiques",
MODELISATION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',into=(
"3D",
"3D_DIAG",
),),),
b_acoustique =BLOC( condition = "PHENOMENE=='ACOUSTIQUE'",
- fr="modelisations acoustiques",
+ fr="modélisations acoustiques",
MODELISATION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',into=(
"3D",
"PLAN"
# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
-ASSE_VECT_GENE=OPER(nom="ASSE_VECT_GENE",op= 140,sd_prod=vect_asse_gene,
- fr="Projection des chargements sur la base modale d'une sous structure",
- reentrant='n',
+# RESPONSABLE VABHHTS J.PELLET
+
+ASSE_VECTEUR=OPER(nom="ASSE_VECTEUR",op=13,sd_prod=cham_no_sdaster,
+ fr="Construire un champ aux noeuds par assemblage de vecteurs élémentaires",reentrant='n',
UIinfo={"groupes":("Matrices/vecteurs",)},
- NUME_DDL_GENE =SIMP(statut='o',typ=nume_ddl_gene ),
- METHODE =SIMP(statut='f',typ='TXM',defaut="CLASSIQUE",into=("CLASSIQUE","INITIAL") ),
- b_nume =BLOC(condition = "METHODE == 'CLASSIQUE'",
- CHAR_SOUS_STRUC =FACT(statut='o',max='**',
- SOUS_STRUC =SIMP(statut='o',typ='TXM' ),
- VECT_ASSE =SIMP(statut='o',typ=cham_no_sdaster ),
- ),
- ),
+ VECT_ELEM =SIMP(statut='o',typ=vect_elem,max='**'),
+ NUME_DDL =SIMP(statut='o',typ=nume_ddl_sdaster ),
+ INFO =SIMP(statut='f',typ='I',into=(1,2,) ),
) ;
#& MODIF COMMANDE DATE 21/02/2006 AUTEUR REZETTE C.REZETTE
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
-# RESPONSABLE VABHHTS J.PELLET
-
-ASSE_VECTEUR=OPER(nom="ASSE_VECTEUR",op=13,sd_prod=cham_no_sdaster,
- fr="Construire un champ aux noeuds par assemblage de vecteurs élémentaires",reentrant='n',
+ASSE_VECT_GENE=OPER(nom="ASSE_VECT_GENE",op= 140,sd_prod=vect_asse_gene,
+ fr="Projection des chargements sur la base modale d'une sous structure",
+ reentrant='n',
UIinfo={"groupes":("Matrices/vecteurs",)},
- VECT_ELEM =SIMP(statut='o',typ=vect_elem,max='**'),
- NUME_DDL =SIMP(statut='o',typ=nume_ddl_sdaster ),
- INFO =SIMP(statut='f',typ='I',into=(1,2,) ),
+ NUME_DDL_GENE =SIMP(statut='o',typ=nume_ddl_gene ),
+ METHODE =SIMP(statut='f',typ='TXM',defaut="CLASSIQUE",into=("CLASSIQUE","INITIAL") ),
+ b_nume =BLOC(condition = "METHODE == 'CLASSIQUE'",
+ CHAR_SOUS_STRUC =FACT(statut='o',max='**',
+ SOUS_STRUC =SIMP(statut='o',typ='TXM' ),
+ VECT_ASSE =SIMP(statut='o',typ=cham_no_sdaster ),
+ ),
+ ),
) ;
#& MODIF COMMANDE DATE 03/01/2006 AUTEUR REZETTE C.REZETTE
# CONFIGURATION MANAGEMENT OF EDF VERSION
),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
) ;
-#& MODIF COMMANDE DATE 10/05/2006 AUTEUR MCOURTOI M.COURTOIS
+#& MODIF COMMANDE DATE 07/11/2006 AUTEUR CIBHHLV L.VIVAN
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
RESULTAT =SIMP(statut='o',typ=(evol_elas,dyna_trans,dyna_harmo,mode_meca,
mode_stat,mode_stat_depl,mode_stat_acce,mode_stat_forc,
- evol_noli,mult_elas,fourier_elas,
+ evol_noli,mult_elas,fourier_elas,fourier_ther,
evol_ther,base_modale,
acou_harmo,mode_acou,mode_flamb) ,
fr="Résultat d'une commande globale"),
MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**',
fr="le calcul ne sera effectué que sur ces mailles là"),
-# options pour des resultats lineaire
+# definition d'un repere local
+
+ REPE_COQUE =FACT(statut='f',max='**',
+ fr="définiton du lieu de post-traitement",
+ regles=EXCLUS('ANGL_REP','VECTEUR'),
+ TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+ GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**',),
+ MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**',),
+
+ NUME_COUCHE =SIMP(statut='f',typ='I',defaut= 1,
+ fr="numero de couche dans l'épaisseur de la coque ou du tuyau" ),
+ NIVE_COUCHE =SIMP(statut='f',typ='TXM',defaut="MOY",into=("SUP","INF","MOY"),
+ fr="position dans l'épaisseur de la coque, ou de la couche" ),
+
+ ANGLE =SIMP(statut='f',typ='I',defaut= 0,
+ fr="angle de dépouillement pour les tuyaux, en degres à partir de la génératrice" ),
+
+ PLAN =SIMP(statut='f',typ='TXM',defaut="MAIL",into=("SUP","INF","MOY","MAIL"),
+ fr="Plan de calcul pour les plaques excentrées" ),
+
+ ANGL_REP =SIMP(statut='f',typ='R',min=2,max=2,
+ fr="définition du repere de post-traitement, par défaut ANGL_REP=(0.,0.)"),
+ VECTEUR =SIMP(statut='f',typ='R',min=3,max=3,
+ fr="définition du repere de post-traitement, par défaut VECTEUR=(1.,0.,0.)"),
+ ),
+
+# options pour des resultats lineaires
b_lineaire =BLOC( condition = "AsType(RESULTAT) in (evol_elas,dyna_trans,dyna_harmo,mode_meca,\
mode_stat,mode_stat_depl,mode_stat_acce,mode_stat_forc,\
fr="options mecaniques lineaires",
TYPE_OPTION =SIMP(statut='f',typ='TXM',defaut='TOUTES',fr="type d'options mecaniques lineaires",
into=("SIGM_MASSIF","SIGM_STRUCT","EPSI","ENER","CRIT","DERIVEES",
- "INDI_ERRE","AUTRES","TOUTES"),
+ "INDI_ERREUR","AUTRES","TOUTES"),
),
b_toutes=BLOC( condition = "TYPE_OPTION == 'TOUTES'",fr="toutes les options evol elas",
OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',defaut="SIEF_ELNO_ELGA",
# contraintes
into=( "SIEF_ELNO_ELGA","SIGM_ELNO_DEPL","SIEF_ELGA_DEPL",
"SIPO_ELNO_DEPL","EFGE_ELNO_DEPL","EFGE_ELNO_CART","SIGM_ELNO_CART",
- "SIGM_ELNO_SIEF","SIPO_ELNO_SIEF","SIGM_ELNO_TUYO",
+ "SIGM_ELNO_SIEF","SIPO_ELNO_SIEF","SIGM_ELNO_TUYO","ARCO_ELNO_SIGM",
# déformations
"EPSI_ELNO_DEPL","EPSI_ELGA_DEPL","EPSG_ELGA_DEPL","EPSG_ELNO_DEPL",
"EPME_ELNO_DEPL","EPME_ELGA_DEPL","DEGE_ELNO_DEPL","EPSI_ELNO_TUYO",
+ "EPVC_ELNO","EPVC_ELGA",
# ENER
"EPOT_ELEM_DEPL","ECIN_ELEM_DEPL","ENEL_ELGA","ENEL_ELNO_ELGA",
"ETOT_ELGA","ETOT_ELNO_ELGA","ETOT_ELEM",
# autres
"VNOR_ELEM_DEPL","VALE_NCOU_MAXI","PRES_DBEL_DEPL"),),
- NUME_COUCHE =SIMP(statut='f',typ='I',defaut= 1,
- fr="numero de couche dans l'épaisseur de la coque ou du tuyau" ),
- NIVE_COUCHE =SIMP(statut='f',typ='TXM',defaut="MOY",into=("SUP","INF","MOY"),
- fr="position dans l'épaisseur de la coque, ou de la couche" ),
- ANGLE =SIMP(statut='f',typ='I',defaut= 0,fr="angle en degres à partir de la génératrice"),
NOM_CHAM =SIMP(statut='f',typ='TXM',fr="nom du champ pour VALE_NCOU_MAXI", ),
NOM_CMP =SIMP(statut='f',typ='TXM',fr="nom de la composante pour VALE_NCOU_MAXI", ),
- PLAN = SIMP(statut='f',typ='TXM',defaut="MAIL",into=("SUP","INF","MOY","MAIL"),
- fr="Plan de calcul pour les plaques excentrées" ),
b_erre_qi =BLOC(condition = "OPTION in ('QIRE_ELEM_SIGM','QIZ1_ELEM_SIGM','QIZ2_ELEM_SIGM') or \
(type(OPTION)==type(()) and 'QIRE_ELEM_SIGM' in OPTION) or \
TYPE_CHARGE =SIMP(statut='f',typ='TXM',defaut="FIXE",into=("FIXE",),),),
),
- b_niv_couche = BLOC( condition = "OPTION in ('SIGM_ELNO_DEPL',) or \
- (type(OPTION)==type(()) and 'SIGM_ELNO_DEPL' in OPTION) ",
-
- NUME_COUCHE =SIMP(statut='f',typ='I',defaut= 1,
- fr="numero de couche dans l'épaisseur de la coque (coques multicouches)" ),
- NIVE_COUCHE =SIMP(statut='f',typ='TXM',defaut="MOY",into=("SUP","INF","MOY"),
- fr="position dans l'épaisseur de la coque, ou de la couche" ),
- ),
- b_sigtuyo = BLOC( condition = "OPTION == 'SIGM_ELNO_TUYO' or \
- (type(OPTION)==type(()) and 'SIGM_ELNO_TUYO' in OPTION) ",
- NUME_COUCHE =SIMP(statut='f',typ='I',defaut= 1 ,
- fr="numero de couche dans l'épaisseur du tuyau" ),
- ANGLE =SIMP(statut='f',typ='I',defaut= 0,fr="angle en degres à partir de la génératrice" ),
- NIVE_COUCHE =SIMP(statut='f',typ='TXM',defaut="MOY",into=("SUP","INF","MOY"),
- fr="position dans l'épaisseur de la couche" ),
- ),
- b_plan_excentrement =BLOC( condition = "OPTION=='EFGE_ELNO_DEPL' or \
- (type(OPTION)==type(()) and 'EFGE_ELNO_DEPL' in OPTION)",
- fr="Plan de calcul des efforts pour les plaques avec excentrement",
- PLAN = SIMP(statut='f',typ='TXM',defaut="MAIL",into=("SUP","INF","MOY","MAIL"),
- fr="Plan de calcul des efforts pour les plaques avec excentrement",),
-
- ),
),
# fin bloc contraintes struct
b_epsi =BLOC( condition = "TYPE_OPTION=='EPSI'",
OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
into=("EPSI_ELNO_DEPL","EPSI_ELGA_DEPL","EPME_ELNO_DEPL","EPME_ELGA_DEPL",
- "DEGE_ELNO_DEPL","EPSI_ELNO_TUYO",),
+ "DEGE_ELNO_DEPL","EPSI_ELNO_TUYO","EPVC_ELNO","EPVC_ELGA",),
),
- b_niv_couche = BLOC( condition = "OPTION =='EPSI_ELNO_DEPL' or \
- (type(OPTION)==type(()) and 'EPSI_ELNO_DEPL' in OPTION) ",
- NUME_COUCHE =SIMP(statut='f',typ='I',defaut= 1,
- fr="numero de couche dans l'épaisseur de la coque (coques multicouches)" ),
- NIVE_COUCHE =SIMP(statut='f',typ='TXM',defaut="MOY",into=("SUP","INF","MOY"),
- fr="position dans l'épaisseur de la coque, ou de la couche" ),
- ) ,
- b_epstuyo = BLOC( condition = "OPTION == 'EPSI_ELNO_TUYO' or \
- (type(OPTION)==type(()) and 'EPSI_ELNO_TUYO' in OPTION) ",
- NUME_COUCHE =SIMP(statut='f',typ='I',defaut= 1 ,
- fr="numero de couche dans l'épaisseur du tuyau" ),
- ANGLE =SIMP(statut='f',typ='I',defaut= 0,fr="angle en degres à partir de la génératrice" ),
- NIVE_COUCHE =SIMP(statut='f',typ='TXM',defaut="MOY",into=("SUP","INF","MOY"),
- fr="position dans l'épaisseur de la couche" ),
- ),
b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ELGA_DEPL','EPSI_ELNO_DEPL','EPSI_ELNO_TUYO' ) or \
(type(OPTION)==type(()) and 'EPSI_ELNO_DEPL' in OPTION ) or \
(type(OPTION)==type(()) and 'EPSI_ELNO_TUYO' in OPTION ) or \
"ENDO_ELGA","ENDO_ELNO_ELGA",
"ENDO_ELNO_SIGA","ENDO_ELNO_SINO","CRIT_ELNO_RUPT","SIEQ_ELNO_TUYO","EPEQ_ELNO_TUYO",
) ),
- b_niv_couche = BLOC( condition = "OPTION in ('CRIT_ELNO_RUPT','EQUI_ELNO_SIGM') or \
- (type(OPTION)==type(()) and 'EQUI_ELNO_SIGM' in OPTION) or \
- (type(OPTION)==type(()) and 'SIEQ_ELNO_TUYO' in OPTION) or \
- (type(OPTION)==type(()) and 'CRIT_ELNO_RUPT' in OPTION) ",
- NUME_COUCHE =SIMP(statut='f',typ='I',defaut= 1,
- fr="numero de couche dans l'épaisseur de la coque (coques multicouches)" ),
- NIVE_COUCHE =SIMP(statut='f',typ='TXM',defaut="MOY",into=("SUP","INF","MOY"),
- fr="position dans l'épaisseur de la coque, ou de la couche" ),
- ),
EXCIT =FACT(statut='f',max='**',fr="charge contenant les temperatures",
CHARGE =SIMP(statut='o',typ=(char_meca,char_ther,char_acou) ),),
),
NOM_CMP =SIMP(statut='o',typ='TXM',fr="Nom de la composante pour VALE_NCOU_MAXI"),),
),
- b_indi_erre =BLOC( condition = "TYPE_OPTION=='INDI_ERRE'",
+ b_indi_erreur =BLOC( condition = "TYPE_OPTION=='INDI_ERREUR'",
OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',defaut="ERRE_ELEM_SIGM",
into=("SIGM_NOZ1_ELGA","ERZ1_ELEM_SIGM","SIGM_NOZ2_ELGA","ERZ2_ELEM_SIGM",
"SIRE_ELNO_DEPL","ERRE_ELEM_SIGM","ERRE_ELNO_ELEM",
b_sing =BLOC(condition= "OPTION == 'SING_ELEM' or \
(type(OPTION)==type(()) and 'SING_ELEM' in OPTION)",
PREC_ERR=SIMP(statut='o',typ='R',val_min= 0.,val_max=1.,
- fr="precision demandee pour calculer la de taille des elements" ),),
+ fr="precision demandee pour calculer la carte de taille des elements" ),),
EXCIT =FACT(statut='f',max='**',fr="charge contenant les temperatures",
CHARGE =SIMP(statut='o',typ=(char_meca,char_ther,char_acou) ),),
b_noli =BLOC( condition = "AsType(RESULTAT) == evol_noli",fr="options evol noli",
TYPE_OPTION =SIMP(statut='f',typ='TXM',defaut='TOUTES',
into=("SIGM_MASSIF","SIGM_STRUCT","EPSI","ENER","CRIT",
- "VARI","INDI_ERRE","TOUTES","AUTRES"),
+ "VARI","INDI_ERREUR","TOUTES","AUTRES"),
),
b_toutes =BLOC( condition = "TYPE_OPTION == 'TOUTES'",fr="toutes les options evol elas",
OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
into=( "SIEF_ELNO_ELGA",
- "SIGM_ELNO_TUYO","SIGM_ELNO_COQU",
+ "SIGM_ELNO_TUYO","SIGM_ELNO_COQU","ARCO_ELNO_SIGM",
"SIGM_ELNO_SIEF","SIPO_ELNO_SIEF","EFGE_ELNO_CART",
# EPSI
"EPSI_ELNO_DEPL","EPSI_ELGA_DEPL","EPSG_ELNO_DEPL","EPSG_ELGA_DEPL",
"EPME_ELNO_DEPL","EPME_ELGA_DEPL","EPMG_ELNO_DEPL","EPMG_ELGA_DEPL",
"DEGE_ELNO_DEPL","EPSI_ELNO_TUYO",
"EPSP_ELNO","EPSP_ELGA",
- "EPGR_ELNO","EPGR_ELGA",
+ "EPFD_ELNO","EPFD_ELGA","EPVC_ELNO","EPVC_ELGA",
+ "EPFP_ELNO","EPFP_ELGA",
"VARI_ELNO_ELGA","VARI_ELNO_TUYO","VARI_ELNO_COQU","CRIT_ELNO_RUPT",
"EXTR_ELGA_VARI","EXTR_ELNO_VARI",
# CRIT
into=("VMIS","TOTAL","VMIS_CINE","TOTAL_CINE"),
fr="Type de norme pour les options RADI_ et DCHA_"),
- NUME_COUCHE =SIMP(statut='f',typ='I',defaut= 1,fr="numéro de couche pour coques et tuyaux" ),
- NIVE_COUCHE =SIMP(statut='f',typ='TXM',defaut="MOY",into=("SUP","INF","MOY"),
- fr="choix du point d'intégration dans la couche" ),
- ANGLE =SIMP(statut='f',typ='I',defaut= 0 ,fr="angle de dépouillement pour les tuyaux"),
NOM_CHAM =SIMP(statut='f',typ='TXM',fr="Nom du champ pour VALE_NCOU_MAXI"),
NOM_CMP =SIMP(statut='f',typ='TXM',fr="Nom de la composante pour VALE_NCOU_MAXI"),
- PLAN = SIMP(statut='f',typ='TXM',defaut="MAIL",into=("SUP","INF","MOY","MAIL") ),
b_erre_qi =BLOC(condition = "OPTION in ('QIRE_ELEM_SIGM','QIZ1_ELEM_SIGM','QIZ2_ELEM_SIGM') or \
(type(OPTION)==type(()) and 'QIRE_ELEM_SIGM' in OPTION) or \
# contraintes
into=( "SIEF_ELNO_ELGA","EFGE_ELNO_CART","SIGM_ELNO_TUYO","SIGM_ELNO_COQU",
"SIGM_ELNO_SIEF","SIPO_ELNO_SIEF",),),
- b_sigcoqu = BLOC( condition = "OPTION in ('SIGM_ELNO_COQU',) or \
- (type(OPTION)==type(()) and 'SIGM_ELNO_COQU' in OPTION) ",
- NUME_COUCHE =SIMP(statut='f',typ='I',defaut= 1,
- fr="numéro de couche dans l'épaisseur de la coque" ),
- NIVE_COUCHE =SIMP(statut='f',typ='TXM',defaut="MOY",into=("SUP","INF","MOY"),
- fr="choix du point d'intégration dans la couche" ),
- ),
- b_sigtuyo = BLOC( condition = "OPTION in ('SIGM_ELNO_TUYO',) or \
- (type(OPTION)==type(()) and 'SIGM_ELNO_TUYO' in OPTION)",
- NUME_COUCHE =SIMP(statut='f',typ='I',defaut= 1,
- fr="numéro de couche dans l'épaisseur du tuyau" ),
- ANGLE =SIMP(statut='f',typ='I',defaut= 0,
- fr="angle de dépouillement pour les tuyaux, en degres" ),
- NIVE_COUCHE =SIMP(statut='f',typ='TXM',defaut="MOY",into=("SUP","INF","MOY"),
- fr="choix du point d'intégration dans la couche"),
- ),
),
b_epsi =BLOC( condition = "TYPE_OPTION=='EPSI'",
OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
into=( "EPSI_ELNO_DEPL","EPSI_ELGA_DEPL","EPSG_ELNO_DEPL","EPSG_ELGA_DEPL",
"EPME_ELNO_DEPL","EPME_ELGA_DEPL","EPMG_ELNO_DEPL","EPMG_ELGA_DEPL",
- "EPSP_ELNO","EPSP_ELGA","EPGR_ELNO","EPGR_ELGA",
- "DEGE_ELNO_DEPL",),
+ "EPSP_ELNO","EPSP_ELGA","DEGE_ELNO_DEPL","EPVC_ELNO","EPVC_ELGA",
+ "EPFD_ELNO","EPFD_ELGA","EPFP_ELNO","EPFP_ELGA"),
),
- b_niv_couche = BLOC( condition = "OPTION =='EPSI_ELNO_DEPL' or \
- (type(OPTION)==type(()) and 'EPSI_ELNO_DEPL' in OPTION) ",
- NUME_COUCHE =SIMP(statut='f',typ='I',defaut= 1,
- fr="numero de couche dans l'épaisseur de la coque (coques multicouches)" ),
- NIVE_COUCHE =SIMP(statut='f',typ='TXM',defaut="MOY",into=("SUP","INF","MOY"),
- fr="position dans l'épaisseur de la coque, ou de la couche" ),
- ) ,
EXCIT =FACT(statut='f',max='**',fr="charge contenant les temperatures",
CHARGE =SIMP(statut='o',typ=(char_meca,char_ther,char_acou) ),),
),
- b_epstuyo = BLOC( condition = "OPTION == 'EPSI_ELNO_TUYO' or \
+ b_epstuyo =BLOC( condition = "OPTION == 'EPSI_ELNO_TUYO' or \
(type(OPTION)==type(()) and 'EPSI_ELNO_TUYO' in OPTION) ",
- NUME_COUCHE =SIMP(statut='f',typ='I',defaut= 1 ,
- fr="numero de couche dans l'épaisseur du tuyau" ),
- ANGLE =SIMP(statut='f',typ='I',defaut= 0,fr="angle en degres à partir de la génératrice" ),
- NIVE_COUCHE =SIMP(statut='f',typ='TXM',defaut="MOY",into=("SUP","INF","MOY"),
- fr="position dans l'épaisseur de la couche" ),
EXCIT =FACT(statut='f',max='**',fr="charge contenant les temperatures",
CHARGE =SIMP(statut='o',typ=(char_meca,char_ther,char_acou) ),),
),
into=("VARI_ELNO_ELGA","VARI_ELNO_TUYO","VARI_ELNO_COQU",
"EXTR_ELGA_VARI","EXTR_ELNO_VARI"),
),
- b_varcoqu = BLOC( condition = "OPTION in ('VARI_ELNO_COQU',) or \
- (type(OPTION)==type(()) and 'VARI_ELNO_COQU' in OPTION) ",
- NUME_COUCHE =SIMP(statut='f',typ='I',defaut= 1,
- fr="numéro de couche dans l'épaisseur de la coque"),
- NIVE_COUCHE =SIMP(statut='f',typ='TXM',defaut="MOY",into=("SUP","INF","MOY"),
- fr="choix du point d'intégration dans la couche" ),
- ),
- b_vartuyo = BLOC( condition = "OPTION in ('VARI_ELNO_TUYO',) or \
- (type(OPTION)==type(()) and 'VARI_ELNO_TUYO' in OPTION) ",
- NUME_COUCHE =SIMP(statut='f',typ='I',defaut= 1,
- fr="numéro de couche dans l'épaisseur de tuyau" ),
- ANGLE =SIMP(statut='f',typ='I',defaut= 0,
- fr="angle de dépouillement pour les tuyaux, en degres"),
- NIVE_COUCHE =SIMP(statut='f',typ='TXM',defaut="MOY",into=("SUP","INF","MOY"),
- fr="choix du point d'intégration dans la couche" ),
- ),
- b_extr = BLOC( condition = "OPTION in ('EXTR_ELNO_VARI','EXTR_ELGA_VARI')",
- NOM_VARI =SIMP(statut='o',typ='TXM',min= 1,max=1,fr="nom de la variable à extraire",
+ b_extr =BLOC( condition = "OPTION in ('EXTR_ELNO_VARI','EXTR_ELGA_VARI')",
+ NOM_VARI =SIMP(statut='o',typ='TXM',min= 1,max=1,fr="nom de la variable à extraire",
into=("DPORO","DRHOLQ","DPVP","SATLIQ","EVP","IND_ETA","D","IND_END","TEMP_MAX","GAMP","PCR",
"SEUIL_HYD","IND_HYD","PCOHE","COMP_ROC","SEUIL_ISO","ANG_DEV","X11","X22","X33","X12","X13","X23",
"DIST_DEV","DEV_SUR_CRIT","DIST_ISO","NB_ITER","ARRET","NB_REDE","SIGNE"),),
"ENDO_ELGA","ENDO_ELNO_ELGA",
"PMPB_ELNO_SIEF","PMPB_ELGA_SIEF","SIEQ_ELNO_TUYO","EPEQ_ELNO_TUYO",
) ),
- NUME_COUCHE =SIMP(statut='f',typ='I',defaut= 1,fr="numéro de couche dans l'épaisseur de la coque"),
- NIVE_COUCHE =SIMP(statut='f',typ='TXM',defaut="MOY",into=("SUP","INF","MOY"),
- fr="choix du point d'intégration dans la couche" ),
),
b_autres =BLOC( condition = "TYPE_OPTION=='AUTRES'",
),
- b_indi_erre =BLOC( condition = "TYPE_OPTION=='INDI_ERRE'",
+ b_indi_erreur =BLOC( condition = "TYPE_OPTION=='INDI_ERREUR'",
OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',defaut="ERRE_ELEM_SIGM",
into=("ERRE_ELEM_SIGM","ERRE_ELNO_ELEM","ERZ1_ELEM_SIGM","ERZ2_ELEM_SIGM",
"DCHA_ELNO_SIGM","DCHA_ELGA_SIGM","RADI_ELNO_SIGM","RADI_ELGA_SIGM",
),
# fin bloc evol_noli
-# thermique : evol_ther
- b_ther =BLOC( condition = "AsType(RESULTAT) == evol_ther",fr="options thermiques",
+# thermique : evol_ther, fourier_ther
+ b_ther =BLOC( condition = "AsType(RESULTAT) in (evol_ther,fourier_ther,)" ,fr="options thermiques",
OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
into=("DEUL_ELGA_TEMP","DETE_ELNO_DLTE","FLUX_ELGA_TEMP","FLUX_ELNO_TEMP",
"HYDR_ELNO_ELGA","DURT_ELGA_META","DURT_ELNO_META",
PUIS_PULS =SIMP(statut='f',typ='I'),
TYPE_CHARGE =SIMP(statut='f',typ='TXM',defaut="FIXE",into=("FIXE",),),
),
- NIVE_COUCHE =SIMP(statut='f',typ='TXM',defaut="MOY",into=("SUP","INF","MOY"),
- fr="choix du point de calcul dans l'épaisseur des coques" ),
-
),
# acoustique
INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
) ;
-#& MODIF COMMANDE DATE 16/05/2006 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 16/10/2006 AUTEUR JMBHH01 J.M.PROIX
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**' ),
COEF_PREECROU =SIMP(statut='f',typ='R',defaut= 1.0E+0),
b_period =BLOC(condition = "TYPE_CHARGE == 'PERIODIQUE'",
- CRITERE =SIMP(statut='o',typ='TXM',into=("MATAKE","DANG_VAN_MODI_AC") ),
- METHODE =SIMP(statut='o',typ='TXM',into=("CERCLE_EXACT",) ),
+ CRITERE =SIMP(statut='o',typ='TXM',into=("MATAKE_MODI_AC","DANG_VAN_MODI_AC","VMIS_TRESCA") ),
+ b_fati_p =BLOC(condition = "(CRITERE == 'MATAKE_MODI_AC' or CRITERE == 'DANG_VAN_MODI_AC')",
+ METHODE =SIMP(statut='o',typ='TXM',into=("CERCLE_EXACT",) ),
+ ),
),
b_non_period =BLOC(condition = "TYPE_CHARGE == 'NON_PERIODIQUE'",
- CRITERE =SIMP(statut='o',typ='TXM',into=("DOMM_MAXI","DANG_VAN_MODI_AV","FATEMI_SOCIE") ),
- PROJECTION =SIMP(statut='o',typ='TXM',into=("UN_AXE", "DEUX_AXES") ),
- DELTA_OSCI =SIMP(statut='f',typ='R',defaut= 0.0E+0),
+ CRITERE =SIMP(statut='o',typ='TXM',
+ into=("MATAKE_MODI_AV","DANG_VAN_MODI_AV","FATESOCI_MODI_AV","VMIS_TRESCA") ),
+ b_fati_np =BLOC(condition =
+ "(CRITERE == 'MATAKE_MODI_AV' or CRITERE == 'DANG_VAN_MODI_AV' or CRITERE == 'FATESOCI_MODI_AV')",
+ PROJECTION =SIMP(statut='o',typ='TXM',into=("UN_AXE", "DEUX_AXES") ),
+ DELTA_OSCI =SIMP(statut='f',typ='R',defaut= 0.0E+0),
+ ),
),
b_fati_grmano =BLOC(condition = "(GROUP_MA != None or MAILLE != None or GROUP_NO != None or NOEUD != None)",
MAILLAGE =SIMP(statut='o',typ=maillage_sdaster ),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2 ) ),
) ;
-#& MODIF COMMANDE DATE 19/09/2005 AUTEUR DURAND C.DURAND
+#& MODIF COMMANDE DATE 07/11/2006 AUTEUR DURAND C.DURAND
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
AMOR_REDUIT =SIMP(statut='f',typ='R',max='**'),
LIST_FREQ =SIMP(statut='f',typ=listr8_sdaster ),
FREQ =SIMP(statut='f',typ='R',max='**'),
- NORME =SIMP(statut='o',typ='R',defaut= 9.81E+0,fr="Valeur de la norme du spectre d oscillateur" ),
+ NORME =SIMP(statut='o',typ='R',fr="Valeur de la norme du spectre d oscillateur" ),
NATURE =SIMP(statut='f',typ='TXM',defaut="ACCE",into=("DEPL","VITE","ACCE") ),
NATURE_FONC =SIMP(statut='f',typ='TXM',defaut="ACCE",into=("DEPL","VITE","ACCE") ),
),
),
) ;
-#& MODIF COMMANDE DATE 29/05/2006 AUTEUR GALENNE E.GALENNE
+#& MODIF COMMANDE DATE 31/10/2006 AUTEUR REZETTE C.REZETTE
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG
+" et les facteurs d'intensité de contraintes.",
reentrant='f',
UIinfo={"groupes":("Post traitements",)},
- regles=(UN_PARMI('RESULTAT','DEPL'),
- PRESENT_PRESENT('VITE','ACCE'),
- EXCLUS('COMP_ELAS','COMP_INCR'),
+ regles=(EXCLUS('COMP_ELAS','COMP_INCR'),
CONCEPT_SENSIBLE("ENSEMBLE"),
REUSE_SENSIBLE(),
- DERIVABLE('RESULTAT'),),
- MODELE =SIMP(statut='f',typ=modele_sdaster),
- CHAM_MATER =SIMP(statut='f',typ=cham_mater),
+ DERIVABLE('RESULTAT'),
+ EXCLUS('TOUT_ORDRE','NUME_ORDRE','LIST_ORDRE','INST','LIST_INST',
+ 'TOUT_MODE','NUME_MODE','LIST_MODE','FREQ','LIST_FREQ',),),
THETA =FACT(statut='o',
THETA =SIMP(statut='f',typ=(theta_geom,cham_no_sdaster),),
regles=(UN_PARMI('R_INF','R_INF_FO'),
EXCLUS('MODULE','MODULE_FO'),
PRESENT_PRESENT('R_INF','R_SUP'),
- PRESENT_PRESENT('R_INF_FO','R_SUP_FO'), ),
+ PRESENT_PRESENT('R_INF_FO','R_SUP_FO'), ),
+ NUME_FOND =SIMP(statut='f',typ='I',defaut=1),
R_INF =SIMP(statut='f',typ='R'),
R_SUP =SIMP(statut='f',typ='R'),
MODULE =SIMP(statut='f',typ='R'),
),
),
- DEPL =SIMP(statut='f',typ=cham_no_sdaster),
- VITE =SIMP(statut='f',typ=cham_no_sdaster),
- ACCE =SIMP(statut='f',typ=cham_no_sdaster),
- RESULTAT =SIMP(statut='f',typ=(evol_elas,evol_noli,dyna_trans,mode_meca),),
+ RESULTAT =SIMP(statut='o',typ=(evol_elas,evol_noli,dyna_trans,mode_meca),),
- b_extrac =BLOC(condition="RESULTAT != None",fr="extraction d un champ",
- regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','LIST_ORDRE','INST','LIST_INST',
- 'TOUT_MODE','NUME_MODE','LIST_MODE','FREQ','LIST_FREQ',),),
- TOUT_ORDRE =SIMP(statut='f',typ='TXM',into=("OUI",) ),
- NUME_ORDRE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
- LIST_ORDRE =SIMP(statut='f',typ=listis_sdaster),
- INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),
- LIST_INST =SIMP(statut='f',typ=listr8_sdaster),
- TOUT_MODE =SIMP(statut='f',typ='TXM',into=("OUI",) ),
- NUME_MODE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
- LIST_MODE =SIMP(statut='f',typ=listis_sdaster),
- LIST_FREQ =SIMP(statut='f',typ=listr8_sdaster),
- FREQ =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),
+ TOUT_ORDRE =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+ NUME_ORDRE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
+ LIST_ORDRE =SIMP(statut='f',typ=listis_sdaster),
+ INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),
+ LIST_INST =SIMP(statut='f',typ=listr8_sdaster),
+ TOUT_MODE =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+ NUME_MODE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
+ LIST_MODE =SIMP(statut='f',typ=listis_sdaster),
+ LIST_FREQ =SIMP(statut='f',typ=listr8_sdaster),
+ FREQ =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),
- b_acce_reel =BLOC(condition="(INST != None)or(LIST_INST != None)or(FREQ != None)or(LIST_FREQ != None)",
- PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-6),
- CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
- ),
- ),
+ b_acce_reel =BLOC(condition="(INST != None)or(LIST_INST != None)or(FREQ != None)or(LIST_FREQ != None)",
+ PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-6),
+ CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
+ ),
+
EXCIT =FACT(statut='f',max='**',
- CHARGE =SIMP(statut='o',typ=(char_meca,char_cine_meca)),
+ CHARGE =SIMP(statut='f',typ=(char_meca,char_cine_meca)),
FONC_MULT =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
TYPE_CHARGE =SIMP(statut='f',typ='TXM',defaut="FIXE",into=("FIXE",) ),
),
LISSAGE =FACT(statut='d',
DEGRE =SIMP(statut='f',typ='I',defaut=5,into=(0,1,2,3,4,5,6,7) ),
- LISSAGE_THETA =SIMP(statut='f',typ='TXM',defaut="LEGENDRE",into=("LEGENDRE","LAGRANGE"),),
- LISSAGE_G =SIMP(statut='f',typ='TXM',defaut="LEGENDRE",into=("LEGENDRE","LAGRANGE","LAGRANGE_NO_NO"),),
+ LISSAGE_THETA =SIMP(statut='f',typ='TXM',defaut="LEGENDRE",into=("LEGENDRE","LAGRANGE","LAGRANGE_REGU"),),
+ LISSAGE_G =SIMP(statut='f',typ='TXM',defaut="LEGENDRE",into=("LEGENDRE","LAGRANGE",
+ "LAGRANGE_NO_NO","LAGRANGE_REGU"),),
),
OPTION =SIMP(statut='o',typ='TXM',max=1,defaut='CALC_G',
into=("CALC_G","CALC_G_GLOB","CALC_K_G","K_G_MODA","G_MAX","G_MAX_GLOB","G_BILI",
- "G_BILI_GLOB","G_LAGR","G_LAGR_GLOB"),),
+ "G_BILI_GLOB","G_LAGR","G_LAGR_GLOB","CALC_K_MAX"),),
b_g_max =BLOC(condition="(OPTION=='G_MAX') or (OPTION=='G_MAX_GLOB')",
BORNES =FACT(statut='o',max='**',
VALE_MAX =SIMP(statut='o',typ='R'),
),
),
+ b_k_max =BLOC(condition="(OPTION=='CALC_K_MAX')",
+ SIGNES =FACT(statut='o',max=1,
+ CHARGE_S =SIMP(statut='o',typ='I',validators=NoRepeat(),max='**'),
+ CHARGE_NS =SIMP(statut='o',typ='I',validators=NoRepeat(),max='**'),
+ ),
+ ),
+
PROPAGATION =SIMP(statut='f',typ='R'),
THETA_LAGR =SIMP(statut='f',typ=theta_geom),
DIRE_THETA_LAGR =SIMP(statut='f',typ=cham_no_sdaster),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
);
-#& MODIF COMMANDE DATE 03/01/2006 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
-CALC_INTE_SPEC=OPER(nom="CALC_INTE_SPEC",op= 120,sd_prod=table_sdaster,
+CALC_INTE_SPEC=OPER(nom="CALC_INTE_SPEC",op= 120,sd_prod=table_fonction,
fr="Calcul d'une matrice interspectrale à partir d'une fonction du temps",
reentrant='n',
UIinfo={"groupes":("Fonction",)},
NB_POIN =SIMP(statut='o',typ='I' ),
FONCTION =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule),max='**' ),
TITRE =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'),
- INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+ INFO =SIMP(statut='f',typ='I',defaut=1,into=(1 , 2) ),
) ;
#& MODIF COMMANDE DATE 21/02/2006 AUTEUR REZETTE C.REZETTE
# CONFIGURATION MANAGEMENT OF EDF VERSION
OPTION =SIMP(statut='f',typ='TXM'
,into=("META_ELNO_TEMP",) ),
) ;
-#& MODIF COMMANDE DATE 10/05/2006 AUTEUR MCOURTOI M.COURTOIS
+#& MODIF COMMANDE DATE 24/10/2006 AUTEUR SMICHEL S.MICHEL-PONNELLE
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
RESULTAT =SIMP(statut='o',typ=(evol_elas,dyna_trans,dyna_harmo,acou_harmo,mode_meca,
mode_acou,mode_stat,mode_stat_depl,mode_stat_acce,
mode_stat_forc,evol_ther,evol_noli,base_modale,
- mult_elas,fourier_elas,mode_flamb ) ),
+ mult_elas,fourier_elas,fourier_ther,mode_flamb ) ),
SENSIBILITE =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**',
fr="Liste des paramètres de sensibilité.",
ang="List of sensitivity parameters"),
"EPSG_NOEU_DEPL",
"EPSI_NOEU_DEPL",
"EPSP_NOEU" ,"EPSP_NOEU_ZAC",
+ "EPVC_NOEU","EPFD_NOEU","EPFP_NOEU","EPFP_NOEU",
"EQUI_NOEU_EPME","EQUI_NOEU_EPSI","EQUI_NOEU_SIGM",
"ERRE_NOEU_ELEM","QIRE_NOEU_ELEM",
"FLUX_NOEU_TEMP",
GROUP_NO_RESU =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
NOEUD_RESU =SIMP(statut='f',typ=ma,validators=NoRepeat(),max='**'),
) ;
-#& MODIF COMMANDE DATE 16/05/2006 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 10/10/2006 AUTEUR REZETTE C.REZETTE
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2003 EDF R&D WWW.CODE-ASTER.ORG
INST_INIT =SIMP(statut='f',typ='R'),
INST_FIN =SIMP(statut='f',typ='R'),
PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-3 ),
- SUBD_PAS =SIMP(statut='f',typ='I',defaut=1),
- SUBD_PAS_MINI =SIMP(statut='f',typ='R'),
- COEF_SUBD_PAS_1 =SIMP(statut='f',typ='R',defaut= 1.0E+0),
+ # DEBUT DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS
+ SUBD_METHODE =SIMP( statut='f',typ='TXM',
+ into =("AUCUNE","UNIFORME","EXTRAPOLE"),
+ defaut="AUCUNE",
+ fr="Méthode de subdivision des pas de temps en cas de non-convergence"
+ ),
+ b_subd_unif=BLOC(condition = "SUBD_METHODE == 'UNIFORME'",
+ regles=(AU_MOINS_UN('SUBD_NIVEAU','SUBD_PAS_MINI'),),
+ SUBD_COEF_PAS_1=SIMP(statut='f',typ='R',defaut=1.0,val_min=0.0,
+ fr="Coefficient multiplicateur de la 1ère subdivision"),
+ SUBD_PAS =SIMP(statut='f',typ='I',defaut=4,val_min=2,
+ fr="Nombre de subdivision d'un pas de temps"),
+ SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2,
+ fr="Nombre maximum de niveau de subdivision d'un pas de temps"),
+ SUBD_PAS_MINI=SIMP(statut='f',typ='R',val_min=0.0,
+ fr="Pas de temps en dessous duquel on ne subdivise plus"),
+ ),
+ b_subd_extr=BLOC(condition = "SUBD_METHODE == 'EXTRAPOLE'",
+ regles=(AU_MOINS_UN('SUBD_NIVEAU','SUBD_PAS_MINI'),),
+ SUBD_OPTION =SIMP(statut='f',typ='TXM',
+ into =("IGNORE_PREMIERES","GARDE_DERNIERES",),
+ defaut="IGNORE_PREMIERES",
+ fr="Technique d'extrapolation : les 1ere itérations sont ignorées ou les dernières sont gardées"),
+ SUBD_ITER_IGNO =SIMP(statut='c',typ='I',defaut=3,val_min=0,
+ fr="Les n premières itérations sont ignorées pour l'extrapolation"),
+ SUBD_ITER_FIN =SIMP(statut='c',typ='I',defaut=8,val_min=3,
+ fr="Seules les n dernières itérations sont prises pour l'extrapolation"),
+ SUBD_PAS =SIMP(statut='c',typ='I',defaut=4,val_min=2,
+ fr="Nombre de subdivision d'un pas de temps en cas divergence"),
+ SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2,
+ fr="Nombre maximum de niveau de subdivision d'un pas de temps"),
+ SUBD_PAS_MINI=SIMP(statut='f',typ='R',val_min=0.0,
+ fr="Pas de temps en dessous duquel on ne subdivise plus"),
+ SUBD_ITER_PLUS =SIMP(statut='c',typ='I',defaut=50,val_min=20,
+ fr="% itération autorisée en plus"),
+ ),
+ # FIN DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS
),
NEWTON =FACT(statut='d',
R =SIMP(statut='f',typ='R',defaut= 1000.),
ITER_PRIM_MAXI =SIMP(statut='f',typ='I',defaut= 10),
),
- PARM_THETA =SIMP(statut='f',typ='R'
- ,defaut= 1. ),
INFO =SIMP(statut='f',typ='I',into=(1,2) ),
TITRE =SIMP(statut='f',typ='TXM',max='**' ),
COMP_INCR =C_COMP_INCR(),
) ;
-#& MODIF COMMANDE DATE 10/05/2006 AUTEUR MCOURTOI M.COURTOIS
+#& MODIF COMMANDE DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2005 EDF R&D WWW.CODE-ASTER.ORG
# RESPONSABLE MCOURTOI M.COURTOIS
-def calc_table_prod(self, TABLE, **kargs):
+def calc_table_prod(self, TABLE, ACTION, **kargs):
"""Typage du concept produit.
"""
- typ_table = AsType(TABLE)
- if issubclass(typ_table, table_sdaster):
- return typ_table
- raise AsException("type de concept resultat non prevu")
+ l_typ = [AsType(TABLE),]
+ for mcf in ACTION:
+ dmc = mcf.cree_dict_valeurs(mcf.mc_liste)
+ if dmc.get('TABLE') != None:
+ l_typ.append(AsType(dmc['TABLE']))
+ # une table_fonction étant une table
+ if table_fonction in l_typ:
+ return table_fonction
+ else:
+ return table_sdaster
+
from Macro.calc_table_ops import calc_table_ops
CALC_TABLE=MACRO(nom="CALC_TABLE",op=calc_table_ops, sd_prod=calc_table_prod,
- fr="Opérations sur une table",
- reentrant='f',
+ fr="Opérations sur une table",
+ reentrant='f',
regles=(DERIVABLE('TABLE'),),
TABLE = SIMP(statut='o',typ=table_sdaster),
ACTION = FACT(statut='o', max='**',
INST =SIMP(statut='f',typ='R',defaut= 0.E+0 ),
),
) ;
-#& MODIF COMMANDE DATE 16/05/2006 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 12/09/2006 AUTEUR REZETTE C.REZETTE
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
# RESPONSABLE G8BHHXD X.DESROCHES
-
-COMB_CHAM_ELEM=OPER(nom="COMB_CHAM_ELEM",op= 139,sd_prod=cham_elem,reentrant='f',
- fr="Effectuer la combinaison linéaire de champs par éléments",
- UIinfo={"groupes":("Résultats et champs",)},
- regles=(UN_PARMI('COMB_R','COMB_C','COMB_FOURIER'),
- PRESENT_PRESENT('COMB_FOURIER','ANGL'),),
- COMB_R =FACT(statut='f',max='**',
- PARTIE =SIMP(statut='f',typ='TXM',into=("REEL","IMAG") ),
- COEF_R =SIMP(statut='o',typ='R'),
- CHAM_ELEM =SIMP(statut='o',typ=cham_elem),
- ),
- COMB_C =FACT(statut='f',max='**',
- regles=(UN_PARMI('COEF_R','COEF_C', ),),
- COEF_R =SIMP(statut='f',typ='R'),
- COEF_C =SIMP(statut='f',typ='C'),
- CHAM_ELEM =SIMP(statut='o',typ=cham_elem),
- ),
- COMB_FOURIER =FACT(statut='f',max='**',
- COEF_R =SIMP(statut='f',typ='R',defaut= 1.),
- NUME_MODE =SIMP(statut='o',typ='I'),
- TYPE_MODE =SIMP(statut='o',typ='TXM',into=("SYME","ANTI") ),
- CHAM_ELEM =SIMP(statut='o',typ=cham_elem),
- ),
- ANGL =SIMP(statut='f',typ='R' ),
-) ;
-
-#& MODIF COMMANDE DATE 21/02/2006 AUTEUR REZETTE C.REZETTE
+COMB_FOURIER=OPER(nom="COMB_FOURIER",op= 161,sd_prod=comb_fourier,
+ reentrant='n',fr="Recombiner les modes de Fourier d'une SD Résultat dans des directions particulières",
+ UIinfo={"groupes":("Post traitements",)},
+ RESULTAT =SIMP(statut='o',typ=(fourier_elas,fourier_ther),),
+ ANGL =SIMP(statut='o',typ='R',max='**'),
+ NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=6,
+ into=("DEPL","REAC_NODA","SIEF_ELGA_DEPL","EPSI_ELNO_DEPL","SIGM_ELNO_DEPL","TEMP","FLUX_ELNO_TEMP"),),
+) ;
+#& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
-# RESPONSABLE G8BHHXD X.DESROCHES
-def comb_cham_no_prod(COMB_R,**args):
- typ=cham_no_sdaster
- if COMB_R != None:
- type_mat = AsType(COMB_R[0]['CHAM_NO'])
- if type_mat == matr_asse_gene_r : typ= matr_asse_gene_r
- return typ
-
-COMB_CHAM_NO=OPER(nom="COMB_CHAM_NO",op= 30,sd_prod=comb_cham_no_prod
- ,fr="Effectuer la combinaison linéaire de champs aux noeuds",
- reentrant='f',
+# RESPONSABLE VABHHTS J.PELLET
+def comb_matr_asse_prod(COMB_R,COMB_C,CALC_AMOR_GENE,**args):
+ if COMB_C != None:
+ type_mat = AsType(COMB_C[0]['MATR_ASSE'])
+ if type_mat in (matr_asse_depl_c,matr_asse_depl_r) : return matr_asse_depl_c
+ if type_mat in (matr_asse_gene_c,matr_asse_gene_r) : return matr_asse_gene_c
+ if type_mat in (matr_asse_temp_c,matr_asse_temp_r) : return matr_asse_temp_c
+ if type_mat in (matr_asse_pres_c,matr_asse_pres_r) : return matr_asse_pres_c
+ elif COMB_R != None:
+ type_mat = AsType(COMB_R[0]['MATR_ASSE'])
+ if type_mat in (matr_asse_depl_c,matr_asse_depl_r) : return matr_asse_depl_r
+ if type_mat in (matr_asse_temp_c,matr_asse_temp_r) : return matr_asse_temp_r
+ if type_mat in (matr_asse_pres_c,matr_asse_pres_r) : return matr_asse_pres_r
+ if type_mat in (matr_asse_gene_c,matr_asse_gene_r) : return matr_asse_gene_r
+ elif CALC_AMOR_GENE != None: return matr_asse_gene_r
+ raise AsException("type de concept resultat non prevu")
+
+COMB_MATR_ASSE=OPER(nom="COMB_MATR_ASSE",op= 31,sd_prod=comb_matr_asse_prod,
+ fr="Effectuer la combinaison linéaire de matrices assemblées",
+ reentrant='f',
UIinfo={"groupes":("Résultats et champs",)},
- regles=(UN_PARMI('COMB_R','COMB_C','COMB_FOURIER'),),
+ regles=(UN_PARMI('COMB_R','COMB_C','CALC_AMOR_GENE' ),),
COMB_R =FACT(statut='f',max='**',
- PARTIE =SIMP(statut='f',typ='TXM',into=("REEL","IMAG",) ),
- CHAM_NO =SIMP(statut='o',typ=cham_no_sdaster),
+ PARTIE =SIMP(statut='f',typ='TXM',into=("REEL","IMAG") ),
+ MATR_ASSE =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_depl_c,matr_asse_temp_r,matr_asse_temp_c
+ ,matr_asse_pres_r,matr_asse_pres_c,matr_asse_gene_r,matr_asse_gene_c ) ),
COEF_R =SIMP(statut='o',typ='R' ),
),
COMB_C =FACT(statut='f',max='**',
regles=(UN_PARMI('COEF_R','COEF_C' ),),
- CHAM_NO =SIMP(statut='o',typ=cham_no_sdaster),
+ MATR_ASSE =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_depl_c,matr_asse_temp_r,matr_asse_temp_c
+ ,matr_asse_pres_r,matr_asse_pres_c,matr_asse_gene_r,matr_asse_gene_c ) ),
COEF_R =SIMP(statut='f',typ='R' ),
COEF_C =SIMP(statut='f',typ='C' ),
),
- COMB_FOURIER =FACT(statut='f',max='**',
- CHAM_NO =SIMP(statut='o',typ=cham_no_sdaster),
- COEF_R =SIMP(statut='f',typ='R',defaut= 1. ),
- NUME_MODE =SIMP(statut='o',typ='I' ),
- TYPE_MODE =SIMP(statut='o',typ='TXM',into=("SYME","ANTI") ),
- ),
- b_angl = BLOC ( condition = "COMB_FOURIER != None",
- ANGL =SIMP(statut='o',typ='R' ),
- ),
+ CALC_AMOR_GENE =FACT(statut='f',
+ regles=(UN_PARMI('AMOR_REDUIT','LIST_AMOR' ),),
+ MASS_GENE = SIMP(statut='f', typ=matr_asse_gene_r),
+ RIGI_GENE = SIMP(statut='f', typ=matr_asse_gene_r),
+ AMOR_REDUIT = SIMP(statut='f',typ='R',max='**'),
+ LIST_AMOR = SIMP(statut='f',typ=listr8_sdaster ),
+ ),
+ SANS_CMP =SIMP(statut='f',typ='TXM',into=("LAGR",) ),
) ;
-#& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE
-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2001 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 G8BHHXD X.DESROCHES
-COMB_FOURIER=OPER(nom="COMB_FOURIER",op= 161,sd_prod=comb_fourier,
- reentrant='n',fr="Recombiner les modes de Fourier d'une SD Résultat dans des directions particulières",
- UIinfo={"groupes":("Post traitements",)},
- RESULTAT =SIMP(statut='o',typ=fourier_elas ),
- ANGL =SIMP(statut='o',typ='R',max='**'),
- NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=5,
- into=("DEPL","REAC_NODA","SIEF_ELGA_DEPL","EPSI_ELNO_DEPL","SIGM_ELNO_DEPL") ),
-) ;
-#& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE
-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2001 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 VABHHTS J.PELLET
-def comb_matr_asse_prod(COMB_R,COMB_C,CALC_AMOR_GENE,**args):
- if COMB_C != None:
- type_mat = AsType(COMB_C[0]['MATR_ASSE'])
- if type_mat in (matr_asse_depl_c,matr_asse_depl_r) : return matr_asse_depl_c
- if type_mat in (matr_asse_gene_c,matr_asse_gene_r) : return matr_asse_gene_c
- if type_mat in (matr_asse_temp_c,matr_asse_temp_r) : return matr_asse_temp_c
- if type_mat in (matr_asse_pres_c,matr_asse_pres_r) : return matr_asse_pres_c
- elif COMB_R != None:
- type_mat = AsType(COMB_R[0]['MATR_ASSE'])
- if type_mat in (matr_asse_depl_c,matr_asse_depl_r) : return matr_asse_depl_r
- if type_mat in (matr_asse_temp_c,matr_asse_temp_r) : return matr_asse_temp_r
- if type_mat in (matr_asse_pres_c,matr_asse_pres_r) : return matr_asse_pres_r
- if type_mat in (matr_asse_gene_c,matr_asse_gene_r) : return matr_asse_gene_r
- elif CALC_AMOR_GENE != None: return matr_asse_gene_r
- raise AsException("type de concept resultat non prevu")
-
-COMB_MATR_ASSE=OPER(nom="COMB_MATR_ASSE",op= 31,sd_prod=comb_matr_asse_prod,
- fr="Effectuer la combinaison linéaire de matrices assemblées",
- reentrant='f',
- UIinfo={"groupes":("Résultats et champs",)},
- regles=(UN_PARMI('COMB_R','COMB_C','CALC_AMOR_GENE' ),),
- COMB_R =FACT(statut='f',max='**',
- PARTIE =SIMP(statut='f',typ='TXM',into=("REEL","IMAG") ),
- MATR_ASSE =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_depl_c,matr_asse_temp_r,matr_asse_temp_c
- ,matr_asse_pres_r,matr_asse_pres_c,matr_asse_gene_r,matr_asse_gene_c ) ),
- COEF_R =SIMP(statut='o',typ='R' ),
- ),
- COMB_C =FACT(statut='f',max='**',
- regles=(UN_PARMI('COEF_R','COEF_C' ),),
- MATR_ASSE =SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_depl_c,matr_asse_temp_r,matr_asse_temp_c
- ,matr_asse_pres_r,matr_asse_pres_c,matr_asse_gene_r,matr_asse_gene_c ) ),
- COEF_R =SIMP(statut='f',typ='R' ),
- COEF_C =SIMP(statut='f',typ='C' ),
- ),
- CALC_AMOR_GENE =FACT(statut='f',
- regles=(UN_PARMI('AMOR_REDUIT','LIST_AMOR' ),),
- MASS_GENE = SIMP(statut='f', typ=matr_asse_gene_r),
- RIGI_GENE = SIMP(statut='f', typ=matr_asse_gene_r),
- AMOR_REDUIT = SIMP(statut='f',typ='R',max='**'),
- LIST_AMOR = SIMP(statut='f',typ=listr8_sdaster ),
- ),
- SANS_CMP =SIMP(statut='f',typ='TXM',into=("LAGR",) ),
-) ;
-#& MODIF COMMANDE DATE 03/01/2006 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 03/01/2006 AUTEUR REZETTE C.REZETTE
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
) ;
-#& MODIF COMMANDE DATE 16/05/2006 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 12/09/2006 AUTEUR REZETTE C.REZETTE
# RESPONSABLE VABHHTS J.PELLET
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# ------------------------------------------------------------------
OPTION =SIMP(statut='f',typ='TXM'),
- OPERATION =SIMP(statut='o',typ='TXM',into=("AFFE","ASSE","EVAL","EXTR","DISC","NORMALE") ),
+ OPERATION =SIMP(statut='o',typ='TXM',into=("AFFE","ASSE","EVAL","EXTR","DISC","NORMALE","R2C","C2R") ),
# ------------------------------------------------------------------
b_norm =BLOC(condition = "OPERATION == 'NORMALE'",
NOM_CMP_RESU =SIMP(statut='f',typ='TXM',max='**' ),
CUMUL =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",) ),
COEF_R =SIMP(statut='f',typ='R',defaut= 1. ),
+ COEF_C =SIMP(statut='f',typ='C',max=1),
),
),
# ------------------------------------------------------------------
CHAM_F =SIMP(statut='o',typ=cham_gd_sdaster),
CHAM_PARA =SIMP(statut='o',typ=cham_gd_sdaster,max='**'),
),
+# ------------------------------------------------------------------
+ b_r2c =BLOC(condition = "OPERATION == 'R2C'",
+ CHAM_GD =SIMP(statut='o',typ=cham_gd_sdaster),
+ ),
+# ------------------------------------------------------------------
+ b_c2r =BLOC(condition = "OPERATION == 'C2R'",
+ CHAM_GD =SIMP(statut='o',typ=cham_gd_sdaster),
+ PARTIE =SIMP(statut='o',typ='TXM',into=('REEL','IMAG'),),
+ ),
# ------------------------------------------------------------------
b_disc =BLOC(condition = "OPERATION == 'DISC'",
MODELE =SIMP(statut='f',typ=(modele_sdaster) ),
), # fin bloc b_extr
- ),
+
+ ),
# FIN DU CATALOGUE : INFO,TITRE ET TYPAGE DU RESULTAT :
#-----------------------------------------------------
INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2,) ),
#
INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
) ;
-#& MODIF COMMANDE DATE 24/01/2006 AUTEUR D6BHHJP J.P.LEFEBVRE
+#& MODIF COMMANDE DATE 12/09/2006 AUTEUR REZETTE C.REZETTE
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
if TYPE_RESU == "EVOL_THER" : return evol_ther
if TYPE_RESU == "MULT_ELAS" : return mult_elas
if TYPE_RESU == "FOURIER_ELAS" : return fourier_elas
+ if TYPE_RESU == "FOURIER_THER" : return fourier_ther
if TYPE_RESU == "EVOL_VARC" : return evol_varc
if TYPE_RESU == "EVOL_CHAR" : return evol_char
raise AsException("type de concept resultat non prevu")
b_affe =BLOC(condition = "OPERATION == 'AFFE'",
TYPE_RESU =SIMP(statut='o',position='global',typ='TXM',into=("MULT_ELAS","EVOL_ELAS","EVOL_NOLI","FOURIER_ELAS",
- "EVOL_THER","EVOL_VARC","EVOL_CHAR",) ),
+ "EVOL_THER","EVOL_VARC","EVOL_CHAR","FOURIER_THER") ),
NOM_CHAM =SIMP(statut='o',typ='TXM',into=C_NOM_CHAM_INTO()),
AFFE =FACT(statut='o',max='**',
PRECISION =SIMP(statut='f',typ='R',defaut= 1.0E-3 ),
CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
),
- b_fourier =BLOC(condition = "TYPE_RESU == 'FOURIER_ELAS' ",
+ b_fourier =BLOC(condition = "((TYPE_RESU == 'FOURIER_ELAS') or (TYPE_RESU == 'FOURIER_THER')) ",
NUME_MODE =SIMP(statut='f',typ='I'),
TYPE_MODE =SIMP(statut='f',typ='TXM',defaut="SYME",into=("SYME","ANTI","TOUS") ),
),
),
) ;
-#& MODIF COMMANDE DATE 10/05/2006 AUTEUR MCOURTOI M.COURTOIS
+#& MODIF COMMANDE DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2003 EDF R&D WWW.CODE-ASTER.ORG
# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
-CREA_TABLE=OPER(nom="CREA_TABLE",op= 36,sd_prod=table_sdaster,
+
+def crea_table_prod(TYPE_TABLE, **args):
+ """Typage du concept résultat
+ """
+ if TYPE_TABLE == 'TABLE_FONCTION':
+ return table_fonction
+ else:
+ return table_sdaster
+
+CREA_TABLE=OPER(nom="CREA_TABLE",op=36,sd_prod=crea_table_prod,
fr="Création d'une table à partir d'une fonction ou de deux listes",
reentrant='f',UIinfo={"groupes":("Table",)},
fr="Liste des paramètres de sensibilité.",
ang="List of sensitivity parameters"),
),
+ TYPE_TABLE = SIMP(statut='f', typ='TXM', defaut="TABLE",
+ into=('TABLE', 'TABLE_FONCTION'),),
+
TITRE=SIMP(statut='f',typ='TXM',max='**'),
) ;
-#& MODIF COMMANDE DATE 16/01/2006 AUTEUR D6BHHJP J.P.LEFEBVRE
+#& MODIF COMMANDE DATE 19/06/2006 AUTEUR VABHHTS J.PELLET
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 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.
+# 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.
+# 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.
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
DEBUT=MACRO(nom="DEBUT",op=ops.build_debut ,repetable='n',
UIinfo={"groupes":("Gestion du travail",)},
IMPR_MACRO =SIMP(fr="affichage des sous-commandes produites par les macros dans le fichier mess",
statut='f',typ='TXM',into=("OUI","NON"),defaut="NON"),
# FORMAT_HDF =SIMP(fr="sauvegarde de la base GLOBALE au format HDF",statut='f',
-# typ='TXM',defaut="NON",into=("OUI","NON",) ),
+# typ='TXM',defaut="NON",into=("OUI","NON",) ),
BASE =FACT(fr="définition des paramètres associés aux bases JEVEUX",
statut='f',min=1,max=2,
FICHIER =SIMP(fr="nom de la base",statut='o',typ='TXM',
statut='f',min=1,max=1,
JXVERI =SIMP(fr="vérifie l intégrité de la segmentation mémoire",
statut='f',typ='TXM',into=('OUI','NON'),defaut='NON'),
+ SDVERI =SIMP(fr="vérifie la conformité des SD produites par les commandes",
+ statut='f',typ='TXM',into=('OUI','NON'),defaut='NON'),
JEVEUX =SIMP(fr="force les déchargement sur disque",
statut='f',typ='TXM',into=('OUI','NON'),defaut='NON'),
ENVIMA =SIMP(fr="imprime les valeurs définies dans ENVIMA",
PRESENT =SIMP(statut='o',typ='TXM',min=2,max=2,into=("OUI","NON") ),
),
) ;
-#& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 05/09/2006 AUTEUR JOUMANA J.EL-GHARIB
# RESPONSABLE JMBHH01 J.M.PROIX
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
fr="Donner le nom du mot-clé facteur de DEFI_MATERIAU précisant le comportement élastique (un et un seul)"),
FAMI_SYST_GLIS =SIMP(statut='o',typ='TXM', max=1,
into=('BASAL', 'PRISMATIQUE', 'OCTAEDRIQUE', 'PYRAMIDAL1',
- 'PYRAMIDAL2', 'CUBIQUE1', 'CUBIQUE2', 'MACLAGE', 'JOINT_GRAIN', 'RL', 'UNIAXIAL'),),
+ 'PYRAMIDAL2', 'CUBIQUE1', 'CUBIQUE2', 'MACLAGE', 'JOINT_GRAIN', 'RL', 'UNIAXIAL','BCC24'),),
),
POLYCRISTAL =FACT(statut='f', max='**',
+ regles=(UN_PARMI('ANGL_REP','ANGL_EULER'),),
MONOCRISTAL =SIMP(statut='o', typ=compor_sdaster, max=1),
FRAC_VOL =SIMP(statut='o', typ='R', max=1,fr="fraction volumique de la phase correspondant au monocristal"),
- ANGL_REP =SIMP(statut='o',typ='R',max=3,fr="orientation du monocristal : 3 angles d'Euler en degrés"),
+ ANGL_REP =SIMP(statut='f',typ='R',max=3,fr="orientation du monocristal : 3 angles nautiques en degrés"),
+ ANGL_EULER=SIMP(statut='f',typ='R',max=3,fr="orientation du monocristal : 3 angles d'Euler en degrés"),
),
ALARME =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
INFO =SIMP(statut='f',typ='I',into=( 1 , 2 ) ),
) ;
-#& MODIF COMMANDE DATE 03/01/2006 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 26/06/2006 AUTEUR CIBHHLV L.VIVAN
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
-DEFI_INTE_SPEC=OPER(nom="DEFI_INTE_SPEC",op= 115,sd_prod=table_sdaster,
- reentrant='n',fr="Définit une matrice interspectrale",
- UIinfo={"groupes":("Fonction",)},
+DEFI_INTERF_DYNA=OPER(nom="DEFI_INTERF_DYNA",op= 98,sd_prod=interf_dyna_clas,
+ reentrant='n',
+ UIinfo={"groupes":("Matrices/vecteurs",)},
+ fr="Définir les interfaces d'une structure et leur affecter un type",
+ NUME_DDL =SIMP(statut='o',typ=nume_ddl_sdaster ),
+ INTERFACE =FACT(statut='o',max='**',
+ regles=(ENSEMBLE('NOM','TYPE'),
+# erreur doc U sur la condition qui suit
+ UN_PARMI('NOEUD','GROUP_NO'),),
+ NOM =SIMP(statut='f',typ='TXM' ),
+ TYPE =SIMP(statut='f',typ='TXM',into=("MNEAL","CRAIGB","CB_HARMO","AUCUN") ),
+ NOEUD =SIMP(statut='f',typ=no,max='**'),
+ GROUP_NO =SIMP(statut='f',typ=grno,max='**'),
+# DDL_ACTIF =SIMP(statut='f',typ='TXM',max='**'),
+ MASQUE =SIMP(statut='f',typ='TXM',max='**'),
+ ),
+ FREQ =SIMP(statut='f',typ='R',defaut= 1.),
+ INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
+) ;
+#& MODIF COMMANDE DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+from Macro.defi_inte_spec_ops import defi_inte_spec_ops
+
+DEFI_INTE_SPEC=MACRO(nom="DEFI_INTE_SPEC",op= defi_inte_spec_ops,sd_prod=table_fonction,
+ reentrant='n',
+ fr="Définit une matrice interspectrale",
+ UIinfo={"groupes":("Fonction",)},
DIMENSION =SIMP(statut='f',typ='I',defaut= 1 ),
# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
-DEFI_INTERF_DYNA=OPER(nom="DEFI_INTERF_DYNA",op= 98,sd_prod=interf_dyna_clas,
- reentrant='n',
- UIinfo={"groupes":("Matrices/vecteurs",)},
- fr="Définir les interfaces d'une structure et leur affecter un type",
- NUME_DDL =SIMP(statut='o',typ=nume_ddl_sdaster ),
- INTERFACE =FACT(statut='o',max='**',
- regles=(ENSEMBLE('NOM','TYPE'),
-# erreur doc U sur la condition qui suit
- UN_PARMI('NOEUD','GROUP_NO'),),
- NOM =SIMP(statut='f',typ='TXM' ),
- TYPE =SIMP(statut='f',typ='TXM',into=("MNEAL","CRAIGB","CB_HARMO","AUCUN") ),
- NOEUD =SIMP(statut='f',typ=no,max='**'),
- GROUP_NO =SIMP(statut='f',typ=grno,max='**'),
- DDL_ACTIF =SIMP(statut='f',typ='TXM',max='**'),
- MASQUE =SIMP(statut='f',typ='TXM',max='**'),
- ),
- FREQ =SIMP(statut='f',typ='R',defaut= 1.),
- INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
-) ;
-#& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE
-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2001 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 VABHHTS J.PELLET
DEFI_LIST_ENTI=OPER(nom="DEFI_LIST_ENTI",op=22,sd_prod=listis_sdaster,
fr="Définir une liste d'entier strictement croissante",
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
) ;
-#& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 31/10/2006 AUTEUR A3BHHAE H.ANDRIAMBOLOLONA
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
fr="Définition d'un nouveau maillage à partir de macro-éléments",
reentrant='n',
UIinfo={"groupes":("Maillage",)},
- DEFI_MAILLE =FACT(statut='o',max='**',
+ DEFI_SUPER_MAILLE =FACT(statut='o',max='**',
MACR_ELEM_STAT =SIMP(statut='o',typ=macr_elem_stat,max='**' ),
- MAILLE =SIMP(statut='f',typ=ma,max='**'),
+ SUPER_MAILLE =SIMP(statut='f',typ=ma,max='**'),
TRAN =SIMP(statut='f',typ='R',max=3),
ANGL_NAUT =SIMP(statut='f',typ='R',max=3),
b_angl_naut =BLOC(condition = "ANGL_NAUT != None",
),
),
RECO_GLOBAL =FACT(statut='f',max='**',
- regles=(UN_PARMI('TOUT','MAILLE'),),
+ regles=(UN_PARMI('TOUT','SUPER_MAILLE'),),
TOUT =SIMP(statut='f',typ='TXM',into=("OUI",) ),
- MAILLE =SIMP(statut='f',typ=ma,max='**'),
+ SUPER_MAILLE =SIMP(statut='f',typ=ma,max='**'),
CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-3 ),
),
- RECO_MAILLE =FACT(statut='f',max='**',
- MAILLE =SIMP(statut='o',typ=ma,max='**'),
+ RECO_SUPER_MAILLE =FACT(statut='f',max='**',
+ SUPER_MAILLE =SIMP(statut='o',typ=ma,max='**'),
GROUP_NO =SIMP(statut='o',typ=grno,max='**'),
OPTION =SIMP(statut='f',typ='TXM',defaut="GEOMETRIQUE",into=("GEOMETRIQUE","NOEUD_A_NOEUD","INVERSE") ),
geometrique =BLOC(condition = "OPTION == 'GEOMETRIQUE'",
INDEX =SIMP(statut='o',typ='I',max='**'),
),
b_noeud_init =BLOC(condition = "NOEUD_INIT != None",
- MAILLE =SIMP(statut='o',typ=ma),
+ SUPER_MAILLE =SIMP(statut='o',typ=ma),
NOEUD_FIN =SIMP(statut='o',typ=no),
),
),
DEFI_GROUP_NO =FACT(statut='f',max='**',
- regles=(UN_PARMI('TOUT','MAILLE'),
+ regles=(UN_PARMI('TOUT','SUPER_MAILLE'),
AU_MOINS_UN('INDEX','GROUP_NO_FIN'),
ENSEMBLE('GROUP_NO_INIT','GROUP_NO_FIN'),),
# la regle ancien catalogue AU_MOINS_UN__: ( INDEX , GROUP_NO_FIN ) incoherente avec doc U
TOUT =SIMP(statut='f',typ='TXM',into=("OUI",),
fr="Création de plusieurs groupes de noeuds" ),
- MAILLE =SIMP(statut='f',typ=ma,
+ SUPER_MAILLE =SIMP(statut='f',typ=ma,
fr="Création de plusieurs groupes de noeuds"),
GROUP_NO_INIT =SIMP(statut='f',typ=grno,
fr="Création d un seul groupe de noeuds"),
GROUP_NO_FIN =SIMP(statut='f',typ=grno),
),
) ;
-#& MODIF COMMANDE DATE 29/05/2006 AUTEUR MJBHHPE J.L.FLEJOU
+#& MODIF COMMANDE DATE 07/11/2006 AUTEUR MARKOVIC D.MARKOVIC
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
'ELAS_ORTH_FO','ELAS_COQUE','ELAS_COQUE_FO',
'ELAS_HYPER',),
EXCLUS('THER','THER_FO','THER_ORTH','THER_NL'),
- EXCLUS('ECRO_LINE','ECRO_LINE_FO'),
+ EXCLUS('ECRO_LINE','ECRO_LINE_FO','ECRO_PUIS'),
EXCLUS('TAHERI','TAHERI_FO'),
EXCLUS('ROUSSELIER','ROUSSELIER_FO'),
PRESENT_PRESENT('ROUSSELIER','TRACTION'),
EXCLUS('CIN1_CHAB','CIN1_CHAB_FO'),
EXCLUS('CIN2_CHAB','CIN2_CHAB_FO'),
EXCLUS('VISCOCHAB','VISCOCHAB_FO'),
- EXCLUS('POLY_CFC','POLY_CFC_FO'),
EXCLUS('LEMAITRE','LEMAITRE_FO','ZIRC_CYRA2','ZIRC_EPRI','VISC_IRRA_LOG',
'LEMA_SEUIL','LEMA_SEUIL_FO','LEMAITRE_IRRA','LMARC_IRRA',),
EXCLUS('LMARC','LMARC_FO'),
PRESENT_PRESENT('HOEK_BROWN','ELAS'),
EXCLUS('MAZARS','MAZARS_FO'),
PRESENT_PRESENT('BAZANT_FD','ELAS_FO'),
- EXCLUS('GLRC','GLRC_FO'),
PRESENT_PRESENT('JOINT_BA','ELAS'),
PRESENT_PRESENT('CABLE','ELAS'),
+ EXCLUS('GLRC_DAMAGE','GLRC_DM'),
),
#
# comportement élastique
SY =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP",) ),
),
+ ECRO_PUIS =FACT(statut='f',
+ SY =SIMP(statut='o',typ='R',),
+ A_PUIS =SIMP(statut='o',typ='R',val_min=0.0),
+ N_PUIS =SIMP(statut='o',typ='R',val_min=1.E-6),
+ ),
+ ECRO_PUIS_FO =FACT(statut='f',
+ SY =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+ A_PUIS =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+ N_PUIS =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
+ VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP",) ),
+ ),
BETON_ECRO_LINE =FACT(statut='f',
D_SIGM_EPSI =SIMP(statut='o',typ='R'),
SYT =SIMP(statut='o',typ='R'),
A_I =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP",) ),
),
- POLY_CFC =FACT(statut='f',
- TEXTURE =SIMP(statut='o',typ=(table_sdaster) ),
- DL =SIMP(statut='f',typ='R'),
- DA =SIMP(statut='f',typ='R'),
- N =SIMP(statut='o',typ='R'),
- K =SIMP(statut='o',typ='R'),
- TAU_0 =SIMP(statut='o',typ='R'),
- Q1 =SIMP(statut='o',typ='R'),
- B1 =SIMP(statut='o',typ='R'),
- HL =SIMP(statut='o',typ='R'),
- Q2 =SIMP(statut='o',typ='R'),
- B2 =SIMP(statut='o',typ='R'),
- C1 =SIMP(statut='o',typ='R'),
- D1 =SIMP(statut='o',typ='R'),
- C2 =SIMP(statut='o',typ='R'),
- ),
- POLY_CFC_FO =FACT(statut='f',
- TEXTURE =SIMP(statut='o',typ=(table_sdaster) ),
- DL =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- DA =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- N =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- K =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- TAU_0 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- Q1 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- B1 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- HL =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- Q2 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- B2 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- C1 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- D1 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- C2 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP",) ),
- ),
LEMAITRE =FACT(statut='f',
N =SIMP(statut='o',typ='R'),
UN_SUR_K =SIMP(statut='o',typ='R'),
ETA_ID =SIMP(statut='o',typ='R'),
ETA_FD =SIMP(statut='f',typ='R'),
),
- GLRC =FACT(statut='f',min=0,max=1,
- MEX1 =SIMP(statut='o',typ='R',val_min=0.E+0),
- MEY1 =SIMP(statut='o',typ='R',val_min=0.E+0),
- MEX2 =SIMP(statut='o',typ='R',val_max=0.E+0),
- MEY2 =SIMP(statut='o',typ='R',val_max=0.E+0),
+ GLRC_DAMAGE =FACT(statut='f',min=0,max=1,
+ FMEX1 =SIMP(statut='o',typ=(fonction_sdaster)),
+ FMEY1 =SIMP(statut='o',typ=(fonction_sdaster)),
+ FMEX2 =SIMP(statut='o',typ=(fonction_sdaster)),
+ FMEY2 =SIMP(statut='o',typ=(fonction_sdaster)),
+ DFMEX1 =SIMP(statut='o',typ=(fonction_sdaster)),
+ DFMEY1 =SIMP(statut='o',typ=(fonction_sdaster)),
+ DFMEX2 =SIMP(statut='o',typ=(fonction_sdaster)),
+ DFMEY2 =SIMP(statut='o',typ=(fonction_sdaster)),
+ DDFMEX1 =SIMP(statut='o',typ=(fonction_sdaster)),
+ DDFMEY1 =SIMP(statut='o',typ=(fonction_sdaster)),
+ DDFMEX2 =SIMP(statut='o',typ=(fonction_sdaster)),
+ DDFMEY2 =SIMP(statut='o',typ=(fonction_sdaster)),
+
CX1 =SIMP(statut='o',typ='R',val_min=0.E+0),
CY1 =SIMP(statut='o',typ='R',val_min=0.E+0),
CXY1 =SIMP(statut='o',typ='R',val_min=0.E+0),
CX2 =SIMP(statut='o',typ='R',val_min=0.E+0),
CY2 =SIMP(statut='o',typ='R',val_min=0.E+0),
CXY2 =SIMP(statut='o',typ='R',val_min=0.E+0),
- ),
- GLRC_FO =FACT(statut='f',min=0,max=1,
- MEX1 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- MEY1 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- MEX2 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- MEY2 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- CX1 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- CY1 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- CXY1 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- CX2 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- CY2 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- CXY2 =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster,formule)),
- VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("NORM",) ),
+ MF1 =SIMP(statut='o',typ='R',val_min=0.E+0),
+ MF2 =SIMP(statut='o',typ='R',val_max=0.E+0),
+ QP1 =SIMP(statut='o',typ='R',val_min=0.E+0),
+ QP2 =SIMP(statut='o',typ='R',val_min=0.E+0),
+ GAMMA =SIMP(statut='o',typ='R',val_min=0.E+0),
+ VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("X ",) ),
+ ),
+ GLRC_DM =FACT(statut='f',min=0,max=1,
+ GAMMA_T =SIMP(statut='o',typ='R',val_min=0.E+0,val_max=1.E+0),
+ GAMMA_F =SIMP(statut='o',typ='R',val_min=0.E+0,val_max=1.E+0),
+ SYT =SIMP(statut='o',typ='R',val_min=0.E+0),
+ SYF =SIMP(statut='o',typ='R',val_min=0.E+0),
+ EF =SIMP(statut='f',typ='R',val_min=0.E+0),
+ NUF =SIMP(statut='f',typ='R',val_min=0.E+0,val_max=0.5+0),
+ ),
+ GLRC_ACIER =FACT(statut='f',min=0,max=1,
+ AX =SIMP(statut='o',typ='R',val_min=0.E+0),
+ AY =SIMP(statut='o',typ='R',val_min=0.E+0),
+ E =SIMP(statut='o',typ='R',val_min=0.E+0),
+ ENROB =SIMP(statut='o',typ='R',val_min=0.E+0),
),
GATT_MONERIE =FACT(statut='f',min=0,max=1,
D_GRAIN =SIMP(statut='o',typ='R',val_min=0.E+0),
VERI_P =SIMP(statut='c',typ='TXM',max='**',defaut=("TEMP",) ),
),
CISA_PLAN_CRIT =FACT(statut='f',
- CRITERE =SIMP(statut='o',typ='TXM',into=("MATAKE",
+ CRITERE =SIMP(statut='o',typ='TXM',into=("MATAKE_MODI_AC",
"DANG_VAN_MODI_AC",
"DANG_VAN_MODI_AV",
- "DOMM_MAXI",
- "FATEMI_SOCIE",
+ "MATAKE_MODI_AV",
+ "FATESOCI_MODI_AV",
) ),
- b_critere_matake =BLOC(condition="CRITERE=='MATAKE'",
- fr="Cisaillement plan critique critère de matake",
+ b_critere_matake =BLOC(condition="CRITERE=='MATAKE_MODI_AC' or CRITERE=='MATAKE_MODI_AV'",
+ fr="Cisaillement plan critique critère de matake pour les cas amplitude constante et amplitude variable",
MATAKE_A =SIMP(statut='o',typ='R'),
MATAKE_B =SIMP(statut='o',typ='R'),
COEF_FLEX_TORS =SIMP(statut='o',typ='R',val_min=1.0E0,val_max=1.7321E0),
COEF_CISA_TRAC =SIMP(statut='o',typ='R',val_min=1.0E0,val_max=1.7321E0),
),
- b_crit_domm_maxi =BLOC(condition="CRITERE=='DOMM_MAXI'",
- fr="Critère pour chargement non périodique : domm_maxi",
- DOMM_A =SIMP(statut='o',typ='R'),
- DOMM_B =SIMP(statut='o',typ='R'),
- COEF_CISA_TRAC =SIMP(statut='o',typ='R',val_min=1.0E0,val_max=1.7321E0),
- ),
-
- b_critere_fate_soci =BLOC(condition="CRITERE=='FATEMI_SOCIE'",
+ b_critere_fate_soci =BLOC(condition="CRITERE=='FATESOCI_MODI_AV'",
fr="Critère de Fatemi et Socie, en élasticité ou élastoplasticité, pour le cas amplitude variable",
FATSOC_A =SIMP(statut='o',typ='R'),
COEF_CISA_TRAC =SIMP(statut='o',typ='R',val_min=1.0E0,val_max=1.7321E0),
DELTAV =SIMP(statut='o',typ='R',fr="Volume d activation"),
DELTAG0 =SIMP(statut='o',typ='R',fr="Gain d energie lie au franchissement d obstacle"),
),
- ECOU_PLAS1 =FACT(statut='f',
- TYPE_PARA =SIMP(statut='f',typ='TXM',into=("ECOU_PLAS",),),
- C =SIMP(statut='o',typ='R'),
- ),
ECRO_ISOT1 =FACT(statut='f',
+ regles=(UN_PARMI('H','H1'),
+ PRESENT_PRESENT('H1','H2','H3','H4'),
+ PRESENT_ABSENT('H','H1','H2','H3','H4','H5','H6'),
+ ),
TYPE_PARA =SIMP(statut='f',typ='TXM',into=("ECRO_ISOT",),),
R_0 =SIMP(statut='o',typ='R'),
Q =SIMP(statut='o',typ='R'),
B =SIMP(statut='o',typ='R'),
- H =SIMP(statut='o',typ='R'),
+ H =SIMP(statut='f',typ='R'),
+ H1 =SIMP(statut='f',typ='R'),
+ H2 =SIMP(statut='f',typ='R'),
+ H3 =SIMP(statut='f',typ='R'),
+ H4 =SIMP(statut='f',typ='R'),
+ H5 =SIMP(statut='f',typ='R'),
+ H6 =SIMP(statut='f',typ='R'),
),
ECRO_ISOT2 =FACT(statut='f',
+ regles=(UN_PARMI('H','H1'),
+ PRESENT_PRESENT('H1','H2','H3','H4'),
+ PRESENT_ABSENT('H','H1','H2','H3','H4','H5','H6'),
+ ),
TYPE_PARA =SIMP(statut='f',typ='TXM',into=("ECRO_ISOT",),),
R_0 =SIMP(statut='o',typ='R'),
Q1 =SIMP(statut='o',typ='R'),
B1 =SIMP(statut='o',typ='R'),
- H =SIMP(statut='o',typ='R'),
+ H =SIMP(statut='f',typ='R'),
+ H1 =SIMP(statut='f',typ='R'),
+ H2 =SIMP(statut='f',typ='R'),
+ H3 =SIMP(statut='f',typ='R'),
+ H4 =SIMP(statut='f',typ='R'),
+ H5 =SIMP(statut='f',typ='R'),
+ H6 =SIMP(statut='f',typ='R'),
Q2 =SIMP(statut='o',typ='R'),
B2 =SIMP(statut='o',typ='R'),
),
VERIF =SIMP(statut='f',typ='TXM',into=("CROISSANT",) ),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
) ;
-#& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
-DEFI_OBSTACLE=OPER(nom="DEFI_OBSTACLE",op= 73,sd_prod=obstacle_sdaster
- ,fr="Définition d'un obstacle plan perpendiculaire à une structure filaire",
- reentrant='n',
- UIinfo={"groupes":("Modélisation",)},
+DEFI_OBSTACLE=OPER(nom="DEFI_OBSTACLE",op= 73,sd_prod=table_fonction,
+ fr="Définition d'un obstacle plan perpendiculaire à une structure filaire",
+ reentrant='n',
+ UIinfo={"groupes":("Modélisation",)},
TYPE =SIMP(statut='o',typ='TXM',defaut="CERCLE",
into=("CERCLE","PLAN_Y","PLAN_Z","DISCRET",
"BI_CERCLE","BI_PLAN_Y","BI_PLAN_Z","BI_CERC_INT",
INFO =SIMP(statut='f',typ='I',into=(1, 2), defaut=1),
);
-#& MODIF COMMANDE DATE 03/01/2006 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
SPEC_FONC_FORME =FACT(statut='f',
regles=(UN_PARMI('INTE_SPEC','GRAPPE_1'),
ENSEMBLE('INTE_SPEC','FONCTION'),),
- INTE_SPEC =SIMP(statut='f',typ=table_sdaster),
+ INTE_SPEC =SIMP(statut='f',typ=table_fonction),
FONCTION =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),max='**'),
GRAPPE_1 =SIMP(statut='f',typ='TXM',into=("DEBIT_180","DEBIT_300",) ),
NOEUD =SIMP(statut='o',typ=no),
),
SPEC_EXCI_POINT =FACT(statut='f',
regles=(UN_PARMI('INTE_SPEC','GRAPPE_2'),),
- INTE_SPEC =SIMP(statut='f',typ=table_sdaster),
+ INTE_SPEC =SIMP(statut='f',typ=table_fonction),
GRAPPE_2 =SIMP(statut='f',typ='TXM',
into=("ASC_CEN","ASC_EXC","DES_CEN","DES_EXC",) ),
# Quels sont les statuts des mots cles à l interieur des deux blocs qui suivent
# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
-DEFI_TEXTURE=OPER(nom="DEFI_TEXTURE",op= 181,sd_prod=table_sdaster,reentrant='n',
- fr="Définir pour un materiau CFC, les orientations cristillographiques et leur système de glissement ",
- UIinfo={"groupes":("Modélisation",)},
- SYST_GLISSEMENT =FACT(statut='o',min=3,max=3,
- N =SIMP(statut='o',typ='R',min=12,max=12 ),
- L =SIMP(statut='o',typ='R',max='**' ),
- ),
- PLAN =FACT(statut='o',min=1,max=40,
- ANGL_NAUT =SIMP(statut='o',typ='R',max='**' ),
- PROPORTION =SIMP(statut='o',typ='R' ),
- ),
- TITRE =SIMP(statut='f',typ='TXM',max='**' ),
-) ;
-#& MODIF COMMANDE DATE 03/01/2006 AUTEUR REZETTE C.REZETTE
-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2001 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.
-# ======================================================================
DEFI_TRC=OPER(nom="DEFI_TRC",op=94,sd_prod=table_sdaster,reentrant='n',
UIinfo={"groupes":("Modélisation",)},
fr="Définir d'un diagramme de transformations en refroidissement continu (TRC) de référence d'un acier"
A =SIMP(statut='f',typ='R'),
),
) ;
-#& MODIF COMMANDE DATE 21/02/2006 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 31/10/2006 AUTEUR A3BHHAE H.ANDRIAMBOLOLONA
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
-DEPL_INTERNE=OPER(nom="DEPL_INTERNE",op=89,sd_prod=cham_no_sdaster,reentrant='n',
+def depl_interne_prod(DEPL_GLOBAL,**args ):
+ if AsType(DEPL_GLOBAL) == cham_no_sdaster: return cham_no_sdaster
+ if AsType(DEPL_GLOBAL) == evol_elas : return evol_elas
+ if AsType(DEPL_GLOBAL) == dyna_trans : return dyna_trans
+ if AsType(DEPL_GLOBAL) == dyna_harmo : return dyna_harmo
+ if AsType(DEPL_GLOBAL) == mode_meca : return mode_meca
+ if AsType(DEPL_GLOBAL) == base_modale : return base_modale
+ raise AsException("type de concept resultat non prevu")
+
+DEPL_INTERNE=OPER(nom="DEPL_INTERNE",op=89,sd_prod=depl_interne_prod,reentrant='n',
UIinfo={"groupes":("Matrices/vecteurs",)},
fr="Calculer le champ de déplacement à l'intérieur d'une sous-structure statique",
- DEPL_GLOBAL =SIMP(statut='o',typ=cham_no_sdaster),
- MAILLE =SIMP(statut='o',typ=ma,),
+ DEPL_GLOBAL =SIMP(statut='o',typ=(cham_no_sdaster,mode_meca,base_modale,evol_elas,dyna_trans,dyna_harmo),),
+ SUPER_MAILLE =SIMP(statut='o',typ=ma,),
NOM_CAS =SIMP(statut='f',typ='TXM',defaut=" "),
) ;
#& MODIF COMMANDE DATE 10/05/2006 AUTEUR MCOURTOI M.COURTOIS
ALARME =SIMP(statut='f',typ='TXM',into=('OUI','NON'),defaut='OUI',),
INFO =SIMP(statut='f',typ='I',into=(1,2),defaut=2, ),
);
-#& MODIF COMMANDE DATE 03/01/2006 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
-DYNA_ALEA_MODAL=OPER(nom="DYNA_ALEA_MODAL",op= 131,sd_prod=table_sdaster
- ,fr="Calcul de la réponse spectrale d'une structure linéaire sous une excitation connue par sa DSP",
+DYNA_ALEA_MODAL=OPER(nom="DYNA_ALEA_MODAL",op= 131,sd_prod=table_fonction,
+ fr="Calcul de la réponse spectrale d'une structure linéaire sous une excitation connue par sa DSP",
reentrant='n',
UIinfo={"groupes":("Résolution",)},
BASE_MODALE =FACT(statut='o',
# MODE_STAT devrait etre dans EXCIT car est utile et obligatoire que si NOM_CMP=depl_r, on pourrait
# ainsi rajouter un bloc du genre b_mod_stat= BLOC(condition = "(GRANDEUR == None) or (GRANDEUR == 'DEPL_R')",
EXCIT =FACT(statut='o',
- INTE_SPEC =SIMP(statut='o',typ=table_sdaster),
+ INTE_SPEC =SIMP(statut='o',typ=table_fonction),
NUME_VITE_FLUI =SIMP(statut='f',typ='I' ),
OPTION =SIMP(statut='f',typ='TXM',defaut="TOUT",into=("TOUT","DIAG",) ),
MODAL =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
# Rajouter test icompatibilite vect_asse et sensibilite
# Peut-on aussi rajouter ici le test d incompatibilite charge complexe - derivation
# presents dans le Fortran
-#& MODIF COMMANDE DATE 10/05/2006 AUTEUR MCOURTOI M.COURTOIS
+#& MODIF COMMANDE DATE 12/06/2006 AUTEUR BOITEAU O.BOITEAU
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
RESI_RELA =SIMP(statut='f',typ='R',defaut=1.E-6),
NMAX_ITER =SIMP(statut='f',typ='I',defaut= 0 ),
),
-
- b_mumps =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
- TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut='AUTO',into=('NONSYM','SYMGEN','SYMDEF','AUTO')),
- PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=20,),
- RESI_RELA =SIMP(statut='f',typ='R',defaut=1.E-6),
- ),
+ b_mumps =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
+ TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
+ SCALING =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
+ RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+ PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=80,),
+ RESI_RELA =SIMP(statut='f',typ='R',defaut=1.E-6,),
+ ),
),
INCREMENT =FACT(statut='o',max='**',
TITRE =SIMP(statut='f',typ='TXM',max='**'),
INFO =SIMP(statut='f',typ='I',into=(1,2) ),
) ;
-#& MODIF COMMANDE DATE 16/05/2006 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 10/10/2006 AUTEUR REZETTE C.REZETTE
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
NUME_INST_FIN =SIMP(statut='f',typ='I'),
INST_FIN =SIMP(statut='f',typ='R'),
PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-3 ),
- SUBD_PAS =SIMP(statut='f',typ='I',defaut=1),
- SUBD_PAS_MINI =SIMP(statut='f',typ='R'),
- COEF_SUBD_PAS_1 =SIMP(statut='f',typ='R',defaut= 1.0E+0),
+ # DEBUT DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS
+ SUBD_METHODE =SIMP( statut='f',typ='TXM',
+ into =("AUCUNE","UNIFORME","EXTRAPOLE"),
+ defaut="AUCUNE",
+ fr="Méthode de subdivision des pas de temps en cas de non-convergence"
+ ),
+ b_subd_unif=BLOC(condition = "SUBD_METHODE == 'UNIFORME'",
+ regles=(AU_MOINS_UN('SUBD_NIVEAU','SUBD_PAS_MINI'),),
+ SUBD_COEF_PAS_1=SIMP(statut='f',typ='R',defaut=1.0,val_min=0.0,
+ fr="Coefficient multiplicateur de la 1ère subdivision"),
+ SUBD_PAS =SIMP(statut='f',typ='I',defaut=4,val_min=2,
+ fr="Nombre de subdivision d'un pas de temps"),
+ SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2,
+ fr="Nombre maximum de niveau de subdivision d'un pas de temps"),
+ SUBD_PAS_MINI=SIMP(statut='f',typ='R',val_min=0.0,
+ fr="Pas de temps en dessous duquel on ne subdivise plus"),
+ ),
+ b_subd_extr=BLOC(condition = "SUBD_METHODE == 'EXTRAPOLE'",
+ regles=(AU_MOINS_UN('SUBD_NIVEAU','SUBD_PAS_MINI'),),
+ SUBD_OPTION =SIMP(statut='f',typ='TXM',
+ into =("IGNORE_PREMIERES","GARDE_DERNIERES",),
+ defaut="IGNORE_PREMIERES",
+ fr="Technique d'extrapolation : les 1ere itérations sont ignorées ou les dernières sont gardées"),
+ SUBD_ITER_IGNO =SIMP(statut='c',typ='I',defaut=3,val_min=0,
+ fr="Les n premières itérations sont ignorées pour l'extrapolation"),
+ SUBD_ITER_FIN =SIMP(statut='c',typ='I',defaut=8,val_min=3,
+ fr="Seules les n dernières itérations sont prises pour l'extrapolation"),
+ SUBD_PAS =SIMP(statut='c',typ='I',defaut=4,val_min=2,
+ fr="Nombre de subdivision d'un pas de temps en cas divergence"),
+ SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2,
+ fr="Nombre maximum de niveau de subdivision d'un pas de temps"),
+ SUBD_PAS_MINI=SIMP(statut='f',typ='R',val_min=0.0,
+ fr="Pas de temps en dessous duquel on ne subdivise plus"),
+ SUBD_ITER_PLUS =SIMP(statut='c',typ='I',defaut=50,val_min=20,
+ fr="% itération autorisée en plus"),
+ ),
+ # FIN DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS
OPTI_LIST_INST =SIMP(statut='f',typ='TXM',into=("INCR_MAXI",),),
NOM_CHAM =SIMP(statut='f',typ='TXM',),
NOM_CMP =SIMP(statut='f',typ='TXM',),
REAC_ITER_ELAS =SIMP(statut='f',typ='I',defaut=0),
PAS_MINI_ELAS =SIMP(statut='f',typ='R',defaut=0.0E+0),
),
- PARM_THETA =SIMP(statut='f',typ='R',defaut= 1. ),
SOLVEUR =FACT(statut='d',
METHODE =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC","MUMPS") ),
b_mult_front =BLOC(condition= "METHODE == 'MULT_FRONT' ",fr="Paramètres de la méthode multi frontale",
NPREC =SIMP(statut='f',typ='I',defaut= 8 ),
STOP_SINGULIER =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON","DECOUPE") ),
),
- b_mumps =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
- TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut='AUTO',into=('NONSYM','SYMGEN','SYMDEF','AUTO')),
- PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=20,),
- RESI_RELA =SIMP(statut='f',typ='R',defaut=1.E-6,),
- ),
+ b_mumps =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
+ TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
+ SCALING =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
+ RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+ PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=80,),
+ RESI_RELA =SIMP(statut='f',typ='R',defaut=-1.0,),
+ ),
b_gcpc =BLOC(condition="METHODE == 'GCPC'",fr="Paramètres de la méthode du gradient conjugué",
PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC",),defaut="LDLT_INC" ),
NIVE_REMPLISSAGE=SIMP(statut='f',typ='I',defaut=0),
PAS_MINI_CRIT =SIMP(statut='f',typ='R',defaut=0.0E+0),
RHO_MIN =SIMP(statut='f',typ='R',defaut=1.0E-2),
RHO_MAX =SIMP(statut='f',typ='R',defaut=1.0E+1),
- RHO_EXCL =SIMP(statut='f',typ='R',defaut=0.9E-2),
+ RHO_EXCL =SIMP(statut='f',typ='R',defaut=0.9E-2,val_min=0.),
),
PILOTAGE =FACT(statut='f',
regles=(EXCLUS('NOEUD','GROUP_NO'),PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),),
),
#-------------------------------------------------------------------
SUIVI_DDL = FACT(statut='f',max=4,
- regles=(UN_PARMI('NOEUD','MAILLE'),
+ regles=(UN_PARMI('NOEUD','MAILLE','GROUP_NO','GROUP_MA','VALE_MIN','VALE_MAX'),
PRESENT_PRESENT('MAILLE','POINT'),),
NUME_SUIVI =SIMP(statut='o',typ='I' ,min=1,max=4),
NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=1,
into=("DEPL","VITE","ACCE","SIEF_ELGA",
"VARI_ELGA","FORC_NODA","DEPL_ABSOLU","VITE_ABSOLU","ACCE_ABSOLU",)),
NOM_CMP =SIMP(statut='o',typ='TXM',max=1 ),
- NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max=1),
- MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max=1),
- POINT =SIMP(statut='f',typ='I' ,validators=NoRepeat(),max=1),
+ NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
+ GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+ MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
+ GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+ POINT =SIMP(statut='f',typ='I' ,validators=NoRepeat(),max='**'),
+ VALE_MAX =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=1,into=("OUI",) ),
+ VALE_MIN =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=1,into=("OUI",) ),
),
AFFICHAGE = FACT(statut='f',max=16,
NPREC =SIMP(statut='f',typ='I',defaut= 8 ),
STOP_SINGULIER =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
),
- b_mumps =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
- TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut='AUTO',into=('NONSYM','SYMGEN','SYMDEF','AUTO')),
- PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=20,),
- RESI_RELA =SIMP(statut='f',typ='R',defaut=1.E-6,),
+ b_mumps =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
+ TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
+ SCALING =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
+ RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+ PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=80,),
+ RESI_RELA =SIMP(statut='f',typ='R',defaut=-1.0,),
),
b_gcpc =BLOC(condition = "METHODE == 'GCPC' ", fr="Paramètres de la méthode du gradient conjugué",
PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC",),defaut="LDLT_INC" ),
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
) ;
-#& MODIF COMMANDE DATE 03/01/2006 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
-DYNA_SPEC_MODAL=OPER(nom="DYNA_SPEC_MODAL",op= 147,sd_prod=table_sdaster,
+DYNA_SPEC_MODAL=OPER(nom="DYNA_SPEC_MODAL",op= 147,sd_prod=table_fonction,
fr="Calcul de la réponse par recombinaison modale d'une structure linéaire pour une excitation aléatoire",
reentrant='n',
UIinfo={"groupes":("Résolution",)},
BASE_ELAS_FLUI =SIMP(statut='o',typ=melasflu_sdaster ),
EXCIT =FACT(statut='o',
- INTE_SPEC_GENE =SIMP(statut='o',typ=table_sdaster),
+ INTE_SPEC_GENE =SIMP(statut='o',typ=table_fonction),
),
OPTION =SIMP(statut='f',typ='TXM',defaut="TOUT",into=("TOUT","DIAG") ),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
) ;
-#& MODIF COMMANDE DATE 16/05/2006 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 27/11/2006 AUTEUR PELLET J.PELLET
# 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.
+# 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
DYNA_TRAN_EXPLI=OPER(nom="DYNA_TRAN_EXPLI",op= 70,sd_prod=evol_noli,reentrant='f',UIinfo={"groupe":("Résolution",)},
CHAM_MATER =SIMP(statut='o',typ=cham_mater),
MODE_STAT =SIMP(statut='f',typ=(mode_stat_depl,mode_stat_acce,mode_stat_forc,)),
CARA_ELEM =SIMP(statut='f',typ=cara_elem),
- MASS_DIAG =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
+ MASS_DIAG =SIMP(statut='f',typ='TXM',into=("OUI","NON",) ),
EXCIT =FACT(statut='o',max='**',
regles=(PRESENT_ABSENT('FONC_MULT','ACCE'),
PRESENT_PRESENT('ACCE','VITE','DEPL'),
RIGI_GENE =SIMP(statut='f',typ=matr_asse_gene_r),
AMOR_GENE =SIMP(statut='f',typ=matr_asse_gene_r),
),
- EXCIT_GENE =FACT(statut='f',
+ EXCIT_GENE =FACT(statut='f',max='**',
FONC_MULT =SIMP(statut='f',typ=fonction_sdaster,max='**' ),
VECT_GENE =SIMP(statut='f',typ=vect_asse_gene,max='**' ),
),
ELAS =SIMP(statut='c',typ='I',defaut=1,into=(1,)),
ELAS_VMIS_TRAC =SIMP(statut='c',typ='I',defaut=1,into=(1,)),
ELAS_VMIS_LINE =SIMP(statut='c',typ='I',defaut=1,into=(1,)),
- ELAS_HYPER =SIMP(statut='c',typ='I',defaut=1,into=(1,)),
+ ELAS_HYPER =SIMP(statut='c',typ='I',defaut=1,into=(1,)),
ELAS_POUTRE_GR =SIMP(statut='c',typ='I',defaut=3,into=(3,)),
CABLE =SIMP(statut='c',typ='I',defaut=1,into=(1,)),
DEFORMATION =SIMP(statut='f',typ='TXM',defaut="PETIT" ,into=("PETIT","GREEN","GREEN_GR",) ),
NUME_INST_FIN =SIMP(statut='f',typ='I'),
INST_FIN =SIMP(statut='f',typ='R'),
PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-3 ),
- SUBD_PAS =SIMP(statut='f',typ='I',defaut=1),
- SUBD_PAS_MINI =SIMP(statut='f',typ='R'),
- COEF_SUBD_PAS_1 =SIMP(statut='f',typ='R',defaut= 1.0E+0),
+ # DEBUT DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS
+ SUBD_METHODE =SIMP( statut='f',typ='TXM',
+ into =("AUCUNE","UNIFORME","EXTRAPOLE"),
+ defaut="AUCUNE",
+ fr="Méthode de subdivision des pas de temps en cas de non-convergence"
+ ),
+ b_subd_unif=BLOC(condition = "SUBD_METHODE == 'UNIFORME'",
+ regles=(AU_MOINS_UN('SUBD_NIVEAU','SUBD_PAS_MINI'),),
+ SUBD_COEF_PAS_1=SIMP(statut='f',typ='R',defaut=1.0,val_min=0.0,
+ fr="Coefficient multiplicateur de la 1ère subdivision"),
+ SUBD_PAS =SIMP(statut='f',typ='I',defaut=4,val_min=2,
+ fr="Nombre de subdivision d'un pas de temps"),
+ SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2,
+ fr="Nombre maximum de niveau de subdivision d'un pas de temps"),
+ SUBD_PAS_MINI=SIMP(statut='f',typ='R',val_min=0.0,
+ fr="Pas de temps en dessous duquel on ne subdivise plus"),
+ ),
+ b_subd_extr=BLOC(condition = "SUBD_METHODE == 'EXTRAPOLE'",
+ regles=(AU_MOINS_UN('SUBD_NIVEAU','SUBD_PAS_MINI'),),
+ SUBD_OPTION =SIMP(statut='f',typ='TXM',
+ into =("IGNORE_PREMIERES","GARDE_DERNIERES",),
+ defaut="IGNORE_PREMIERES",
+ fr="Technique d'extrapolation : les 1ere itérations sont ignorées ou les dernières sont gardées"),
+ SUBD_ITER_IGNO =SIMP(statut='c',typ='I',defaut=3,val_min=0,
+ fr="Les n premières itérations sont ignorées pour l'extrapolation"),
+ SUBD_ITER_FIN =SIMP(statut='c',typ='I',defaut=8,val_min=3,
+ fr="Seules les n dernières itérations sont prises pour l'extrapolation"),
+ SUBD_PAS =SIMP(statut='c',typ='I',defaut=4,val_min=2,
+ fr="Nombre de subdivision d'un pas de temps en cas divergence"),
+ SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2,
+ fr="Nombre maximum de niveau de subdivision d'un pas de temps"),
+ SUBD_PAS_MINI=SIMP(statut='f',typ='R',val_min=0.0,
+ fr="Pas de temps en dessous duquel on ne subdivise plus"),
+ SUBD_ITER_PLUS =SIMP(statut='c',typ='I',defaut=50,val_min=20,
+ fr="% itération autorisée en plus"),
+ ),
+ # FIN DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS
OPTI_LIST_INST =SIMP(statut='f',typ='TXM',into=("INCR_MAXI",),),
NOM_CHAM =SIMP(statut='f',typ='TXM',),
NOM_CMP =SIMP(statut='f',typ='TXM',),
REAC_ITER_ELAS =SIMP(statut='f',typ='I',defaut=0),
PAS_MINI_ELAS =SIMP(statut='f',typ='R',defaut=0.0E+0),
),
- PARM_THETA =SIMP(statut='f',typ='R',defaut= 1. ),
SOLVEUR =FACT(statut='d',
METHODE =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC") ),
b_mult_front =BLOC(condition= "METHODE == 'MULT_FRONT' ",fr="Paramètres de la méthode multi frontale",
EPSI_REFE =SIMP(statut='f',typ='R'),
FLUX_THER_REFE =SIMP(statut='f',typ='R'),
FLUX_HYD1_REFE =SIMP(statut='f',typ='R'),
- FLUX_HYD2_REFE =SIMP(statut='f',typ='R'),
+ FLUX_HYD2_REFE =SIMP(statut='f',typ='R'),
RESI_REFE_RELA =SIMP(statut='f',typ='R'),
RESI_GLOB_MAXI =SIMP(statut='f',typ='R'),
RESI_GLOB_RELA =SIMP(statut='f',typ='R'),
LONG_R = SIMP(statut='f',typ='I',defaut=12,val_min=1,val_max=12),
PREC_R = SIMP(statut='f',typ='I',defaut=5, val_min=1,val_max=8),
LONG_I = SIMP(statut='f',typ='I',defaut=6, val_min=1,val_max=12),
-
+
NOM_COLONNE = SIMP(statut='o',typ='TXM',defaut="STANDARD",
into=("STANDARD","MINIMUM",
"ITER_NEWT",
NOM_COLONNE == 'RESI_REFE' or\
NOM_COLONNE == 'CTCD_GEOM' or\
NOM_COLONNE == 'STANDARD' ",
- INFO_RESIDU = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
+ INFO_RESIDU = SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
),
),
#-------------------------------------------------------------------
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
) ;
-#& MODIF COMMANDE DATE 21/02/2006 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
regles=(UN_PARMI('FONC_MULT','COEF_MULT','ACCE'),
PRESENT_PRESENT('ACCE','VITE','DEPL'),
PRESENT_PRESENT('D_FONC_DT','D_FONC_DT2'),
- PRESENT_ABSENT('NUME_MODE','VECT_GENE','COEF_MULT'),
+ PRESENT_ABSENT('NUME_ORDRE','VECT_GENE','COEF_MULT'),
EXCLUS('MULT_APPUI','CORR_STAT'),
PRESENT_ABSENT('MULT_APPUI','COEF_MULT'),
PRESENT_ABSENT('MULT_APPUI','FONC_MULT'),),
VECT_GENE =SIMP(statut='f',typ=vect_asse_gene ),
- NUME_MODE =SIMP(statut='f',typ='I' ),
+ NUME_ORDRE =SIMP(statut='f',typ='I' ),
FONC_MULT =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
COEF_MULT =SIMP(statut='f',typ='R' ),
ACCE =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
PRESENT_ABSENT('GROUP_MA','NOEUD_2','GROUP_NO_2'),
PRESENT_ABSENT('MAILLE','NOEUD_2','GROUP_NO_2'),),
INTITULE =SIMP(statut='f',typ='TXM' ),
- GROUP_MA =SIMP(statut='f',typ=grma),
- MAILLE =SIMP(statut='f',typ=ma),
+ GROUP_MA =SIMP(statut='f',typ=grma,max='**'),
+ MAILLE =SIMP(statut='f',typ=ma,max='**'),
NOEUD_1 =SIMP(statut='f',typ=no),
NOEUD_2 =SIMP(statut='f',typ=no),
GROUP_NO_1 =SIMP(statut='f',typ=grno),
GROUP_NO_2 =SIMP(statut='f',typ=grno),
- OBSTACLE =SIMP(statut='o',typ=obstacle_sdaster ),
+ OBSTACLE =SIMP(statut='o',typ=table_fonction),
ORIG_OBST =SIMP(statut='f',typ='R',min=3,max=3),
NORM_OBST =SIMP(statut='o',typ='R',min=3,max=3),
ANGL_VRIL =SIMP(statut='f',typ='R' ),
NOEUD_2 =SIMP(statut='f',typ=no),
GROUP_NO_1 =SIMP(statut='f',typ=grno),
GROUP_NO_2 =SIMP(statut='f',typ=grno),
- OBSTACLE =SIMP(statut='o',typ=obstacle_sdaster ),
+ OBSTACLE =SIMP(statut='o',typ=table_fonction),
ORIG_OBST =SIMP(statut='f',typ='R',max='**'),
NORM_OBST =SIMP(statut='o',typ='R',max='**'),
ANGL_VRIL =SIMP(statut='f',typ='R' ),
FORMAT_R =SIMP(statut='f',typ='TXM',defaut="1PE12.5"),
PREC_R =SIMP(statut='f',typ='TXM',defaut="1.E-5"),
) ;
-#& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 29/08/2006 AUTEUR MCOURTOI M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
-EXEC_LOGICIEL=PROC(nom="EXEC_LOGICIEL",op= 183,
- fr="Exécute un logiciel ou une commande système depuis Aster",
- UIinfo={"groupes":("Impression",)},
- LOGICIEL =SIMP(statut='f',typ='TXM' ),
- ARGUMENT =FACT(statut='f',max='**',
- NOM_PARA =SIMP(statut='f',typ='TXM' ),
- ),
-) ;
+
+from Macro.exec_logiciel_ops import exec_logiciel_ops
+def exec_logiciel_prod(self, MAILLAGE, **args):
+ if MAILLAGE != None:
+ mcf = MAILLAGE[0]
+ self.type_sdprod(mcf['MAILLAGE'], maillage_sdaster)
+ return None
+
+EXEC_LOGICIEL = MACRO(nom="EXEC_LOGICIEL",op=exec_logiciel_ops, sd_prod=exec_logiciel_prod,
+ fr="Exécute un logiciel ou une commande système depuis Aster",
+ UIinfo={"groupes":("Outils métier",)},
+
+ regles = (AU_MOINS_UN('LOGICIEL', 'MAILLAGE'),),
+
+ LOGICIEL = SIMP(statut='f', typ='TXM'),
+ ARGUMENT = SIMP(statut='f', max='**', typ='TXM'),
+
+ MAILLAGE = FACT(statut='f',
+ FORMAT = SIMP(statut='o', typ='TXM', into=("GMSH", "GIBI", "SALOME")),
+ UNITE_GEOM = SIMP(statut='f', typ='I', val_min=10, val_max=90, defaut=16,
+ fr="Unité logique définissant le fichier (fort.N) contenant les données géométriques (datg)"),
+ UNITE = SIMP(statut='f', typ='I', val_min=10, val_max=90, defaut=19,
+ fr="Unité logique définissant le fichier (fort.N) produit par le mailleur"),
+ MAILLAGE = SIMP(statut='o', typ=CO),
+ ),
+
+ CODE_RETOUR_MAXI = SIMP(statut='f', typ='I', defaut=0, val_min=-1,
+ fr="Valeur maximale du code retour toléré (-1 pour l'ignorer)"),
+
+ INFO = SIMP(statut='f', typ='I', defaut=2, into=(1,2),),
+)
#& MODIF COMMANDE DATE 14/10/2005 AUTEUR CIBHHLV L.VIVAN
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
CRIT_EXTR =SIMP(statut='f',typ='TXM',defaut="MASS_EFFE_UN",into=("MASS_EFFE_UN","MASS_GENE") ),
),
) ;
-#& MODIF COMMANDE DATE 10/05/2006 AUTEUR MCOURTOI M.COURTOIS
+#& MODIF COMMANDE DATE 10/10/2006 AUTEUR VABHHTS J.PELLET
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
if AsType(RESULTAT) == acou_harmo : return acou_harmo
if AsType(RESULTAT) == mode_meca : return mode_meca
if AsType(RESULTAT) == mode_acou : return mode_acou
- if AsType(RESULTAT) == mode_stat : return mode_stat
- if AsType(mode_stat) == mode_stat_depl : return mode_stat_depl
- if AsType(mode_stat) == mode_stat_acce : return mode_stat_acce
- if AsType(mode_stat) == mode_stat_forc : return mode_stat_forc
+ if AsType(RESULTAT) == mode_stat_depl : return mode_stat_depl
+ if AsType(RESULTAT) == mode_stat_acce : return mode_stat_acce
+ if AsType(RESULTAT) == mode_stat_forc : return mode_stat_forc
if AsType(RESULTAT) == mult_elas : return mult_elas
if AsType(RESULTAT) == fourier_elas : return fourier_elas
raise AsException("type de concept resultat non prevu")
DERIVABLE('RESULTAT'),),
RESULTAT =SIMP(statut='o',typ=(evol_elas,dyna_trans,dyna_harmo,acou_harmo,mode_meca,
mode_acou,mode_stat_depl,mode_stat_acce,mode_stat_forc,evol_ther,evol_noli,
- mult_elas,fourier_elas ) ),
+ mult_elas,fourier_elas,fourier_ther ) ),
SENSIBILITE =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**',
fr="Liste des paramètres de sensibilité.",
VALE =SIMP(statut='f',typ='TXM'),
NOM_PARA =SIMP(statut='o',typ='TXM',max='**'),
);
-#& MODIF COMMANDE DATE 03/01/2006 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
# RESPONSABLE CAMBIER S.CAMBIER
-GENE_FONC_ALEA=OPER(nom="GENE_FONC_ALEA",op= 118,sd_prod=table_sdaster,
+GENE_FONC_ALEA=OPER(nom="GENE_FONC_ALEA",op= 118,sd_prod=table_fonction,
fr="Génération de la fonction temporelle à partir d une matrice interspectrale",
reentrant='n',
UIinfo={"groupes":("Fonction",)},
- INTE_SPEC =SIMP(statut='o',typ=table_sdaster),
+ INTE_SPEC =SIMP(statut='o',typ=table_fonction),
NUME_VITE_FLUI =SIMP(statut='f',typ='I' ),
INTERPOL =SIMP(statut='f',typ='TXM',defaut="OUI",into=("NON","OUI") ),
b_interpol_oui =BLOC(condition = "INTERPOL == 'OUI' ",fr="Parametres cas interpolation autorisee",
INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2 ) ),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
) ;
-#& MODIF COMMANDE DATE 16/06/2004 AUTEUR DURAND C.DURAND
+#& MODIF COMMANDE DATE 07/11/2006 AUTEUR DURAND C.DURAND
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG
# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
-# RESPONSABLE D6BHHAM A.M.DONORE
+# RESPONSABLE thomasso D.THOMASSON
#
-IMPR_OAR =PROC(nom="IMPR_OAR",op= 40,
+from Macro.impr_oar_ops import impr_oar_ops
+IMPR_OAR =MACRO(nom="IMPR_OAR",op= impr_oar_ops, sd_prod=None,
fr="Impression au format OAR",
UIinfo={"groupes":("Impression",)},
- CARA_ELEM =SIMP(statut='f',typ=cara_elem ),
- MAILLAGE =SIMP(statut='o',typ=maillage_sdaster ),
- MODELE =SIMP(statut='o',typ=modele_sdaster ),
- MAILLE =SIMP(statut='o',typ=ma ,validators=NoRepeat(),max=2 ),
- NOEUD =SIMP(statut='o',typ=no ,validators=NoRepeat() ),
-
- CHARGE =FACT(statut='o',max='**',
-
- NUM_CHAR =SIMP(statut='o',typ='I'),
- TEMP_NOEUD =SIMP(statut='f',typ='R',defaut=20.),
- TYPE =SIMP(statut='f',typ='TXM',defaut="DILA",
- into=("POIDS","DILA","SEISME","DEPL","EFFO","STRATIF","CONDITIONNEL","COMBINAISON") ),
- NATURE =SIMP(statut='f',typ='TXM',defaut="PRIMAIRE",
- into=("PRIMAIRE","SECONDAIRE","TOTAL") ),
- SIGNE =SIMP(statut='f',typ='TXM',defaut="S",
- into=("S","NS") ),
- RESULTAT =SIMP(statut='o',typ=resultat_sdaster),# CO() sd a creer !!!
- ),
-
-
- UNITE =SIMP(statut='f',typ='I',defaut=38),
- INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
-) ;
-#& MODIF COMMANDE DATE 10/05/2006 AUTEUR MCOURTOI M.COURTOIS
+ TYPE_CALC = SIMP(statut='o', typ='TXM',into=('COMPOSANT', 'MEF', 'TUYAUTERIE')),
+ b_composant =BLOC(condition = "TYPE_CALC == 'COMPOSANT' ",
+ regles = (AU_MOINS_UN('RESU_MECA','RESU_THER')),
+ DIAMETRE = SIMP(statut='o', typ='R'),
+ ORIGINE = SIMP(statut='o', typ='TXM', defaut='INTERNE', into=('INTERNE', 'EXTERNE')),
+ COEF_U = SIMP(statut='f', typ='R', defaut=1.0),
+ ANGLE_C = SIMP(statut='o', typ='R', defaut=0.0),
+ REVET = SIMP(statut='f', typ='TXM', defaut='NON', into=('OUI', 'NON')),
+ RESU_MECA = FACT(statut='f', max='**',
+ NUM_CHAR = SIMP(statut='o', typ='I'),
+ TYPE = SIMP(statut='o', typ='TXM', defaut='FX', into=('FX', 'FY', 'FZ', 'MX', 'MY', 'MZ', 'PRE')),
+ TABLE = SIMP(statut='o', typ=table_sdaster),
+ TABLE_S = SIMP(statut='f', typ=table_sdaster)),
+ RESU_THER = FACT(statut='f', max='**',
+ NUM_TRAN = SIMP(statut='o', typ='I'),
+ TABLE_T = SIMP(statut='o', typ=table_sdaster),
+ TABLE_TEMP= SIMP(statut='o', typ=table_sdaster),
+ TABLE_S = SIMP(statut='f', typ=table_sdaster),
+ TABLE_ST = SIMP(statut='f', typ=table_sdaster)),
+ ),
+ b_mef = BLOC(condition = "TYPE_CALC == 'MEF' ",
+ regles = (AU_MOINS_UN('RESU_MECA','RESU_THER')),
+ DIAMETRE = SIMP(statut='o', typ='R'),
+ ORIGINE = SIMP(statut='o', typ='TXM', defaut='INTERNE', into=('INTERNE', 'EXTERNE')),
+ COEF_U = SIMP(statut='f', typ='R', defaut=1.0),
+ RESU_MECA = FACT(statut='f', max='**',
+ AZI = SIMP(statut='o', typ='R'),
+ TABLE_T = SIMP(statut='o', typ=table_sdaster),
+ TABLE_F = SIMP(statut='o', typ=table_sdaster),
+ TABLE_P = SIMP(statut='o', typ=table_sdaster),
+ TABLE_CA = SIMP(statut='o', typ=table_sdaster)),
+ RESU_THER=FACT(statut='f', max='**',
+ AZI = SIMP(statut='o', typ='R'),
+ NUM_CHAR = SIMP(statut='o', typ='I'),
+ TABLE_T = SIMP(statut='o', typ=table_sdaster),
+ TABLE_TI = SIMP(statut='o', typ=table_sdaster)),
+ ),
+ b_tuyauterie = BLOC(condition = "TYPE_CALC == 'TUYAUTERIE' ",
+ RESU_MECA = FACT(statut='o', max='**',
+ NUM_CHAR = SIMP(statut='o', typ='I'),
+ TABLE = SIMP(statut='o', typ=table_sdaster),
+ MAILLAGE = SIMP(statut='o', typ=maillage_sdaster)),
+ ),
+ UNITE = SIMP(statut='f',typ='I',defaut=38),
+ AJOUT = SIMP(statut='f', typ='TXM', defaut='NON', into=('OUI', 'NON')),
+ );
+#& MODIF COMMANDE DATE 06/11/2006 AUTEUR MCOURTOI M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
),
b_format_gmsh =BLOC(condition="FORMAT=='GMSH'",fr="unité logique d'impression et version GMSH",
- UNITE =SIMP(statut='f',typ='I',defaut=19),
+ UNITE =SIMP(statut='f',typ='I',defaut=37),
VERSION =SIMP(statut='f',typ='R',defaut=1.2,into=(1.0,1.2)),
),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
) ;
-#& MODIF COMMANDE DATE 24/05/2005 AUTEUR MCOURTOI M.COURTOIS
+#& MODIF COMMANDE DATE 24/10/2006 AUTEUR DURAND C.DURAND
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2005 EDF R&D WWW.CODE-ASTER.ORG
),
),
MAX =FACT(statut='f',fr="Extrémas locaux d'une fonction",
- FONCTION =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster) ),
+ FONCTION =SIMP(statut='o',typ=(fonction_sdaster,nappe_sdaster),max='**' ),
),
NORME =FACT(statut='f',fr="Norme L2 d'une fonction",
FONCTION =SIMP(statut='o', typ=nappe_sdaster),
UNITE_RESU_FORC =SIMP(statut='f',typ='I',defaut=30),
) ;
-#& MODIF COMMANDE DATE 08/11/2005 AUTEUR ACBHHCD G.DEVESA
+#& MODIF COMMANDE DATE 19/09/2006 AUTEUR ACBHHCD G.DEVESA
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2005 EDF R&D WWW.CODE-ASTER.ORG
NUME_DDL_GENE =SIMP(statut='o',typ=nume_ddl_gene ),
FREQ_EXTR =SIMP(statut='o',typ='R',max=1),
UNITE_RESU_IMPE =SIMP(statut='f',typ='I',defaut=30),
+ TYPE =SIMP(statut='f',typ='TXM',defaut="ASCII",into=("BINAIRE","ASCII") ),
) ;
-#& MODIF COMMANDE DATE 03/01/2006 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
from Macro.lire_inte_spec_ops import lire_inte_spec_ops
-LIRE_INTE_SPEC=MACRO(nom="LIRE_INTE_SPEC",op=lire_inte_spec_ops,sd_prod=table_sdaster,
+LIRE_INTE_SPEC=MACRO(nom="LIRE_INTE_SPEC",op=lire_inte_spec_ops,sd_prod=table_fonction,
fr="Lecture sur un fichier externe de fonctions complexes pour créer une matrice interspectrale",
reentrant='n',
UIinfo={"groupes":("Fonction",)},
TITRE =SIMP(statut='f',typ='TXM',max='**'),
INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
) ;
-#& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 21/11/2006 AUTEUR COURTOIS M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
),
#
b_format_med =BLOC( condition = " ( FORMAT == 'MED' ) " ,
- fr="Informations complémentaires pour la lecture MED.",
- ang="Further information for MED readings.",
+ fr="Informations complémentaires pour la lecture MED.",
+ ang="Further information for MED readings.",
#
# Pour une lecture dans un fichier MED, on peut préciser le nom sous lequel
# le maillage y a été enregistré. Par défaut, on va le chercher sous le nom du concept à créer.
-#
- NOM_MED = SIMP(statut='f',typ='TXM',
- fr="Nom du maillage dans le fichier MED.",
- ang="Name of the mesh into the MED file.",),
-#
- INFO_MED = SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
-#
- ) ,
+ NOM_MED = SIMP(statut='f',typ='TXM',
+ fr="Nom du maillage dans le fichier MED.",
+ ang="Name of the mesh into the MED file.",),
+ INFO_MED = SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
+#
+ RENOMME = FACT(statut='f', max='**',
+ fr="Renommer un nom de groupe MED",
+ NOM_MED = SIMP(statut='o', typ=grma,
+ fr="Nom du groupe dans le fichier MED"),
+ NOM = SIMP(statut='o', typ=grma, validators=LongStr(1,8),
+ fr="Nom du groupe dans le maillage ASTER"),
+ ),
+ ),
#
INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
#
TITRE =SIMP(statut='f',typ='TXM',max='**'),
INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
) ;
-#& MODIF COMMANDE DATE 02/06/2006 AUTEUR MCOURTOI M.COURTOIS
+#& MODIF COMMANDE DATE 30/10/2006 AUTEUR DURAND C.DURAND
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
#
# 2. Version de HOMARD
#
- VERSION_HOMARD = SIMP(statut='f',typ='TXM',defaut="V8_2",
- into=("V8_2", "V8_N", "V8_N_PERSO"),
+ VERSION_HOMARD = SIMP(statut='f',typ='TXM',defaut="V8_5",
+ into=("V8_5", "V8_N", "V8_N_PERSO"),
fr="Version de HOMARD",
ang="HOMARD release"),
#
ang="Error indicator field in the result structure" ),
),
#
-# 6.1.3. La composante retenue
+# 6.1.3. Est-ce un champ dérivé
+#
+ b_sensibilite = BLOC(condition=" (RESULTAT_N != None) or (CHAM_GD != None) ",
+ fr="Est-ce un champ dérivé",
+ ang="Is the indicator a derivative field",
+#
+ SENSIBILITE = SIMP(statut='f',typ=(para_sensi,theta_geom),
+ fr="Paramètre de sensibilité.",
+ ang="Sensitivity parameter")
+#
+ ),
+#
+# 6.1.4. La composante retenue
#
b_composante = BLOC(condition=" (RESULTAT_N != None) or (CHAM_GD != None) ",
fr="Choix de la composante pour l'indicateur",
#
),
#
-# 6.1.4. Le paramètre temporel pour l'indicateur
+# 6.1.5. Le paramètre temporel pour l'indicateur
#
b_parametre_temporel = BLOC(condition="(RESULTAT_N != None)",
fr="Choix éventuel du paramètre temporel pour l'indicateur",
#
regles=(EXCLUS('NUME_ORDRE','INST'),),
#
-# 6.1.4.1. Soit le numero d'ordre
+# 6.1.5.1. Soit le numero d'ordre
#
NUME_ORDRE = SIMP(statut='f',typ='I',
fr="Numero d ordre",
ang="Rank" ),
#
-# 6.1.4.2. Soit l'instant
-# 6.1.4.2.1. Sa valeur
+# 6.1.5.2. Soit l'instant
+# 6.1.5.2.1. Sa valeur
#
INST = SIMP(statut='f',typ='R',
fr="Instant associé",
ang="Instant" ),
#
-# 6.1.4.2.2. La précision du choix de l'instant
+# 6.1.5.2.2. La précision du choix de l'instant
#
b_precision = BLOC(condition="(INST != None)",
fr="Choix de la précision du choix de l'instant",
),
#
),
+#
+# 6.1.6. Type de valeur de l'indicateur : absolue ou relative
+#
+ b_valeur_indicateur = BLOC(condition=" (RESULTAT_N != None) or (CHAM_GD != None) ",
+ fr="Type de valeur pour l'indicateur",
+ ang="Value type for error indicator",
+#
+ TYPE_VALEUR_INDICA = SIMP(statut='f',typ='TXM',defaut="V_ABSOLUE",into=("V_ABSOLUE","V_RELATIVE"),
+ fr="Valeur absolue ou relative pour l'indicateur",
+ ang="Absolute or relative value for error indicator" ),
+#
+ ),
#
) ,
#
) ,
#
# 8. Pour de l'adaptation par zone, définitions des zones
-# Remarque : on impose le 3D
#
b_zone = BLOC( condition = " (ADAPTATION == 'RAFFINEMENT_ZONE') " ,
fr="Pour une adaptation selon une zone à raffiner",
#
regles=(AU_MOINS_UN('X_MINI','X_CENTRE'),
EXCLUS('X_MINI','X_CENTRE',),
- PRESENT_PRESENT('X_MINI','X_MAXI','Y_MINI','Y_MAXI','Z_MINI','Z_MAXI'),
- PRESENT_PRESENT('X_CENTRE','Y_CENTRE','Z_CENTRE','RAYON'),),
+ EXCLUS('Z_MINI','X_CENTRE',),
+ EXCLUS('X_MINI','Z_CENTRE',),
+ EXCLUS('Z_MINI','Z_CENTRE',),
+ PRESENT_PRESENT('X_MINI','X_MAXI','Y_MINI','Y_MAXI'),
+ PRESENT_PRESENT('Z_MINI','Z_MAXI'),
+ PRESENT_PRESENT('X_CENTRE','Y_CENTRE','RAYON'),),
#
# 6.2.1. Une boite parallelepipedique
#
#
),
#
-# 11.4. Le paramètre temporel pour le champ a interpoler
+# 11.4. Est-ce un champ dérivé
+#
+ SENSIBILITE = SIMP(statut='f',typ=(para_sensi,theta_geom),
+ fr="Paramètre de sensibilité.",
+ ang="Sensitivity parameter"),
+#
+# 11.5. Le paramètre temporel pour le champ a interpoler
#
b_parametre_temporel = BLOC(condition="(RESULTAT != None)",
fr="Choix éventuel du paramètre temporel pour le champ à interpoler",
#
regles=(EXCLUS('NUME_ORDRE','INST'),),
#
-# 11.4.1. Soit le numero d'ordre
+# 11.5.1. Soit le numero d'ordre
#
NUME_ORDRE = SIMP(statut='f',typ='I',
fr="Numero d ordre du champ à mettre à jour",
ang="Rank of the field to be updated" ),
#
-# 11.4.2. Soit l'instant
-# 11.4.2.1. Sa valeur
+# 11.5.2. Soit l'instant
+# 11.5.2.1. Sa valeur
#
INST = SIMP(statut='f',typ='R',
fr="Instant associé",
ang="Instant" ),
#
-# 11.4.2.2. La précision du choix de l'instant
+# 11.5.2.2. La précision du choix de l'instant
#
b_precision = BLOC(condition="(INST != None)",
fr="Choix de la précision du choix de l'instant",
ang="Incompatible elements for HOMARD" ),
#
) ;
-#& MODIF COMMANDE DATE 07/10/2005 AUTEUR CIBHHPD L.SALMONA
+#& MODIF COMMANDE DATE 25/09/2006 AUTEUR MJBHHPE J.L.FLEJOU
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
NUME_INST_FIN =SIMP(statut='f',typ='I'),
INST_FIN =SIMP(statut='f',typ='R'),
PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-3 ),
- SUBD_PAS =SIMP(statut='f',typ='I',defaut=1),
- SUBD_PAS_MINI =SIMP(statut='f',typ='R'),
- COEF_SUBD_PAS_1 =SIMP(statut='f',typ='R',defaut= 1.0E+0),
+ # DEBUT DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS
+ SUBD_METHODE =SIMP( statut='f',typ='TXM',
+ into =("AUCUNE","UNIFORME","EXTRAPOLE"),
+ defaut="AUCUNE",
+ fr="Méthode de subdivision des pas de temps en cas de non-convergence"
+ ),
+ b_subd_unif=BLOC(condition = "SUBD_METHODE == 'UNIFORME'",
+ regles=(AU_MOINS_UN('SUBD_NIVEAU','SUBD_PAS_MINI'),),
+ SUBD_COEF_PAS_1=SIMP(statut='f',typ='R',defaut=1.0,val_min=0.0,
+ fr="Coefficient multiplicateur de la 1ère subdivision"),
+ SUBD_PAS =SIMP(statut='f',typ='I',defaut=4,val_min=2,
+ fr="Nombre de subdivision d'un pas de temps"),
+ SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2,
+ fr="Nombre maximum de niveau de subdivision d'un pas de temps"),
+ SUBD_PAS_MINI=SIMP(statut='f',typ='R',val_min=0.0,
+ fr="Pas de temps en dessous duquel on ne subdivise plus"),
+ ),
+ b_subd_extr=BLOC(condition = "SUBD_METHODE == 'EXTRAPOLE'",
+ regles=(AU_MOINS_UN('SUBD_NIVEAU','SUBD_PAS_MINI'),),
+ SUBD_OPTION =SIMP(statut='f',typ='TXM',
+ into =("IGNORE_PREMIERES","GARDE_DERNIERES",),
+ defaut="IGNORE_PREMIERES",
+ fr="Technique d'extrapolation : les 1ere itérations sont ignorées ou les dernières sont gardées"),
+ SUBD_ITER_IGNO =SIMP(statut='c',typ='I',defaut=3,val_min=0,
+ fr="Les n premières itérations sont ignorées pour l'extrapolation"),
+ SUBD_ITER_FIN =SIMP(statut='c',typ='I',defaut=8,val_min=3,
+ fr="Seules les n dernières itérations sont prises pour l'extrapolation"),
+ SUBD_PAS =SIMP(statut='c',typ='I',defaut=4,val_min=2,
+ fr="Nombre de subdivision d'un pas de temps en cas divergence"),
+ SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2,
+ fr="Nombre maximum de niveau de subdivision d'un pas de temps"),
+ SUBD_PAS_MINI=SIMP(statut='f',typ='R',val_min=0.0,
+ fr="Pas de temps en dessous duquel on ne subdivise plus"),
+ SUBD_ITER_PLUS =SIMP(statut='c',typ='I',defaut=50,val_min=20,
+ fr="% itération autorisée en plus"),
+ ),
+ # FIN DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS
),
THETA_3D =FACT(statut='f',max='**',
INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
) ;
-#& MODIF COMMANDE DATE 07/10/2005 AUTEUR CIBHHPD L.SALMONA
+#& MODIF COMMANDE DATE 25/09/2006 AUTEUR MJBHHPE J.L.FLEJOU
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
NUME_INST_FIN =SIMP(statut='f',typ='I'),
INST_FIN =SIMP(statut='f',typ='R'),
PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-3 ),
- SUBD_PAS =SIMP(statut='f',typ='I',defaut=1),
- SUBD_PAS_MINI =SIMP(statut='f',typ='R'),
- COEF_SUBD_PAS_1 =SIMP(statut='f',typ='R',defaut= 1.0E+0),
+ # DEBUT DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS
+ SUBD_METHODE =SIMP( statut='f',typ='TXM',
+ into =("AUCUNE","UNIFORME","EXTRAPOLE"),
+ defaut="AUCUNE",
+ fr="Méthode de subdivision des pas de temps en cas de non-convergence"
+ ),
+ b_subd_unif=BLOC(condition = "SUBD_METHODE == 'UNIFORME'",
+ regles=(AU_MOINS_UN('SUBD_NIVEAU','SUBD_PAS_MINI'),),
+ SUBD_COEF_PAS_1=SIMP(statut='f',typ='R',defaut=1.0,val_min=0.0,
+ fr="Coefficient multiplicateur de la 1ère subdivision"),
+ SUBD_PAS =SIMP(statut='f',typ='I',defaut=4,val_min=2,
+ fr="Nombre de subdivision d'un pas de temps"),
+ SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2,
+ fr="Nombre maximum de niveau de subdivision d'un pas de temps"),
+ SUBD_PAS_MINI=SIMP(statut='f',typ='R',val_min=0.0,
+ fr="Pas de temps en dessous duquel on ne subdivise plus"),
+ ),
+ b_subd_extr=BLOC(condition = "SUBD_METHODE == 'EXTRAPOLE'",
+ regles=(AU_MOINS_UN('SUBD_NIVEAU','SUBD_PAS_MINI'),),
+ SUBD_OPTION =SIMP(statut='f',typ='TXM',
+ into =("IGNORE_PREMIERES","GARDE_DERNIERES",),
+ defaut="IGNORE_PREMIERES",
+ fr="Technique d'extrapolation : les 1ere itérations sont ignorées ou les dernières sont gardées"),
+ SUBD_ITER_IGNO =SIMP(statut='c',typ='I',defaut=3,val_min=0,
+ fr="Les n premières itérations sont ignorées pour l'extrapolation"),
+ SUBD_ITER_FIN =SIMP(statut='c',typ='I',defaut=8,val_min=3,
+ fr="Seules les n dernières itérations sont prises pour l'extrapolation"),
+ SUBD_PAS =SIMP(statut='c',typ='I',defaut=4,val_min=2,
+ fr="Nombre de subdivision d'un pas de temps en cas divergence"),
+ SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2,
+ fr="Nombre maximum de niveau de subdivision d'un pas de temps"),
+ SUBD_PAS_MINI=SIMP(statut='f',typ='R',val_min=0.0,
+ fr="Pas de temps en dessous duquel on ne subdivise plus"),
+ SUBD_ITER_PLUS =SIMP(statut='c',typ='I',defaut=50,val_min=20,
+ fr="% itération autorisée en plus"),
+ ),
+ # FIN DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS
),
PAS_AZIMUT =SIMP(statut='f',typ='I',defaut=1),
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
) ;
-#& MODIF COMMANDE DATE 07/10/2005 AUTEUR CIBHHPD L.SALMONA
+#& MODIF COMMANDE DATE 25/09/2006 AUTEUR MJBHHPE J.L.FLEJOU
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2003 EDF R&D WWW.CODE-ASTER.ORG
NUME_INST_FIN =SIMP(statut='f',typ='I'),
INST_FIN =SIMP(statut='f',typ='R'),
PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-3 ),
- SUBD_PAS =SIMP(statut='f',typ='I',defaut=1),
- SUBD_PAS_MINI =SIMP(statut='f',typ='R'),
- COEF_SUBD_PAS_1 =SIMP(statut='f',typ='R',defaut= 1.0E+0),
+ # DEBUT DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS
+ SUBD_METHODE =SIMP( statut='f',typ='TXM',
+ into =("AUCUNE","UNIFORME","EXTRAPOLE"),
+ defaut="AUCUNE",
+ fr="Méthode de subdivision des pas de temps en cas de non-convergence"
+ ),
+ b_subd_unif=BLOC(condition = "SUBD_METHODE == 'UNIFORME'",
+ regles=(AU_MOINS_UN('SUBD_NIVEAU','SUBD_PAS_MINI'),),
+ SUBD_COEF_PAS_1=SIMP(statut='f',typ='R',defaut=1.0,val_min=0.0,
+ fr="Coefficient multiplicateur de la 1ère subdivision"),
+ SUBD_PAS =SIMP(statut='f',typ='I',defaut=4,val_min=2,
+ fr="Nombre de subdivision d'un pas de temps"),
+ SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2,
+ fr="Nombre maximum de niveau de subdivision d'un pas de temps"),
+ SUBD_PAS_MINI=SIMP(statut='f',typ='R',val_min=0.0,
+ fr="Pas de temps en dessous duquel on ne subdivise plus"),
+ ),
+ b_subd_extr=BLOC(condition = "SUBD_METHODE == 'EXTRAPOLE'",
+ regles=(AU_MOINS_UN('SUBD_NIVEAU','SUBD_PAS_MINI'),),
+ SUBD_OPTION =SIMP(statut='f',typ='TXM',
+ into =("IGNORE_PREMIERES","GARDE_DERNIERES",),
+ defaut="IGNORE_PREMIERES",
+ fr="Technique d'extrapolation : les 1ere itérations sont ignorées ou les dernières sont gardées"),
+ SUBD_ITER_IGNO =SIMP(statut='c',typ='I',defaut=3,val_min=0,
+ fr="Les n premières itérations sont ignorées pour l'extrapolation"),
+ SUBD_ITER_FIN =SIMP(statut='c',typ='I',defaut=8,val_min=3,
+ fr="Seules les n dernières itérations sont prises pour l'extrapolation"),
+ SUBD_PAS =SIMP(statut='c',typ='I',defaut=4,val_min=2,
+ fr="Nombre de subdivision d'un pas de temps en cas divergence"),
+ SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2,
+ fr="Nombre maximum de niveau de subdivision d'un pas de temps"),
+ SUBD_PAS_MINI=SIMP(statut='f',typ='R',val_min=0.0,
+ fr="Pas de temps en dessous duquel on ne subdivise plus"),
+ SUBD_ITER_PLUS =SIMP(statut='c',typ='I',defaut=50,val_min=20,
+ fr="% itération autorisée en plus"),
+ ),
+ # FIN DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS
OPTI_LIST_INST =SIMP(statut='f',typ='TXM',into=("INCR_MAXI",),),
NOM_CHAM =SIMP(statut='f',typ='TXM',),
NOM_CMP =SIMP(statut='f',typ='TXM',),
OPTION =SIMP(statut='f',typ='TXM',defaut="CLASSIQUE",into=("CLASSIQUE","RITZ",
"DIAG_MASS") ),
) ;
-#& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 31/10/2006 AUTEUR A3BHHAE H.ANDRIAMBOLOLONA
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
regles=(AU_MOINS_UN('DEFINITION','RIGI_MECA','MASS_MECA','CAS_CHARGE'),
ENSEMBLE('DEFINITION','EXTERIEUR'),),
DEFINITION =FACT(statut='f',
+ regles=(PRESENT_PRESENT('PROJ_MESU','MODE_MESURE'),),
MODELE =SIMP(statut='o',typ=modele_sdaster),
CHAM_MATER =SIMP(statut='f',typ=cham_mater),
CARA_ELEM =SIMP(statut='f',typ=cara_elem),
INST =SIMP(statut='f',typ='R',defaut=0.0E+0 ),
NMAX_CAS =SIMP(statut='f',typ='I',defaut=10),
NMAX_CHAR =SIMP(statut='f',typ='I',defaut=10),
+ PROJ_MESU =SIMP(statut='f',typ=(mode_gene,tran_gene,harm_gene),max=1),
+ MODE_MESURE =SIMP(statut='f',typ=( mode_meca,base_modale) ),
),
EXTERIEUR =FACT(statut='f',
regles=(AU_MOINS_UN('NOEUD','GROUP_NO'),),
CHARGE =SIMP(statut='f',typ=char_meca,validators=NoRepeat(),max='**'),
INST =SIMP(statut='f',typ='R',defaut=0.E+0),
),
-) ;
-#& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE
-# 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
-from Macro.macr_fiab_impr_ops import macr_fiab_impr_ops
-
-MACR_FIAB_IMPR=MACRO(nom="MACR_FIAB_IMPR",op=macr_fiab_impr_ops,
- docu="U7.04.41",UIinfo={"groupe":("Impression",)},
- fr="Imprimer les valeurs à transmettre au logiciel de fiabilité.",
- ang="Print values for the fiability software",
-#
-# 1. Le niveau d'information
-#
- INFO = SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
-#
-# 2. Impression de la valeur de la cible
-#
-# 2.1. ==> La table contenant la valeur à imprimer
-#
- TABLE_CIBLE = SIMP(statut='o',typ=table_sdaster,
- fr="Table contenant la valeur cible.",
- ang="Table which includes the target value."),
-#
-# 2.2. ==> Le nom du paramètre associé à la valeur cible dans cette table
-#
- NOM_PARA_CIBLE = SIMP(statut='o',typ='TXM',
- fr="Nom du paramètre associé à la valeur cible.",
- ang="Name of the parameter connected to the target value."),
-#
-# 3. Impressions des valeurs des éventuels gradients
-#
- GRADIENTS = FACT(statut='f',min=1,max='**',
-#
-# 3.1. ==> La table contenant la valeur à imprimer
-#
- TABLE = SIMP(statut='o',typ=table_sdaster,
- fr="Table contenant le gradient.",
- ang="Table which includes the gradient."),
-#
-# 3.2. ==> Le paramètre sensible
-#
- PARA_SENSI = SIMP(statut='o',typ=(para_sensi,theta_geom),
- fr="Paramètre sensible associé au gradient.",
- ang="Sensitivity parameter connected to the gradient."),
-#
-# 3.3. ==> Le nom du paramètre associé au gradient dans cette table
-#
- NOM_PARA = SIMP(statut='o',typ='TXM',
- fr="Nom du paramètre associé au gradient.",
- ang="Name of the parameter connected to the gradient."),
-#
- ),
-#
-);
-#& MODIF COMMANDE DATE 04/10/2005 AUTEUR REZETTE C.REZETTE
+) ;
+#& MODIF COMMANDE DATE 27/11/2006 AUTEUR GNICOLAS G.NICOLAS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG
fr="Valeur minimale.",
ang="Minimal value."),
#
- VALE_MAX = SIMP(statut="o",typ="R.",max=1,
+ VALE_MAX = SIMP(statut="o",typ="R",max=1,
fr="Valeur maximale.",
ang="Maximal value."),
#
),
#
);
-#& MODIF COMMANDE DATE 22/05/2006 AUTEUR MCOURTOI M.COURTOIS
+#& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE
+# 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
+
+from Macro.macr_fiab_impr_ops import macr_fiab_impr_ops
+
+MACR_FIAB_IMPR=MACRO(nom="MACR_FIAB_IMPR",op=macr_fiab_impr_ops,
+ docu="U7.04.41",UIinfo={"groupe":("Impression",)},
+ fr="Imprimer les valeurs à transmettre au logiciel de fiabilité.",
+ ang="Print values for the fiability software",
+#
+# 1. Le niveau d'information
+#
+ INFO = SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+#
+# 2. Impression de la valeur de la cible
+#
+# 2.1. ==> La table contenant la valeur à imprimer
+#
+ TABLE_CIBLE = SIMP(statut='o',typ=table_sdaster,
+ fr="Table contenant la valeur cible.",
+ ang="Table which includes the target value."),
+#
+# 2.2. ==> Le nom du paramètre associé à la valeur cible dans cette table
+#
+ NOM_PARA_CIBLE = SIMP(statut='o',typ='TXM',
+ fr="Nom du paramètre associé à la valeur cible.",
+ ang="Name of the parameter connected to the target value."),
+#
+# 3. Impressions des valeurs des éventuels gradients
+#
+ GRADIENTS = FACT(statut='f',min=1,max='**',
+#
+# 3.1. ==> La table contenant la valeur à imprimer
+#
+ TABLE = SIMP(statut='o',typ=table_sdaster,
+ fr="Table contenant le gradient.",
+ ang="Table which includes the gradient."),
+#
+# 3.2. ==> Le paramètre sensible
+#
+ PARA_SENSI = SIMP(statut='o',typ=(para_sensi,theta_geom),
+ fr="Paramètre sensible associé au gradient.",
+ ang="Sensitivity parameter connected to the gradient."),
+#
+# 3.3. ==> Le nom du paramètre associé au gradient dans cette table
+#
+ NOM_PARA = SIMP(statut='o',typ='TXM',
+ fr="Nom du paramètre associé au gradient.",
+ ang="Name of the parameter connected to the gradient."),
+#
+ ),
+#
+);
+#& MODIF COMMANDE DATE 30/10/2006 AUTEUR DURAND C.DURAND
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
#
# 2. Version de HOMARD
#
- VERSION_HOMARD = SIMP(statut='f',typ='TXM',defaut="V8_2",
- into=("V8_2", "V8_N", "V8_N_PERSO"),
+ VERSION_HOMARD = SIMP(statut='f',typ='TXM',defaut="V8_5",
+ into=("V8_5", "V8_N", "V8_N_PERSO"),
fr="Version de HOMARD",
ang="HOMARD release"),
#
#
# 6.5. Controle de la non-interpenetration des elements
#
- INTERPENETRATION=SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON"),
+ INTERPENETRATION=SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON"),
fr="Controle de la non interpénétration des éléments.",
ang="Overlapping checking." ),
#
) ;
-#& MODIF COMMANDE DATE 08/11/2005 AUTEUR ASSIRE A.ASSIRE
-# 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.
-# ======================================================================
-
-from Macro.macr_recal_ops import macr_recal_ops
-
-def macr_recal_prod(self,**args ):
- return listr8_sdaster
-
-MACR_RECAL = MACRO(nom="MACR_RECAL",op=macr_recal_ops,
- UIinfo={"groupes":("Résultats et champs",)},
- sd_prod=macr_recal_prod,
- fr="Réalise le recalage des calculs Aster sur des résultats expérimentaux"
- +" ou sur d'autres résultats de calculs",
- UNITE_ESCL =SIMP(statut='o',typ='I'),
- RESU_EXP =SIMP(statut='o',typ=assd,max='**'),
- POIDS =SIMP(statut='f',typ=assd,max='**'),
- RESU_CALC =SIMP(statut='o',typ=assd,max='**'),
- LIST_PARA =SIMP(statut='o',typ=assd,max='**'),
- ITER_MAXI =SIMP(statut='f',typ='I',defaut=10),
- RESI_GLOB_RELA =SIMP(statut='f',typ='R',defaut=1.E-3),
- UNITE_RESU =SIMP(statut='f',typ='I',defaut=91),
- PARA_DIFF_FINI =SIMP(statut='f',typ='R',defaut=0.001),
- GRAPHIQUE =FACT(statut='d',
- UNITE =SIMP(statut='f',typ='I',defaut=90),
- FORMAT =SIMP(statut='f',typ='TXM',defaut='XMGRACE',into=("XMGRACE","GNUPLOT")),
- INTERACTIF =SIMP(statut='f',typ='TXM',defaut='NON',into=("OUI","NON")),),
- INFO =SIMP(statut='f',typ='I',defaut=1,into=( 1, 2 ) ),
-) ;
-#& MODIF COMMANDE DATE 04/04/2006 AUTEUR CIBHHLV L.VIVAN
+#& MODIF COMMANDE DATE 04/04/2006 AUTEUR CIBHHLV L.VIVAN
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
NOEUD_DOUBLE =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON")),
AVEC_MODE_STAT =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
)
-#& MODIF COMMANDE DATE 16/05/2006 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 12/06/2006 AUTEUR CIBHHLV L.VIVAN
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
INST =SIMP(statut='f',typ='R',defaut=0.),
CARA_ELEM =SIMP(statut='f',typ=cara_elem),
CHARGE =SIMP(statut='f',typ=(char_meca,char_ther,char_acou),validators=NoRepeat(),max='**'),
+ CHAR_CINE =SIMP(statut='f',typ=(char_cine_meca,char_cine_ther,char_cine_acou) ),
NUME_DDL =SIMP(statut='o',typ=(nume_ddl_sdaster,CO)),
SOLVEUR =FACT(statut='d',
METHODE =SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",
TITRE =SIMP(statut='f',typ='TXM',max='**'),
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
) ;
-#& MODIF COMMANDE DATE 20/03/2006 AUTEUR ACBHHCD G.DEVESA
+#& MODIF COMMANDE DATE 19/09/2006 AUTEUR ACBHHCD G.DEVESA
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
RFIC =SIMP(statut='f',typ='R'),
FICH_RESU_IMPE =SIMP(statut='f',typ='TXM'),
FICH_RESU_FORC =SIMP(statut='f',typ='TXM'),
+ TYPE =SIMP(statut='f',typ='TXM',into=("BINAIRE","ASCII",),defaut="ASCII"),
DREF =SIMP(statut='f',typ='R'),
ALGO =SIMP(statut='f',typ='TXM',into=("DEPL","REGU")),
OFFSET_MAX =SIMP(statut='f',typ='R'),
),
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
) ;
+#& MODIF COMMANDE DATE 31/10/2006 AUTEUR ASSIRE A.ASSIRE
+# 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.
+# ======================================================================
+
+from Macro.macr_recal_ops import macr_recal_ops
+
+def macr_recal_prod(self,**args ):
+ return listr8_sdaster
+
+MACR_RECAL = MACRO(nom="MACR_RECAL",op=macr_recal_ops,
+ UIinfo={"groupes":("Résultats et champs",)},
+ sd_prod=macr_recal_prod,
+ fr="Réalise le recalage des calculs Aster sur des résultats expérimentaux"
+ +" ou sur d'autres résultats de calculs",
+ UNITE_ESCL =SIMP(statut='o',typ='I'),
+ RESU_EXP =SIMP(statut='o',typ=assd,max='**'),
+ POIDS =SIMP(statut='f',typ=assd,max='**'),
+ RESU_CALC =SIMP(statut='o',typ=assd,max='**'),
+ LIST_PARA =SIMP(statut='o',typ=assd,max='**'),
+ LIST_DERIV =SIMP(statut='f',typ=assd,max='**'),
+ ITER_MAXI =SIMP(statut='f',typ='I',defaut=10),
+ ITER_FONC_MAXI =SIMP(statut='f',typ='I',defaut=100),
+ RESI_GLOB_RELA =SIMP(statut='f',typ='R',defaut=1.E-3),
+ UNITE_RESU =SIMP(statut='f',typ='I',defaut=91),
+ PARA_DIFF_FINI =SIMP(statut='f',typ='R',defaut=0.001),
+# GRAPHIQUE =FACT(statut='d',
+ GRAPHIQUE =FACT(statut='f',
+ UNITE =SIMP(statut='f',typ='I',defaut=90),
+ FORMAT =SIMP(statut='f',typ='TXM',defaut='XMGRACE',into=("XMGRACE","GNUPLOT")),
+ INTERACTIF =SIMP(statut='f',typ='TXM',defaut='NON',into=("OUI","NON")),
+ AFFICHAGE =SIMP(statut='f',typ='TXM',defaut='TOUTE_ITERATION',into=("TOUTE_ITERATION","ITERATION_FINALE")),),
+ SUIVI_ESCLAVE =SIMP(statut='f',typ='TXM',defaut='NON',into=("OUI","NON"),),
+
+ METHODE =SIMP(statut='f',typ='TXM',defaut='LEVENBERG',into=("LEVENBERG","FMIN","FMINBFGS","FMINNCG","EXTERNE")),
+
+ b_gradient =BLOC(condition = "METHODE == 'FMINBFGS' or METHODE == 'FMINNCG'" ,
+ GRADIENT =SIMP(statut='f',typ='TXM',defaut='NON_CALCULE', into=("NON_CALCULE", "NORMAL", "ADIMENSIONNE" )),
+ ),
+
+ b_gradient_externe =BLOC(condition = "METHODE == 'EXTERNE'" ,
+ GRADIENT =SIMP(statut='f',typ='TXM',defaut='NON_CALCULE', into=("NON_CALCULE", "NORMAL", "ADIMENSIONNE" )),
+ ),
+
+ b_type_fonctionnelle =BLOC(condition = "METHODE == 'EXTERNE'" ,
+ FONCTIONNELLE =SIMP(statut='f',typ='TXM',defaut='SCALAIRE',into=("SCALAIRE","VECTORIELLE")),
+ ),
+
+ INFO =SIMP(statut='f',typ='I',defaut=2,into=( 1, 2 ) ),
+);
+#& MODIF COMMANDE DATE 07/11/2006 AUTEUR DURAND C.DURAND
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+
+from Macro.macr_spectre_ops import macr_spectre_ops
+
+MACR_SPECTRE=MACRO(nom="MACR_SPECTRE",op=macr_spectre_ops,sd_prod=table_sdaster,
+ reentrant='n', UIinfo={"groupes":("Outils métier",)},
+ fr="calcul de spectre, post-traitement de séisme",
+ MAILLAGE =SIMP(statut='o',typ=maillage_sdaster,),
+ PLANCHER =FACT(statut='o',max='**',
+ regles=(AU_MOINS_UN('NOEUD','GROUP_NO' ),),
+ NOM =SIMP(statut='o',typ='TXM',),
+ GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+ NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'), ),
+ NOM_CHAM =SIMP(statut='o',typ='TXM' ,into=('ACCE','DEPL')),
+ CALCUL =SIMP(statut='o',typ='TXM' ,into=('ABSOLU','RELATIF'),position='global'),
+ b_acce =BLOC( condition = "NOM_CHAM=='ACCE'",
+ regles=(UN_PARMI('LIST_FREQ','FREQ'),),
+ AMOR_SPEC =SIMP(statut='o',typ='R',max='**'),
+ LIST_INST =SIMP(statut='f',typ=listr8_sdaster ),
+ LIST_FREQ =SIMP(statut='f',typ=listr8_sdaster ),
+ FREQ =SIMP(statut='f',typ='R',max='**'),
+ NORME =SIMP(statut='f',typ='R',defaut=9.81),
+ RESU =FACT(statut='o',max='**',
+ regles=(UN_PARMI('RESU_GENE','RESULTAT'),),
+ RESU_GENE =SIMP(statut='f',typ=tran_gene),
+ RESULTAT =SIMP(statut='f',typ=(dyna_trans,evol_noli)),
+ b_calc =BLOC( condition = "CALCUL=='RELATIF'",
+ ACCE_X =SIMP(statut='o',typ=fonction_sdaster),
+ ACCE_Y =SIMP(statut='o',typ=fonction_sdaster),
+ ACCE_Z =SIMP(statut='o',typ=fonction_sdaster),), ),
+ IMPRESSION =FACT(statut='f',
+ TRI =SIMP(statut='f',typ='TXM',defaut='AMOR_SPEC',into=("AMOR_SPEC","DIRECTION",),),
+ FORMAT =SIMP(statut='f',typ='TXM',defaut='TABLEAU',into=("TABLEAU","XMGRACE",),),
+ UNITE =SIMP(statut='f',typ='I',val_min=10,val_max=90,defaut=29,
+ fr="Unité logique définissant le fichier (fort.N) dans lequel on écrit"),
+ b_pilote = BLOC(condition = "FORMAT == 'XMGRACE'",
+ PILOTE =SIMP(statut='f',typ='TXM',defaut='',
+ into=('','POSTSCRIPT','EPS','MIF','SVG','PNM','PNG','JPEG','PDF','INTERACTIF'),),),
+ TOUT =SIMP(statut='f',typ='TXM',defaut='NON',into=("OUI","NON",),),
+ ),
+ ),
+ b_depl =BLOC( condition = "NOM_CHAM=='DEPL'",
+ LIST_INST =SIMP(statut='f',typ=listr8_sdaster),
+ RESU =FACT(statut='o',max=3,
+ regles=(UN_PARMI('RESU_GENE','RESULTAT'),),
+ RESU_GENE =SIMP(statut='f',typ=tran_gene),
+ RESULTAT =SIMP(statut='f',typ=(dyna_trans,evol_noli)),
+ b_calc =BLOC( condition = "CALCUL=='ABSOLU'",
+ DEPL_X =SIMP(statut='o',typ=fonction_sdaster),
+ DEPL_Y =SIMP(statut='o',typ=fonction_sdaster),
+ DEPL_Z =SIMP(statut='o',typ=fonction_sdaster),),),
+ ),
+)
#& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
ELEMENT =FACT(statut='f',),
) ;
-#& MODIF COMMANDE DATE 10/05/2006 AUTEUR MCOURTOI M.COURTOIS
+#& MODIF COMMANDE DATE 12/06/2006 AUTEUR BOITEAU O.BOITEAU
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
NMAX_ITER =SIMP(statut='f',typ='I',defaut= 0 ),
),
- b_mumps =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
- TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut='AUTO',into=('NONSYM','SYMGEN','SYMDEF','AUTO')),
- PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=20,),
- RESI_RELA =SIMP(statut='f',typ='R',defaut=1.E-6),
- ),
+ b_mumps =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
+ TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
+ SCALING =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
+ RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+ PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=80,),
+ RESI_RELA =SIMP(statut='f',typ='R',defaut=1.E-6,),
+ ),
),
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
) ;
INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
) ;
-#& MODIF COMMANDE DATE 21/02/2006 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 10/07/2006 AUTEUR LEBOUVIE F.LEBOUVIER
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
NOEUD =SIMP(statut='f',typ=no),
GROUP_NO =SIMP(statut='f',typ=grno),
),
- b_modele =BLOC(condition = "(ORIE_PEAU_2D != None) or (ORIE_PEAU_3D != None) or(ORIE_NORM_COQUE != None)",
- MODELE =SIMP(statut='o',typ=modele_sdaster ),
- ),
PLAQ_TUBE =FACT(statut='f',
DEXT =SIMP(statut='o',typ='R' ),
EPAIS =SIMP(statut='o',typ='R' ),
),
INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
) ;
-#& MODIF COMMANDE DATE 06/07/2005 AUTEUR GENIAUT S.GENIAUT
+#& MODIF COMMANDE DATE 13/06/2006 AUTEUR GENIAUT S.GENIAUT
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2004 EDF R&D WWW.CODE-ASTER.ORG
MODELE_IN =SIMP(statut='o',typ=modele_sdaster,min=01,max=01,),
FISSURE =SIMP(statut='o',typ=fiss_xfem,min=01,max=01,),
- CRITERE =SIMP(statut='f',typ='R',defaut=1.1E-4),
+ CRITERE =SIMP(statut='f',typ='R',defaut=1.67E-8),
INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2,)),
) ;
-#& MODIF COMMANDE DATE 03/01/2006 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
-MODI_OBSTACLE=OPER(nom="MODI_OBSTACLE",op=182,sd_prod=obstacle_sdaster,
- fr="Calculer les obstacles dans les systèmes guidage-tube après usure",reentrant='f',
+MODI_OBSTACLE=OPER(nom="MODI_OBSTACLE",op=182,sd_prod=table_fonction,
+ fr="Calculer les obstacles dans les systèmes guidage-tube après usure",
+ reentrant='f',
UIinfo={"groupes":("Modélisation",)},
regles=(PRESENT_ABSENT('R_MOBILE','CRAYON'),
PRESENT_PRESENT('V_USUR_TUBE','V_USUR_OBST'),),
- V_USUR_TUBE =SIMP(statut='f',typ='R',max='**'),
- V_USUR_OBST =SIMP(statut='f',typ='R',max='**'),
+ OBSTACLE =SIMP(statut='f',typ=table_fonction),
+ GUIDE =SIMP(statut='o',typ=table_sdaster),
+ CRAYON =SIMP(statut='f',typ=table_sdaster),
TABL_USURE =SIMP(statut='f',typ=table_sdaster),
INST =SIMP(statut='f',typ='R'),
- OBSTACLE =SIMP(statut='f',typ=obstacle_sdaster),
- GUIDE =SIMP(statut='o',typ=obstacle_sdaster),
- CRAYON =SIMP(statut='f',typ=obstacle_sdaster),
R_MOBILE =SIMP(statut='f',typ='R'),
PERCEMENT =SIMP(statut='f',typ='R',defaut=1),
+ V_USUR_TUBE =SIMP(statut='f',typ='R',max='**'),
+ V_USUR_OBST =SIMP(statut='f',typ='R',max='**'),
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
) ;
#& MODIF COMMANDE DATE 12/09/2005 AUTEUR CIBHHLV L.VIVAN
TITRE =SIMP(statut='f',typ='TXM',max='**'),
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
) ;
-#& MODIF COMMANDE DATE 10/05/2006 AUTEUR MCOURTOI M.COURTOIS
+#& MODIF COMMANDE DATE 31/10/2006 AUTEUR A3BHHAE H.ANDRIAMBOLOLONA
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
if AsType(MODE) == mode_meca : return mode_meca
if AsType(MODE) == mode_meca_c : return mode_meca_c
if AsType(MODE) == mode_flamb : return mode_flamb
+ if AsType(MODE) == base_modale : return base_modale
raise AsException("type de concept resultat non prevu")
NORM_MODE=OPER(nom="NORM_MODE",op= 37,sd_prod=norm_mode_prod,
regles=(UN_PARMI('NORME','NOEUD','AVEC_CMP','SANS_CMP'),
CONCEPT_SENSIBLE('SEPARE'),
DERIVABLE('MODE'),),
- MODE =SIMP(statut='o',typ=(mode_meca,mode_flamb) ),
+ MODE =SIMP(statut='o',typ=(mode_meca,mode_flamb,base_modale) ),
NORME =SIMP(statut='f',typ='TXM',fr="Norme prédéfinie : masse généralisée, euclidienne,...",
into=("MASS_GENE","RIGI_GENE","EUCL","EUCL_TRAN","TRAN","TRAN_ROTA") ),
NOEUD =SIMP(statut='f',typ=no, fr="Composante donnée d un noeud spécifié égale à 1"),
fr="Liste des param\350tres de sensibilit\351.",
ang="List of sensitivity parameters",
),
+ b_base =BLOC(condition = "AsType(MODE) == base_modale",
+ MASSE = SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_gene_r,matr_asse_pres_r ), ),
+ RAIDE = SIMP(statut='o',typ=(matr_asse_depl_r,matr_asse_depl_c,matr_asse_gene_r,matr_asse_pres_r ), ),
+ AMOR = SIMP(statut='f',typ=(matr_asse_depl_r,matr_asse_gene_r) ),
+ ),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2) ),
) ;
-#& MODIF COMMANDE DATE 01/04/2005 AUTEUR VABHHTS J.PELLET
+#& MODIF COMMANDE DATE 12/06/2006 AUTEUR BOITEAU O.BOITEAU
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
b_ldlt =BLOC(condition="METHODE=='LDLT'",fr="paramètres associés à la méthode LDLT",
RENUM =SIMP(statut='f',typ='TXM',into=("RCMK","SANS"),defaut="RCMK" ),
),
- b_mumps =BLOC(condition="METHODE=='MUMPS'",fr="paramètres associés à la méthode MUMPS",
- RENUM =SIMP(statut='f',typ='TXM',into=("SANS",),defaut="SANS" ),
+ b_mumps =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
+ RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
),
b_gcpc =BLOC(condition="METHODE=='GCPC'",fr="paramètres associés à la méthode gradient conjugué",
RENUM =SIMP(statut='f',typ='TXM',into=("RCMK","SANS"),defaut="RCMK" ),
RESULTAT = SIMP(statut='o',typ=resultat_sdaster),
NOM_CHAM = SIMP(statut='o',typ='TXM',into=("DEPL","SIEF_ELGA"),)
);
-#& MODIF COMMANDE DATE 03/01/2006 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
-POST_DYNA_ALEA=OPER(nom="POST_DYNA_ALEA",op= 132,sd_prod=table_sdaster,
+from Macro.post_dyna_alea_ops import post_dyna_alea_ops
+
+POST_DYNA_ALEA=MACRO(nom="POST_DYNA_ALEA",op= post_dyna_alea_ops,sd_prod=table_sdaster,
fr="Traitements statistiques de résultats de type interspectre et impression sur fichiers",
reentrant='n',
UIinfo={"groupes":("Post traitements",)},
regles=(UN_PARMI('NOEUD_I','NUME_ORDRE_I','OPTION'),),
- INTE_SPEC =SIMP(statut='o',typ=table_sdaster),
+ INTE_SPEC =SIMP(statut='o',typ=table_fonction),
NUME_VITE_FLUI =SIMP(statut='f',typ='I' ),
TOUT_ORDRE =SIMP(statut='f',typ='TXM',into=("OUI",) ),
NUME_ORDRE_I =SIMP(statut='f',typ='I',max='**' ),
NOM_CMP_I =SIMP(statut='o',typ='TXM',max='**' ),
NOM_CMP_J =SIMP(statut='o',typ='TXM',max='**' ),
),
- DEPASSEMENT =FACT(statut='f',max='**',
- fr="Loi de dépassement d un seuil pendant une durée donnée",
- regles=(ENSEMBLE('VALE_MIN','VALE_MAX'),),
- VALE_MIN =SIMP(statut='f',typ='R' ),
- VALE_MAX =SIMP(statut='f',typ='R' ),
- PAS =SIMP(statut='f',typ='R' ),
- DUREE =SIMP(statut='f',typ='R',defaut= 1. ),
- ),
- RAYLEIGH =FACT(statut='f',max='**',
- fr="Densité de probabilité de pic positif, loi adaptée à des signaux à bande étroite",
- regles=(ENSEMBLE('VALE_MIN','VALE_MAX'),),
- VALE_MIN =SIMP(statut='f',typ='R' ),
- VALE_MAX =SIMP(statut='f',typ='R' ),
- PAS =SIMP(statut='f',typ='R' ),
- ),
- GAUSS =FACT(statut='f',max='**',
- fr="Densité de probabilité de pic positif, loi normale adaptée à des signaux large bande",
- regles=(ENSEMBLE('VALE_MIN','VALE_MAX'),),
- VALE_MIN =SIMP(statut='f',typ='R' ),
- VALE_MAX =SIMP(statut='f',typ='R' ),
- PAS =SIMP(statut='f',typ='R' ),
- ),
- VANMARCKE =FACT(statut='f',max='**',
- fr="Probabilité de non dépassement de seuil pendant une durée donnée (analyse sismique)",
- regles=(ENSEMBLE('VALE_MIN','VALE_MAX'),),
- VALE_MIN =SIMP(statut='f',typ='R' ),
- VALE_MAX =SIMP(statut='f',typ='R' ),
- PAS =SIMP(statut='f',typ='R' ),
- DUREE =SIMP(statut='f',typ='R',defaut= 10. ),
- ),
MOMENT =SIMP(statut='f',typ='I',max='**',fr="Moments spectraux en complément des cinq premiers" ),
TITRE =SIMP(statut='f',typ='TXM',max='**' ),
INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
TITRE =SIMP(statut='f',typ='TXM',max='**' ),
) ;
-#& MODIF COMMANDE DATE 16/05/2006 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 12/09/2006 AUTEUR REZETTE C.REZETTE
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
) ;
+#& MODIF COMMANDE DATE 31/10/2006 AUTEUR REZETTE C.REZETTE
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+
+from Macro.post_gp_ops import post_gp_ops
+def post_gp_prod(self, TABL_RESU, **kargs):
+ """Typage des sd_prod
+ """
+ if TABL_RESU != None:
+ self.type_sdprod(TABL_RESU, table_sdaster)
+ return table_sdaster
+
+POST_GP=MACRO(nom="POST_GP", op=post_gp_ops, sd_prod=post_gp_prod,
+ fr="Calcul du critère énergétique Gp suite à un calcul thermo-mécanique",
+ reentrant='n',
+ UIinfo={"groupes":("Post traitements",)},
+ regles=(AU_MOINS_UN('IDENTIFICATION', 'PREDICTION'),),
+
+ # Résultat, modèle, comportement, chargement
+ RESULTAT = SIMP(statut='o',typ=(evol_elas,evol_noli,dyna_trans,mode_meca),),
+ RESU_THER = SIMP(statut='f',typ=evol_ther,),
+ MODELE = SIMP(statut='o',typ=modele_sdaster),
+ MATER = SIMP(statut='o',typ=mater_sdaster),
+
+ COMP_ELAS = FACT(statut='o',
+ RELATION = SIMP(statut='f',typ='TXM',defaut="ELAS",
+ into=("ELAS","ELAS_VMIS_LINE","ELAS_VMIS_TRAC"),),
+ DEFORMATION = SIMP(statut='f',typ='TXM',defaut="PETIT",into=("PETIT","GREEN"),),
+ ),
+
+ EXCIT = FACT(statut='f', max='**',
+ CHARGE = SIMP(statut='o', typ=(char_meca,char_cine_meca)),
+ FONC_MULT = SIMP(statut='f', typ=(fonction_sdaster,nappe_sdaster,formule)),
+ TYPE_CHARGE = SIMP(statut='f', typ='TXM', defaut="FIXE", into=("FIXE",)),
+ ),
+ SYME_CHAR = SIMP(statut='f',typ='TXM',defaut="SANS",into=("SYME","ANTI","SANS")),
+
+ DIRECTION = SIMP(statut='o', typ='R', max=3),
+ THETA_2D = FACT(statut='o', max='**',
+ fr="paramètres de définition des champs theta",
+ GROUP_NO = SIMP(statut='o', typ=grno, validators=NoRepeat(), max='**'),
+ R_INF = SIMP(statut='o', typ='R'),
+ R_SUP = SIMP(statut='o', typ='R'),
+ ),
+
+ # copeaux
+ GROUP_MA = SIMP(statut='o', typ=grma, validators=NoRepeat(), max='**'),
+ PAS_ENTAILLE = SIMP(statut='o', typ='R', val_min=0.),
+
+ # critère sur Gp
+ CRIT_MAXI_GP = SIMP(statut='f', typ='TXM', defaut="ABSOLU",
+ into=("RELATIF","ABSOLU")),
+
+ # correction axisymétrie
+ RAYON_AXIS = SIMP(statut='f', typ='R', val_min=0., defaut=1.),
+
+ # identification
+ IDENTIFICATION = FACT(statut='f', max=1,
+ KJ_CRIT = SIMP(statut='o', typ='R', val_min=0., max='**'),
+ TEMP = SIMP(statut='o', typ='R', val_min=0., max='**'),
+ ),
+
+ # prédiction
+ PREDICTION = FACT(statut='f', max=1,
+ GP_CRIT = SIMP(statut='o', typ='R', val_min=0., max='**'),
+ TEMP = SIMP(statut='o', typ='R', val_min=0., max='**'),
+ ),
+
+ # table résultat
+ TABL_RESU = SIMP(statut='o', typ=CO,),
+
+ INFO = SIMP(statut='f', typ='I', defaut=1, into=(1, 2),),
+)
#& MODIF COMMANDE DATE 09/05/2006 AUTEUR GALENNE E.GALENNE
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
),
TITRE = SIMP(statut='f',typ='TXM',max='**'),
);
+#& MODIF COMMANDE DATE 31/10/2006 AUTEUR REZETTE C.REZETTE
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG
+# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
+# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
+# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
+# (AT YOUR OPTION) ANY LATER VERSION.
+#
+# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
+# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
+# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
+# GENERAL PUBLIC LICENSE FOR MORE DETAILS.
+#
+# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
+# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
+# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
+# ======================================================================
+
+from Macro.post_k_trans_ops import post_k_trans_ops
+
+POST_K_TRANS=MACRO(nom="POST_K_TRANS",op=post_k_trans_ops,sd_prod=table_sdaster,
+ fr="Calcul des facteurs d intensite des contrainte par recombinaison modale",reentrant='n',
+ UIinfo={"groupes":("Post traitements",)},
+ RESU_TRANS =SIMP(statut='o',typ=tran_gene),
+ K_MODAL =FACT(statut='o',
+ TABL_K_MODA =SIMP(statut='f',typ=table_sdaster,),
+ RESU_MODA =SIMP(statut='f',typ=mode_meca,),
+ FOND_FISS =SIMP(statut='f',typ=fond_fiss,),
+ FISSURE =SIMP(statut='f',typ=fiss_xfem,),
+ THETA =SIMP(statut='f',typ=(theta_geom,cham_no_sdaster)),
+ R_INF =SIMP(statut='f',typ='R'),
+ R_SUP =SIMP(statut='f',typ='R'),
+ MODULE =SIMP(statut='f',typ='R'),
+ DIRE_THETA =SIMP(statut='f',typ=cham_no_sdaster ),
+ DIRECTION =SIMP(statut='f',typ='R',max='**'),
+ R_INF_FO =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+ R_SUP_FO =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+ MODULE_FO =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
+ DEGRE =SIMP(statut='f',typ='I',into=(0,1,2,3,4,5,6,7) ),
+ LISSAGE_THETA =SIMP(statut='f',typ='TXM',into=("LEGENDRE","LAGRANGE","LAGRANGE_REGU"),),
+ LISSAGE_G =SIMP(statut='f',typ='TXM',into=("LEGENDRE","LAGRANGE","LAGRANGE_NO_NO","LAGRANGE_REGU"),),
+
+
+ regles=(UN_PARMI('TABL_K_MODA','RESU_MODA'),
+ UN_PARMI('FISSURE','FOND_FISS'),
+ EXCLUS('MODULE','MODULE_FO'),
+ PRESENT_PRESENT('R_INF','R_SUP'),
+ PRESENT_PRESENT('R_INF_FO','R_SUP_FO'), ),
+ ),
+ regles=(EXCLUS('TOUT_ORDRE','NUME_ORDRE','INST','LIST_INST','LIST_ORDRE'),),
+ TOUT_ORDRE =SIMP(statut='f',typ='TXM',into=("OUI",) ),
+ NUME_ORDRE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**'),
+ LIST_ORDRE =SIMP(statut='f',typ=listis_sdaster),
+ INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),
+ LIST_INST =SIMP(statut='f',typ=listr8_sdaster),
+ PRECISION =SIMP(statut='f',typ='R',defaut= 1.0E-3),
+ CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU",) ),
+
+ INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2)),
+ TITRE =SIMP(statut='f',typ='TXM'),
+)
+
#& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
MODELE = SIMP(statut='o',typ=modele_sdaster),
TITRE = SIMP(statut='f',typ='TXM',max='**'),
);
-#& MODIF COMMANDE DATE 13/03/2006 AUTEUR CIBHHLV L.VIVAN
+#& MODIF COMMANDE DATE 03/10/2006 AUTEUR CIBHHLV L.VIVAN
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
into=("PM_PB","SN","FATIGUE_ZH210") ),
MATER =SIMP(statut='o',typ=mater_sdaster ),
+ SY_MAX =SIMP(statut='f',typ='R',
+ fr="limite élastique utilisée pourle calcul du rochet thermique" ),
TRANSITOIRE =FACT(statut='o',max='**',fr="transitoire à dépouiller",
regles=(EXCLUS('TOUT_ORDRE','INST','LIST_INST'),),
fr="relevé des contraintes sur le chemin"),
TABL_SIGM_THER =SIMP(statut='f',typ=table_sdaster,
fr="résultat sous chargement thermique seul" ),
+ TABL_RESU_PRES =SIMP(statut='f',typ=table_sdaster,
+ fr="table relevé des contraintes sous chargement de pression" ),
TOUT_ORDRE =SIMP(statut='f',typ='TXM',into=("OUI",) ),
INST =SIMP(statut='f',typ='R',validators=NoRepeat(),max='**'),
LIST_INST =SIMP(statut='f',typ=listr8_sdaster ),
OPTION =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max='**',
into=("PM_PB","SN","FATIGUE") ),
MATER =SIMP(statut='o',typ=mater_sdaster ),
+ SY_MAX =SIMP(statut='f',typ='R',
+ fr="limite élastique utilisée pourle calcul du rochet thermique" ),
TYPE_KE =SIMP(statut='f',typ='TXM',defaut="KE_MECA",into=("KE_MECA","KE_MIXTE"),
fr="Ke meca seul ou partition mecanique + thermique" ),
CHAR_MECA =FACT(statut='o',max='**',fr="Chargements mécaniques",
),
),
) ;
-#& MODIF COMMANDE DATE 16/05/2006 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 27/11/2006 AUTEUR GNICOLAS G.NICOLAS
# ======================================================================
# CONFIGURATION MANAGEMENT OF EDF VERSION
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
POST_RELEVE_T=OPER(nom="POST_RELEVE_T",op=51,sd_prod=table_sdaster,reentrant='f',
fr="Extraire des valeurs de composantes de champs de grandeurs pour y effectuer des calculs (moyenne,invariants,..)"
+" ou pour les exprimer dans d'autres repères",
- UIinfo={"groupes":("Post traitements",)},
+ docu="U4.81.21",UIinfo={"groupes":("Post traitements",)},
ACTION =FACT(statut='o',max='**',
regles=(UN_PARMI('RESULTAT','CHAM_GD'),),
cham_elem,),),
RESULTAT =SIMP(statut='f',typ=(evol_elas,evol_ther,evol_noli,dyna_trans,
mode_meca,mode_flamb,mode_acou,base_modale,mode_stat,
- mult_elas,fourier_elas,dyna_harmo,acou_harmo)),
-
- b_sensibilite =BLOC(condition="RESULTAT != None",
+ mult_elas,fourier_elas,fourier_ther,dyna_harmo,acou_harmo)),
+#
+# 1. Sensibilité
+# 1.1. Cas d'un résultat réel
+# Cas d'un résultat harmonique dont on veut partie réelle ou imaginaire
+#
+ b_sensibilite =BLOC(condition=" (RESULTAT != None) and \
+ ( AsType(RESULTAT) in (evol_elas,evol_ther,evol_noli,dyna_trans, \
+ mode_meca,mode_flamb,mode_acou,base_modale,mode_stat, \
+ mult_elas,fourier_elas,fourier_ther) or \
+ ( AsType(RESULTAT) in (dyna_harmo,acou_harmo) and FORMAT_C != 'MODULE' ) )",
fr="Définition des paramètres de sensibilité",
ang="Definition of sensitivity parameters",
regles=(CONCEPT_SENSIBLE("SEPARE"), REUSE_SENSIBLE(),
SENSIBILITE =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**',
fr="Liste des paramètres de sensibilité.",
ang="List of sensitivity parameters"),
+
+ ),
+#
+# 1.2. Cas d'un résultat harmonique dont on veut le module
+#
+ b_sensibilite_harmo =BLOC(condition=" (RESULTAT != None) and \
+ ( AsType(RESULTAT) in (dyna_harmo,acou_harmo) and FORMAT_C == 'MODULE' )",
+ fr="Définition des paramètres de sensibilité",
+ ang="Definition of sensitivity parameters",
+ regles=(CONCEPT_SENSIBLE("SEPARE"), REUSE_SENSIBLE(),
+ DERIVABLE('RESULTAT'),),
+ SENSIBILITE =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**',
+ fr="Liste des paramètres de sensibilité.",
+ ang="List of sensitivity parameters"),
+ b_sensibilite_harmo =BLOC(condition=" SENSIBILITE != None",
+ fr="Option pour la sensibilite",
+ ang="Option for sensitivity",
+ SENSIBILITE_OPTION =SIMP(statut='o',typ='TXM',into=("MODULE_SENSIBILITE","SENSIBILITE_MODULE",),
+ fr="Option : module de la dérivée ou dérivée du module",
+ ang="Option : modulus of derivative or derivative of modulus"),
+ ),
),
b_extrac =BLOC(condition = "RESULTAT != None",fr="extraction des résultats",
CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")),
) ;
-#& MODIF COMMANDE DATE 16/01/2006 AUTEUR D6BHHJP J.P.LEFEBVRE
+#& MODIF COMMANDE DATE 19/06/2006 AUTEUR VABHHTS J.PELLET
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 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.
+# 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.
+# 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.
+# 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.
# ======================================================================
POURSUITE=MACRO(nom="POURSUITE",op=ops.build_poursuite,repetable='n',
fr="Poursuite d'une étude à partir de la sauvegarde au format JEVEUX ou HDF de sa base globale",
UIinfo={"groupes":("Gestion du travail",)},
op_init = ops.POURSUITE_context,fichier_ini = 1,
FORMAT_HDF =SIMP(fr="sauvegarde de la base GLOBALE au format HDF",statut='f',
- typ='TXM',defaut="NON",into=("OUI","NON",) ),
+ typ='TXM',defaut="NON",into=("OUI","NON",) ),
PAR_LOT =SIMP(fr="mode de traitement des commandes",statut='f',typ='TXM',
into=("OUI","NON"),defaut="OUI"),
IMPR_MACRO =SIMP(fr="affichage des sous-commandes produites par les macros dans le fichier mess",
statut='f',min=1,max=1,
JXVERI =SIMP(fr="vérifie l intégrité de la segmentation mémoire",
statut='f',typ='TXM',into=('OUI','NON'),defaut='NON'),
+ SDVERI =SIMP(fr="vérifie la conformité des SD produites par les commandes",
+ statut='f',typ='TXM',into=('OUI','NON'),defaut='NON'),
JEVEUX =SIMP(fr="force les déchargement sur disque",
statut='f',typ='TXM',into=('OUI','NON'),defaut='NON'),
ENVIMA =SIMP(fr="imprime les valeurs définies dans ENVIMA",
CHAM_NO =SIMP(statut='o',typ=cham_no_sdaster),
TITRE =SIMP(statut='f',typ='TXM',max='**'),
) ;
-#& MODIF COMMANDE DATE 10/05/2006 AUTEUR MCOURTOI M.COURTOIS
+#& MODIF COMMANDE DATE 12/09/2006 AUTEUR VABHHTS J.PELLET
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
if AsType(RESULTAT) == evol_noli : return evol_noli
if AsType(RESULTAT) == evol_char : return evol_char
if AsType(RESULTAT) == dyna_trans : return dyna_trans
+ if AsType(RESULTAT) == dyna_harmo : return dyna_harmo
if AsType(RESULTAT) == mode_meca : return mode_meca
if AsType(RESULTAT) == mode_stat_depl : return mode_stat_depl
if AsType(RESULTAT) == base_modale : return base_modale
CONCEPT_SENSIBLE('SEPARE'),
REUSE_SENSIBLE(),
DERIVABLE('RESULTAT'),),
- RESULTAT =SIMP(statut='o',typ=(evol_ther,evol_elas,evol_noli,dyna_trans,evol_char,
+ RESULTAT =SIMP(statut='o',typ=(evol_ther,evol_elas,evol_noli,dyna_trans,evol_char,dyna_harmo,
mode_meca,mode_stat_depl,base_modale) ),
SENSIBILITE =SIMP(statut='f',typ=(para_sensi,theta_geom),validators=NoRepeat(),max='**',
fr="Liste des paramètres de sensibilité.",
MODELE_1 =SIMP(statut='o',typ=modele_sdaster),
MODELE_2 =SIMP(statut='o',typ=modele_sdaster),
+ NOM_PARA =SIMP(statut='f',typ='TXM', max='**'),
TOUT_CHAM =SIMP(statut='f',typ='TXM',into=("OUI",) ),
NOM_CHAM =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'),
NUME_MODE =SIMP(statut='f',typ='I',validators=NoRepeat(),max='**' ),
NOEUD_CMP =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max='**'),
+
CAS_FIGURE =SIMP(statut='f',typ='TXM',into=("2D","3D","2.5D","1.5D",) ),
DISTANCE_MAX =SIMP(statut='f',typ='R',
fr="Distance maximale entre le noeud et l'élément le plus proche, lorsque le noeud n'est dans aucun élément."),
+ TRANSF_GEOM_2 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3,
+ fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+
+ " aux noeuds du MODELE_2 avant la projection."),
+
ALARME =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
TYPE_CHAM =SIMP(statut='f',typ='TXM',into=("NOEU",),
GROUP_NO_2 =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
NOEUD_2 =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
CAS_FIGURE =SIMP(statut='f',typ='TXM',into=("2D","3D","2.5D","1.5D",) ),
+ TRANSF_GEOM_2 =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule),min=2,max=3,
+ fr="2 (ou 3) fonctions fx,fy,fz définissant la transformation géométrique à appliquer"+
+ " aux noeuds du MODELE_2 avant la projection."),
),
TITRE =SIMP(statut='f',typ='TXM',max='**' ),
MATR_ASSE_GENE =SIMP(statut='f',typ=(matr_asse_gene_r,matr_asse_gene_c) ),
) ;
-#& MODIF COMMANDE DATE 22/06/2005 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 19/06/2006 AUTEUR VABHHTS J.PELLET
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
NOEU_CALCUL =SIMP(statut='f',typ=no),
NOEU_MESURE =SIMP(statut='f',typ=no),
),
+ NOM_PARA =SIMP(statut='f',typ='TXM',max='**'),
RESOLUTION =FACT(statut='f',
METHODE =SIMP(statut='f',typ='TXM',defaut="LU",into=("LU","SVD",) ),
b_svd =BLOC(condition="METHODE=='SVD'",
),
);
-#& MODIF COMMANDE DATE 21/02/2006 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
-PROJ_SPEC_BASE=OPER(nom="PROJ_SPEC_BASE",op= 146,sd_prod=table_sdaster,reentrant='n',
+PROJ_SPEC_BASE=OPER(nom="PROJ_SPEC_BASE",op= 146,sd_prod=table_fonction,reentrant='n',
UIinfo={"groupes":("Matrices/vecteurs",)},
fr="Projecter un ou plusieurs spectres de turbulence sur une (ou plusieurs) base(s) modale(s) ",
regles=(UN_PARMI('BASE_ELAS_FLUI','MODE_MECA','CHAM_NO'),
ENSEMBLE('FREQ_INIT','FREQ_FIN','NB_POIN'),),
SPEC_TURB =SIMP(statut='o',typ=spectre_sdaster,validators=NoRepeat(),max='**' ),
+ TOUT_CMP =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
BASE_ELAS_FLUI =SIMP(statut='f',typ=melasflu_sdaster ),
MODE_MECA =SIMP(statut='f',typ=mode_meca ),
CHAM_NO =SIMP(statut='f',typ=cham_no_sdaster),
VECT_ASSE =SIMP(statut='f',typ=cham_no_sdaster),
VECT_ASSE_GENE =SIMP(statut='f',typ=vect_asse_gene ),
) ;
-#& MODIF COMMANDE DATE 09/05/2006 AUTEUR MASSIN P.MASSIN
+#& MODIF COMMANDE DATE 22/08/2006 AUTEUR MASSIN P.MASSIN
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2006 EDF R&D WWW.CODE-ASTER.ORG
C =SIMP(statut='o',typ='R',),
M =SIMP(statut='o',typ='R',),),
),
- GROUP_MA_ENRI =SIMP(statut='o',typ=grma,max=01),
-
- INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
+
+ RAYON =SIMP(statut='o',typ='R',),
+
+ METHODE =SIMP(statut='f',typ='TXM',into=("SIMPLEXE","UPWIND",),defaut="COEFF_POSITIF"),
+
+# RUNGE_KUTTA =SIMP(statut='f',typ='I',into=("1","2",),defaut=1),
+
+ INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2) ),
) ;
#& MODIF COMMANDE DATE 03/01/2006 AUTEUR REZETTE C.REZETTE
# CONFIGURATION MANAGEMENT OF EDF VERSION
ITER_GLOB_MAXI =SIMP(statut='f',typ='I',defaut= 10 ),
INFO =SIMP(statut='f',typ='I',defaut= 1,into=( 1 , 2 ,) ),
) ;
-#& MODIF COMMANDE DATE 16/05/2006 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 07/11/2006 AUTEUR DURAND C.DURAND
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
# RESPONSABLE MCOURTOI M.COURTOIS
-def recu_fonction_prod(RESULTAT=None,TABLE=None,OBSTACLE=None,
- RESU_GENE=None,BASE_ELAS_FLUI=None,CHAM_GD=None,
- TYPE_RESU=None,**args):
- if AsType(RESULTAT) == dyna_harmo : return fonction_c
- if AsType(RESU_GENE) == harm_gene : return fonction_c
-# On ne sait pas interpreter les deux conditions suivantes
- if TABLE != None :
- if TYPE_RESU != None :
- if TYPE_RESU == "FONCTION_C" : return fonction_c
- if TYPE_RESU == "FONCTION" : return fonction_sdaster
- else:
- return fonction_sdaster
- if RESU_GENE != None : return fonction_sdaster
- if BASE_ELAS_FLUI != None : return fonction_sdaster
- if RESULTAT != None : return fonction_sdaster
- if CHAM_GD != None : return fonction_sdaster
- if OBSTACLE != None : return fonction_sdaster
- raise AsException("type de concept resultat non prevu")
+def recu_fonction_prod(RESULTAT=None,TABLE=None,RESU_GENE=None,
+ BASE_ELAS_FLUI=None,CHAM_GD=None,NAPPE=None,
+ NOM_PARA_TABL=None,**args):
+ if AsType(RESULTAT) == dyna_harmo or \
+ AsType(RESU_GENE) == harm_gene or \
+ (TABLE != None and NOM_PARA_TABL == "FONCTION_C"):
+ return fonction_c
+ else:
+ return fonction_sdaster
RECU_FONCTION=OPER(nom="RECU_FONCTION",op=90,sd_prod=recu_fonction_prod,
fr="Extraire sous forme d'une fonction, l'évolution d'une grandeur en fonction d'une autre",
reentrant='f',
UIinfo={"groupes":("Fonction",)},
- regles=(UN_PARMI('CHAM_GD','RESULTAT','RESU_GENE','TABLE','BASE_ELAS_FLUI','OBSTACLE'),),
+ regles=(UN_PARMI('CHAM_GD','RESULTAT','RESU_GENE','TABLE','BASE_ELAS_FLUI','NAPPE'),),
CHAM_GD =SIMP(statut='f',typ=(cham_no_sdaster,
cham_elem,),),
RESULTAT =SIMP(statut='f',typ=(evol_elas,dyna_trans,evol_noli,evol_ther,dyna_harmo ) ),
RESU_GENE =SIMP(statut='f',typ=(tran_gene, mode_gene, harm_gene)),
- TABLE =SIMP(statut='f',typ=table_sdaster),
+ TABLE =SIMP(statut='f',typ=(table_sdaster,table_fonction)),
BASE_ELAS_FLUI =SIMP(statut='f',typ=melasflu_sdaster),
- OBSTACLE =SIMP(statut='f',typ=obstacle_sdaster),
+ NAPPE =SIMP(statut='f',typ=nappe_sdaster),
# ======= SENSIBILITE =================================================
b_sensibilite =BLOC(condition="RESULTAT != None",
fr="Récupération de la fonction à partir d un concept table",
regles=(UN_PARMI('PARA_X','NOM_PARA_TABL'),
PRESENT_PRESENT('PARA_X','PARA_Y'),),
- PARA_X =SIMP(statut='f',typ='TXM',
+ PARA_X = SIMP(statut='f',typ='TXM',
fr="1ère colonne de la table qui définit la fonction à récupérer", ),
- PARA_Y =SIMP(statut='f',typ='TXM',
+ PARA_Y = SIMP(statut='f',typ='TXM',
fr="2ème colonne de la table qui définit la fonction à récupérer", ),
- NOM_PARA_TABL =SIMP(statut='f',typ='TXM',into=("FONCTION",),
- fr="Nom du paramètre de la table à qui est associé la fonction" ),
- b_nom_para_tabl = BLOC (condition = "NOM_PARA_TABL != None",
- TYPE_RESU =SIMP(statut='f',typ='TXM',defaut="FONCTION",into=("FONCTION","FONCTION_C") ),
- ),
+ #b_tabl_fonc = BLOC(condition = "AsType(TABLE) == table_fonction",
+ NOM_PARA_TABL = SIMP(statut='f',typ='TXM',into=("FONCTION","FONCTION_C"),
+ fr="Nom du paramètre de la table contenant la fonction" ),
+ #),
- FILTRE =FACT(statut='f',max='**',
+ FILTRE = FACT(statut='f',max='**',
NOM_PARA =SIMP(statut='o',typ='TXM' ),
CRIT_COMP =SIMP(statut='f',typ='TXM',defaut="EQ",
into=("EQ","LT","GT","NE","LE","GE","VIDE",
SOUS_POINT =SIMP(statut='f',typ='I' ),
),
-# ======= OBSTACLE =================================================
- b_obstacle = BLOC ( condition = "OBSTACLE != None",
- fr="Choix du repère",
- REPERE =SIMP(statut='f',typ='TXM',into=("POLAIRE","GLOBAL") ),
+# ======= NAPPE =================================================
+ b_nappe = BLOC ( condition = "(NAPPE != None)", fr="Opérandes en cas de NAPPE",
+ VALE_PARA_FONC =SIMP(statut='o',typ='R' ),
+ PRECISION =SIMP(statut='f',typ='R',defaut= 1.E-3 ),
+ CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
),
# ======= SURCHARGE DES ATTRIBUTS =================================================
TITRE =SIMP(statut='f',typ='TXM',max='**'),
INFO =SIMP(statut='f',typ='I',into=(1,2) ),
) ;
-#& MODIF COMMANDE DATE 20/03/2006 AUTEUR ACBHHCD G.DEVESA
+#& MODIF COMMANDE DATE 31/10/2006 AUTEUR CIBHHLV L.VIVAN
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
TOUT_CHAM =SIMP(statut='f',typ='TXM',into=("OUI",) ),
GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
+ GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+ MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
ACCE_MONO_APPUI =SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule)),
DIRECTION =SIMP(statut='f',typ='R',min=3,max=3 ),
SECTEUR =SIMP(statut='f',typ='I',defaut= 1 ),
TITRE =SIMP(statut='f',typ='TXM',max='**' ),
) ;
-#& MODIF COMMANDE DATE 03/01/2006 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
# ======================================================================
-REST_SPEC_PHYS=OPER(nom="REST_SPEC_PHYS",op= 148,sd_prod=table_sdaster,
+REST_SPEC_PHYS=OPER(nom="REST_SPEC_PHYS",op= 148,sd_prod=table_fonction,
reentrant='n',
fr="Calculer la réponse d'une structure dans la base physique",
UIinfo={"groupes":("Matrices/vecteurs",)},
MODE_MECA =SIMP(statut='f',typ=mode_meca ),
BANDE =SIMP(statut='f',typ='R',min=2,validators=NoRepeat(),max=2 ),
NUME_ORDRE =SIMP(statut='f',typ='I' ,validators=NoRepeat(),max='**' ),
- INTE_SPEC_GENE =SIMP(statut='o',typ=table_sdaster),
+ INTE_SPEC_GENE =SIMP(statut='o',typ=table_fonction),
NOEUD =SIMP(statut='o',typ=no ,max='**'),
MAILLE =SIMP(statut='f',typ=ma ,max='**'),
NOM_CMP =SIMP(statut='o',typ='TXM',max='**'),
into=("DIAG_TOUT","DIAG_DIAG","TOUT_TOUT","TOUT_DIAG") ),
TITRE =SIMP(statut='f',typ='TXM',max='**' ),
) ;
+#& MODIF COMMANDE DATE 10/10/2006 AUTEUR REZETTE C.REZETTE
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2006 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.
+# ======================================================================
+# -*- coding: iso-8859-1 -*-
+
+from Macro.simu_point_mat_ops import simu_point_mat_ops
+
+SIMU_POINT_MAT=MACRO(nom="SIMU_POINT_MAT", op=simu_point_mat_ops,sd_prod=table_sdaster,
+ UIinfo={"groupes":("Résolution",)},
+ fr="Calcul de l'évolution mécanique, en quasi-statique,"
+ +" d'un point matériel en non linéaire",
+ COMP_INCR =C_COMP_INCR(),
+ MATER =SIMP(statut='o',typ=mater_sdaster,max=30),
+ INCREMENT =FACT(statut='o',
+ LIST_INST =SIMP(statut='o',typ=listr8_sdaster),
+ # DEBUT DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS
+ SUBD_METHODE =SIMP( statut='f',typ='TXM',
+ into =("AUCUNE","UNIFORME","EXTRAPOLE"),
+ defaut="AUCUNE",
+ fr="Méthode de subdivision des pas de temps en cas de non-convergence"
+ ),
+ b_subd_unif=BLOC(condition = "SUBD_METHODE == 'UNIFORME'",
+ regles=(AU_MOINS_UN('SUBD_NIVEAU','SUBD_PAS_MINI'),),
+ SUBD_COEF_PAS_1=SIMP(statut='f',typ='R',defaut=1.0,val_min=0.0,
+ fr="Coefficient multiplicateur de la 1ère subdivision"),
+ SUBD_PAS =SIMP(statut='f',typ='I',defaut=4,val_min=2,
+ fr="Nombre de subdivision d'un pas de temps"),
+ SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2,
+ fr="Nombre maximum de niveau de subdivision d'un pas de temps"),
+ SUBD_PAS_MINI=SIMP(statut='f',typ='R',val_min=0.0,
+ fr="Pas de temps en dessous duquel on ne subdivise plus"),
+ ),
+ b_subd_extr=BLOC(condition = "SUBD_METHODE == 'EXTRAPOLE'",
+ regles=(AU_MOINS_UN('SUBD_NIVEAU','SUBD_PAS_MINI'),),
+ SUBD_OPTION =SIMP(statut='f',typ='TXM',
+ into =("IGNORE_PREMIERES","GARDE_DERNIERES",),
+ defaut="IGNORE_PREMIERES",
+ fr="Technique d'extrapolation : les 1ere itérations sont ignorées ou les dernières sont gardées"),
+ SUBD_ITER_IGNO =SIMP(statut='c',typ='I',defaut=3,val_min=0,
+ fr="Les n premières itérations sont ignorées pour l'extrapolation"),
+ SUBD_ITER_FIN =SIMP(statut='c',typ='I',defaut=8,val_min=3,
+ fr="Seules les n dernières itérations sont prises pour l'extrapolation"),
+ SUBD_PAS =SIMP(statut='c',typ='I',defaut=4,val_min=2,
+ fr="Nombre de subdivision d'un pas de temps en cas divergence"),
+ SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2,
+ fr="Nombre maximum de niveau de subdivision d'un pas de temps"),
+ SUBD_PAS_MINI=SIMP(statut='f',typ='R',val_min=0.0,
+ fr="Pas de temps en dessous duquel on ne subdivise plus"),
+ SUBD_ITER_PLUS =SIMP(statut='c',typ='I',defaut=50,val_min=20,
+ fr="% itération autorisée en plus"),
+ ),
+ # FIN DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS
+ ),
+ NEWTON =FACT(statut='d',
+ PREDICTION =SIMP(statut='f',typ='TXM',into=("TANGENTE","ELASTIQUE","EXTRAPOL") ),
+ MATRICE =SIMP(statut='f',typ='TXM',defaut="TANGENTE",into=("TANGENTE","ELASTIQUE") ),
+ PAS_MINI_ELAS =SIMP(statut='f',typ='R',defaut=0.0E+0),
+ REAC_ITER =SIMP(statut='f',typ='I',defaut=1),
+ REAC_ITER_ELAS =SIMP(statut='f',typ='I',defaut=0),
+ ),
+ CONVERGENCE =FACT(statut='d',
+ regles=(PRESENT_ABSENT('RESI_REFE_RELA','RESI_GLOB_MAXI','RESI_GLOB_RELA'),),
+ SIGM_REFE =SIMP(statut='f',typ='R'),
+ EPSI_REFE =SIMP(statut='f',typ='R'),
+ RESI_REFE_RELA =SIMP(statut='f',typ='R'),
+ RESI_GLOB_MAXI =SIMP(statut='f',typ='R'),
+ RESI_GLOB_RELA =SIMP(statut='f',typ='R'),
+ ITER_GLOB_MAXI =SIMP(statut='f',typ='I',defaut=50),
+ ITER_GLOB_ELAS =SIMP(statut='f',typ='I',defaut=25),
+ ARRET =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
+ ),
+ SUIVI_DDL = FACT(statut='f',max=4,
+ NUME_SUIVI =SIMP(statut='o',typ='I' ,min=1,max=4),
+ NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=1,
+ into=("DEPL","SIEF_ELGA","VARI_ELGA",)),
+ NOM_CMP =SIMP(statut='o',typ='TXM',max=1 ),
+ ),
+ SIGM_IMPOSE=FACT(statut='f',
+ SIXX = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ SIYY = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ SIZZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ SIXY = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ SIXZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ SIYZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ ),
+ EPSI_IMPOSE=FACT(statut='f',
+ EPXX = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ EPYY = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ EPZZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ EPXY = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ EPXZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ EPYZ = SIMP(statut='f',typ=(fonction_sdaster,nappe_sdaster,formule) ),
+ ),
+
+
+ INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
+)
#& MODIF COMMANDE DATE 15/05/2006 AUTEUR ASSIRE A.ASSIRE
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
fr="Unité logique définissant le fichier (fort.N) dans lequel on écrit les md5"),
) ;
-#& MODIF COMMANDE DATE 16/05/2006 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 10/10/2006 AUTEUR REZETTE C.REZETTE
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
NUME_INST_FIN =SIMP(statut='f',typ='I'),
INST_FIN =SIMP(statut='f',typ='R'),
PRECISION =SIMP(statut='f',typ='R',defaut=1.0E-3 ),
- SUBD_PAS =SIMP(statut='f',typ='I',defaut=1),
- SUBD_PAS_MINI =SIMP(statut='f',typ='R'),
- COEF_SUBD_PAS_1 =SIMP(statut='f',typ='R',defaut= 1.0E+0),
+ # DEBUT DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS
+ SUBD_METHODE =SIMP( statut='f',typ='TXM',
+ into =("AUCUNE","UNIFORME","EXTRAPOLE"),
+ defaut="AUCUNE",
+ fr="Méthode de subdivision des pas de temps en cas de non-convergence"
+ ),
+ b_subd_unif=BLOC(condition = "SUBD_METHODE == 'UNIFORME'",
+ regles=(AU_MOINS_UN('SUBD_NIVEAU','SUBD_PAS_MINI'),),
+ SUBD_COEF_PAS_1=SIMP(statut='f',typ='R',defaut=1.0,val_min=0.0,
+ fr="Coefficient multiplicateur de la 1ère subdivision"),
+ SUBD_PAS =SIMP(statut='f',typ='I',defaut=4,val_min=2,
+ fr="Nombre de subdivision d'un pas de temps"),
+ SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2,
+ fr="Nombre maximum de niveau de subdivision d'un pas de temps"),
+ SUBD_PAS_MINI=SIMP(statut='f',typ='R',val_min=0.0,
+ fr="Pas de temps en dessous duquel on ne subdivise plus"),
+ ),
+ b_subd_extr=BLOC(condition = "SUBD_METHODE == 'EXTRAPOLE'",
+ regles=(AU_MOINS_UN('SUBD_NIVEAU','SUBD_PAS_MINI'),),
+ SUBD_OPTION =SIMP(statut='f',typ='TXM',
+ into =("IGNORE_PREMIERES","GARDE_DERNIERES",),
+ defaut="IGNORE_PREMIERES",
+ fr="Technique d'extrapolation : les 1ere itérations sont ignorées ou les dernières sont gardées"),
+ SUBD_ITER_IGNO =SIMP(statut='c',typ='I',defaut=3,val_min=0,
+ fr="Les n premières itérations sont ignorées pour l'extrapolation"),
+ SUBD_ITER_FIN =SIMP(statut='c',typ='I',defaut=8,val_min=3,
+ fr="Seules les n dernières itérations sont prises pour l'extrapolation"),
+ SUBD_PAS =SIMP(statut='c',typ='I',defaut=4,val_min=2,
+ fr="Nombre de subdivision d'un pas de temps en cas divergence"),
+ SUBD_NIVEAU=SIMP(statut='f',typ='I',val_min=2,
+ fr="Nombre maximum de niveau de subdivision d'un pas de temps"),
+ SUBD_PAS_MINI=SIMP(statut='f',typ='R',val_min=0.0,
+ fr="Pas de temps en dessous duquel on ne subdivise plus"),
+ SUBD_ITER_PLUS =SIMP(statut='c',typ='I',defaut=50,val_min=20,
+ fr="% itération autorisée en plus"),
+ ),
+ # FIN DE BLOC POUR LA SUBDIVISION DES PAS DE TEMPS
OPTI_LIST_INST =SIMP(statut='f',typ='TXM',into=("INCR_MAXI",),),
NOM_CHAM =SIMP(statut='f',typ='TXM',),
NOM_CMP =SIMP(statut='f',typ='TXM',),
PAS_MINI_CRIT =SIMP(statut='f',typ='R',defaut=0.0E+0),
RHO_MIN =SIMP(statut='f',typ='R',defaut=1.0E-2),
RHO_MAX =SIMP(statut='f',typ='R',defaut=1.0E+1),
- RHO_EXCL =SIMP(statut='f',typ='R',defaut=0.9E-2),
+ RHO_EXCL =SIMP(statut='f',typ='R',defaut=0.9E-2,val_min=0.),
),
PILOTAGE =FACT(statut='f',
regles=(EXCLUS('NOEUD','GROUP_NO'),PRESENT_ABSENT('TOUT','GROUP_MA','MAILLE'),),
ITER_GLOB_ELAS =SIMP(statut='f',typ='I',defaut=25),
ARRET =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON")),
),
- PARM_THETA =SIMP(statut='f',typ='R',defaut= 1. ),
SOLVEUR =FACT(statut='d',
METHODE=SIMP(statut='f',typ='TXM',defaut="MULT_FRONT",into=("MULT_FRONT","LDLT","GCPC","MUMPS","FETI") ),
b_mult_front =BLOC(condition = "METHODE == 'MULT_FRONT' ",fr="Paramètres de la méthode multi frontale",
RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
NMAX_ITER =SIMP(statut='f',typ='I',defaut= 0 ),
),
- b_mumps =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
- TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut='AUTO',into=('NONSYM','SYMGEN','SYMDEF','AUTO')),
- PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=20,),
- RESI_RELA =SIMP(statut='f',typ='R',defaut=-1.,),
- ),
+ b_mumps =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
+ TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
+ SCALING =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
+ RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+ PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=80,),
+ RESI_RELA =SIMP(statut='f',typ='R',defaut=-1.0,),
+ ),
b_feti =BLOC(condition = "METHODE == 'FETI' ",fr="Paramètres de la méthode FETI 1",
PARTITION =SIMP(statut='o',typ=sd_feti_sdaster),
RENUM =SIMP(statut='f',typ='TXM',defaut="METIS",into=("MD","MDA","METIS") ),
),
SUIVI_DDL = FACT(statut='f',max=4,
- regles=(UN_PARMI('NOEUD','MAILLE'),
+ regles=(UN_PARMI('NOEUD','MAILLE','GROUP_NO','GROUP_MA','VALE_MIN','VALE_MAX'),
PRESENT_PRESENT('MAILLE','POINT'),),
NUME_SUIVI =SIMP(statut='o',typ='I' ,min=1,max=4),
NOM_CHAM =SIMP(statut='o',typ='TXM',validators=NoRepeat(),max=1,
into=("DEPL","VITE","ACCE","SIEF_ELGA",
"VARI_ELGA","FORC_NODA","DEPL_ABSOLU","VITE_ABSOLU","ACCE_ABSOLU",)),
NOM_CMP =SIMP(statut='o',typ='TXM',max=1 ),
- NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max=1),
- MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max=1),
- POINT =SIMP(statut='f',typ='I' ,validators=NoRepeat(),max=1),
+ NOEUD =SIMP(statut='f',typ=no ,validators=NoRepeat(),max='**'),
+ GROUP_NO =SIMP(statut='f',typ=grno,validators=NoRepeat(),max='**'),
+ MAILLE =SIMP(statut='f',typ=ma ,validators=NoRepeat(),max='**'),
+ GROUP_MA =SIMP(statut='f',typ=grma,validators=NoRepeat(),max='**'),
+ POINT =SIMP(statut='f',typ='I' ,validators=NoRepeat(),max='**'),
+ VALE_MAX =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=1,into=("OUI",) ),
+ VALE_MIN =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=1,into=("OUI",) ),
),
AFFICHAGE = FACT(statut='f',max=16,
NPREC =SIMP(statut='f',typ='I',defaut= 8 ),
STOP_SINGULIER =SIMP(statut='f',typ='TXM',defaut="OUI",into=("OUI","NON") ),
),
- b_mumps =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
- TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut='AUTO',into=('NONSYM','SYMGEN','SYMDEF','AUTO')),
- PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=20,),
- RESI_RELA =SIMP(statut='f',typ='R',defaut=1.E-6,),
+ b_mumps =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
+ TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
+ SCALING =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
+ RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+ PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=80,),
+ RESI_RELA =SIMP(statut='f',typ='R',defaut=-1.0,),
),
b_gcpc =BLOC(condition = "METHODE == 'GCPC' ", fr="Paramètres de la méthode du gradient conjugué",
PRE_COND =SIMP(statut='f',typ='TXM',into=("LDLT_INC",),defaut="LDLT_INC" ),
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
)
-#& MODIF COMMANDE DATE 10/05/2006 AUTEUR MCOURTOI M.COURTOIS
+#& MODIF COMMANDE DATE 17/10/2006 AUTEUR MCOURTOI M.COURTOIS
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
ang="Sensitivity parameter"),
NOM_PARA =SIMP(statut='f',typ='TXM',validators=NoRepeat(),max=2),
VALE_PARA =SIMP(statut='o',typ='R' ,validators=NoRepeat(),max=2),
- VALE_REFE =SIMP(statut='f',typ='R' ),
- VALE_REFE_C =SIMP(statut='f',typ='C' ),
+ VALE_REFE =SIMP(statut='f',typ='R',max='**' ),
+ VALE_REFE_C =SIMP(statut='f',typ='C',max='**' ),
VALE_ABS =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
CRITERE =SIMP(statut='f',typ='TXM',fr="Critère de comparaison avec la solution de référence",
defaut="RELATIF",into=("RELATIF","ABSOLU") ),
TABL_INTSP =FACT(statut='f',max='**',
fr="Tester la valeur d une fonction contenue dans une table interspectrale",
regles=(UN_PARMI('NUME_ORDRE_I','NOEUD_I'),),
- INTE_SPEC =SIMP(statut='o',typ=table_sdaster),
+ INTE_SPEC =SIMP(statut='o',typ=table_fonction),
NOEUD_I =SIMP(statut='f',typ=no),
NUME_ORDRE_I =SIMP(statut='f',typ='I' ),
b_nume_ordre_i = BLOC (condition = "NUME_ORDRE_I != None",
),
NUME_VITE_FLUI =SIMP(statut='f',typ='I' ),
VALE_PARA =SIMP(statut='o',typ='R' ),
- VALE_REFE_C =SIMP(statut='o',typ='C' ),
+ VALE_REFE_C =SIMP(statut='o',typ='C',max='**' ),
CRITERE =SIMP(statut='f',typ='TXM',fr="Critère de comparaison avec la solution de référence",
defaut="RELATIF",into=("RELATIF","ABSOLU") ),
PRECISION =SIMP(statut='f',typ='R',fr="Ecart maximal autorisé avec la solution de référence",
),
),
) ;
-#& MODIF COMMANDE DATE 16/05/2006 AUTEUR REZETTE C.REZETTE
+#& MODIF COMMANDE DATE 10/10/2006 AUTEUR REZETTE C.REZETTE
# RESPONSABLE VABHHTS J.PELLET
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
GROUP_NO =SIMP(statut='f',typ=grno ),
NOM_CMP =SIMP(statut='f',typ='TXM'),
TYPE_TEST =SIMP(statut='f',typ='TXM',into=("SOMM_ABS","SOMM","MAX","MIN")),
- VALE =SIMP(statut='f',typ='R'),
- VALE_I =SIMP(statut='f',typ='I'),
- VALE_C =SIMP(statut='f',typ='C'),
+ VALE =SIMP(statut='f',typ='R',max='**'),
+ VALE_I =SIMP(statut='f',typ='I',max='**'),
+ VALE_C =SIMP(statut='f',typ='C',max='**'),
VALE_ABS =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")),
PRECISION =SIMP(statut='f',typ='R',defaut= 1.0E-3),
GROUP_NO =SIMP(statut='f',typ=grno),
NOM_CMP =SIMP(statut='f',typ='TXM',max='**'),
TYPE_TEST =SIMP(statut='f',typ='TXM',into=("SOMM_ABS","SOMM","MAX","MIN") ),
- VALE =SIMP(statut='f',typ='R' ),
- VALE_I =SIMP(statut='f',typ='I' ),
- VALE_C =SIMP(statut='f',typ='C' ),
+ VALE =SIMP(statut='f',typ='R',max='**' ),
+ VALE_I =SIMP(statut='f',typ='I',max='**' ),
+ VALE_C =SIMP(statut='f',typ='C',max='**' ),
VALE_ABS =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU")),
PRECISION =SIMP(statut='f',typ='R',defaut= 1.0E-3 ),
POINT =SIMP(statut='f',typ='I'),
SOUS_POINT =SIMP(statut='f',typ='I'),
TYPE_TEST =SIMP(statut='f',typ='TXM',into=("SOMM_ABS","SOMM","MAX","MIN")),
- VALE =SIMP(statut='f',typ='R'),
- VALE_I =SIMP(statut='f',typ='I'),
- VALE_C =SIMP(statut='f',typ='C'),
+ VALE =SIMP(statut='f',typ='R',max='**'),
+ VALE_I =SIMP(statut='f',typ='I',max='**'),
+ VALE_C =SIMP(statut='f',typ='C',max='**'),
VALE_ABS =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
CRITERE =SIMP(statut='f',typ='TXM',into=("RELATIF","ABSOLU"),max=2),
PRECISION =SIMP(statut='f',typ='R',max=2),
NUME_ORDRE =SIMP(statut='f',typ='I'),
INST =SIMP(statut='f',typ='R'),
),
- VALE =SIMP(statut='f',typ='R'),
- VALE_I =SIMP(statut='f',typ='I'),
- VALE_C =SIMP(statut='f',typ='C'),
+ VALE =SIMP(statut='f',typ='R',max='**'),
+ VALE_I =SIMP(statut='f',typ='I',max='**'),
+ VALE_C =SIMP(statut='f',typ='C',max='**'),
VALE_ABS =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
CRITERE =SIMP(statut='f',typ='TXM',into=("RELATIF","ABSOLU"),max=2),
PRECISION =SIMP(statut='f',typ='R',max=2),
VERSION =SIMP(statut='f',typ='TXM' ),
),
) ;
-#& MODIF COMMANDE DATE 10/05/2006 AUTEUR MCOURTOI M.COURTOIS
+#& MODIF COMMANDE DATE 10/10/2006 AUTEUR REZETTE C.REZETTE
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
"NON_VIDE","MAXI","ABS_MAXI","MINI","ABS_MINI") ),
b_vale =BLOC(condition = "(CRIT_COMP in ('EQ','NE','GT','LT','GE','LE'))",
regles=(UN_PARMI('VALE','VALE_I','VALE_K','VALE_C',),),
- VALE =SIMP(statut='f',typ='R' ),
- VALE_I =SIMP(statut='f',typ='I' ),
- VALE_C =SIMP(statut='f',typ='C' ),
+ VALE =SIMP(statut='f',typ='R',),
+ VALE_I =SIMP(statut='f',typ='I',),
+ VALE_C =SIMP(statut='f',typ='C',),
VALE_K =SIMP(statut='f',typ='TXM' ),),
CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
),
TYPE_TEST =SIMP(statut='f',typ='TXM',into=("SOMM_ABS","SOMM","MAX","MIN") ),
NOM_PARA =SIMP(statut='o',typ='TXM' ),
- VALE =SIMP(statut='f',typ='R' ),
- VALE_I =SIMP(statut='f',typ='I' ),
- VALE_C =SIMP(statut='f',typ='C' ),
+ VALE =SIMP(statut='f',typ='R',max='**' ),
+ VALE_I =SIMP(statut='f',typ='I',max='**' ),
+ VALE_C =SIMP(statut='f',typ='C',max='**' ),
VALE_ABS =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON") ),
CRITERE =SIMP(statut='f',typ='TXM',defaut="RELATIF",into=("RELATIF","ABSOLU") ),
PRECISION =SIMP(statut='f',typ='R',defaut= 1.2E-3 ),
INFO =SIMP(statut='f',typ='I',defaut=1,into=(1,2) ),
),
) ;
-#& MODIF COMMANDE DATE 10/05/2006 AUTEUR MCOURTOI M.COURTOIS
+#& MODIF COMMANDE DATE 12/06/2006 AUTEUR BOITEAU O.BOITEAU
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
RESI_RELA =SIMP(statut='f',typ='R',defaut= 1.E-6 ),
NMAX_ITER =SIMP(statut='f',typ='I',defaut= 0 ),
),
- b_mumps =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
- TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut='AUTO',into=('NONSYM','SYMGEN','SYMDEF','AUTO')),
- PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=20,),
+ b_mumps =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
+ TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
+ SCALING =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
+ RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+ PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=80,),
RESI_RELA =SIMP(statut='f',typ='R',defaut=1.E-6,),
- ),
+ ),
),
PARM_THETA =SIMP(statut='f',typ='R',defaut= 0.57),
ARCHIVAGE =FACT(statut='f',
TITRE =SIMP(statut='f',typ='TXM',max='**'),
INFO =SIMP(statut='f',typ='I',into=(1,2)),
) ;
-#& MODIF COMMANDE DATE 10/05/2006 AUTEUR MCOURTOI M.COURTOIS
+#& MODIF COMMANDE DATE 19/06/2006 AUTEUR BOITEAU O.BOITEAU
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2001 EDF R&D WWW.CODE-ASTER.ORG
RESI_RELA =SIMP(statut='f',typ='R' ,defaut= 1.E-6 ),
NMAX_ITER =SIMP(statut='f',typ='I' ,defaut= 0 ),
),
- b_mumps =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
- TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut='AUTO',into=('NONSYM','SYMGEN','SYMDEF','AUTO')),
- PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=20,),
- RESI_RELA =SIMP(statut='f',typ='R',defaut=-1.,),
- ),
+ b_mumps =BLOC(condition = "METHODE == 'MUMPS' ",fr="Paramètres de la méthode MUMPS",
+ TYPE_RESOL =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("NONSYM","SYMGEN","SYMDEF","AUTO")),
+ SCALING =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("SANS","AUTO")),
+ RENUM =SIMP(statut='f',typ='TXM',defaut="AUTO",into=("AMD","AMF","PORD","METIS","QAMD","AUTO")),
+ PCENT_PIVOT =SIMP(statut='f',typ='I',defaut=80,),
+ RESI_RELA =SIMP(statut='f',typ='R',defaut=-1.0,),
+ ),
SYME =SIMP(statut='f',typ='TXM',defaut="NON",into=("OUI","NON",) ),
),
PARM_THETA =SIMP(statut='f',typ='R',defaut= 0.57 ),
-#@ MODIF ops Cata DATE 08/11/2005 AUTEUR D6BHHJP J.P.LEFEBVRE
+#@ MODIF ops Cata DATE 24/10/2006 AUTEUR DURAND C.DURAND
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
print nomres,concep,nomcmd,statut
if nomres[0] not in (' ','.','&') and statut != '&DETRUIT':
exec nomres+'='+string.lower(concep)+'()' in self.parent.g_context,d
+ elif statut == '&DETRUIT' : self.jdc.nsd = self.jdc.nsd+1
pos=pos+80
for k,v in d.items():
self.parent.NommerSdprod(v,k)
for elem in pickle_context.keys():
if type(pickle_context[elem])==types.InstanceType :
pickle_class=pickle_context[elem].__class__
+ # on rattache chaque assd au nouveau jdc courant (en poursuite)
+ if isinstance(pickle_context[elem],ASSD) :
+ pickle_context[elem].jdc=self.jdc
+ pickle_context[elem].parent=self.jdc
if elem in self.g_context.keys():
poursu_class=self.g_context[elem].__class__
if poursu_class!=pickle_class :
# On lit le fichier et on supprime les éventuels \r
text=string.replace(open(f).read(),'\r\n','\n')
# On effectue les substitutions necessaires
- self.prefix=NOM_MATER
self.text= subst_materiau(text,NOM_MATER,EXTRACTION,UNITE_LONGUEUR)
if INFO == 2:
print "INCLUDE_MATERIAU: ", self.mat,' ',NOM_MATER,'\n'
+++ /dev/null
-#@ MODIF ops Cata DATE 08/11/2005 AUTEUR D6BHHJP J.P.LEFEBVRE
-# -*- coding: iso-8859-1 -*-
-# CONFIGURATION MANAGEMENT OF EDF VERSION
-# ======================================================================
-# COPYRIGHT (C) 1991 - 2001 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.
-# ======================================================================
-
-
-# Modules Python
-import types
-import string,linecache,os,traceback,re
-import pickle
-
-# Modules Eficas
-import Accas
-from Accas import ASSD
-from Utilitai.Utmess import UTMESS
-
-try:
- import aster
- # Si le module aster est présent, on le connecte
- # au JDC
- import Build.B_CODE
- Build.B_CODE.CODE.codex=aster
-except:
- pass
-
-def DEBUT(self,PAR_LOT,IMPR_MACRO,CODE,DEBUG,**args):
- """
- Fonction sdprod de la macro DEBUT
- """
- # La commande DEBUT ne peut exister qu'au niveau jdc
- if self.jdc is not self.parent :
- raise Accas.AsException("La commande DEBUT ne peut exister qu'au niveau jdc")
-
- self.jdc.impr_macro=IMPR_MACRO
- self.jdc.jxveri=0
- if DEBUG!=None :
- if DEBUG['JXVERI']=='OUI' : self.jdc.jxveri=1
- self.jdc.set_par_lot(PAR_LOT)
- if CODE!=None :
- self.jdc.fico=CODE['NOM']
- else:
- self.jdc.fico=None
-
-def build_debut(self,**args):
- """
- Fonction ops pour la macro DEBUT
- """
- self.jdc.UserError=self.codex.error
-
- if self.jdc.par_lot == 'NON' :
- self.jdc._Build()
- # On execute la fonction debut pour initialiser les bases
- # Cette execution est indispensable avant toute autre action sur ASTER
- # op doit etre un entier car la fonction debut appelle GCECDU qui demande
- # le numero de l'operateur associé (getoper)
- self.definition.op=0
- self.set_icmd(1)
- lot,ier=self.codex.debut(self,1)
- # On remet op a None juste apres pour eviter que la commande DEBUT
- # ne soit executée dans la phase d'execution
- self.definition.op=None
- return ier
-
-def POURSUITE(self,PAR_LOT,IMPR_MACRO,CODE,DEBUG,**args):
- """
- Fonction sdprod de la macro POURSUITE
- """
- # La commande POURSUITE ne peut exister qu'au niveau jdc
- if self.jdc is not self.parent :
- raise Accas.AsException("La commande POURSUITE ne peut exister qu'au niveau jdc")
-
- self.jdc.impr_macro=IMPR_MACRO
- self.jdc.set_par_lot(PAR_LOT)
- self.jdc.jxveri=0
- if DEBUG!=None :
- if DEBUG['JXVERI']=='OUI' : self.jdc.jxveri=1
- if CODE!=None :
- self.jdc.fico=CODE['NOM']
- else:
- self.jdc.fico=None
- if (self.codex and os.path.isfile("glob.1") or os.path.isfile("bhdf.1")):
- # Le module d'execution est accessible et glob.1 est present
- # Pour eviter de rappeler plusieurs fois la sequence d'initialisation
- # on memorise avec l'attribut fichier_init que l'initialisation
- # est réalisée
- if hasattr(self,'fichier_init'):return
- self.fichier_init='glob.1'
- self.jdc.initexec()
- # le sous programme fortran appelé par self.codex.poursu demande le numero
- # de l'operateur (GCECDU->getoper), on lui donne la valeur 0
- self.definition.op=0
- lot,ier,lonuti,concepts=self.codex.poursu(self,1)
- # Par la suite pour ne pas executer la commande pendant la phase
- # d'execution on le remet à None
- self.definition.op=None
- # On demande la numerotation de la commande POURSUITE avec l'incrément
- # lonuti pour qu'elle soit numérotée à la suite des commandes existantes.
-####CD self.set_icmd(lonuti)
- pos=0
- d={}
- while pos+80 < len(concepts)+1:
- nomres=concepts[pos:pos+8]
- concep=concepts[pos+8:pos+24]
- nomcmd=concepts[pos+24:pos+40]
- statut=concepts[pos+40:pos+48]
- print nomres,concep,nomcmd,statut
- if nomres[0] not in (' ','.','&') and statut != '&DETRUIT':
- exec nomres+'='+string.lower(concep)+'()' in self.parent.g_context,d
- pos=pos+80
- for k,v in d.items():
- self.parent.NommerSdprod(v,k)
- self.g_context=d
-
- # Il peut exister un contexte python sauvegardé sous forme pickled
- # On récupère ces objets après la restauration des concepts pour que
- # la récupération des objets pickled soit prioritaire.
- # On vérifie que les concepts relus dans glob.1 sont bien tous
- # presents sous le meme nom et du meme type dans pick.1
- # Le contexte est ensuite updaté (surcharge) et donc enrichi des
- # variables qui ne sont pas des concepts.
- # On supprime du pickle_context les concepts valant None, ca peut
- # etre le cas des concepts non executés, placés après FIN.
- pickle_context=get_pickled_context()
- if pickle_context==None :
- UTMESS('F','Poursuite',"Erreur a la relecture du fichier pick.1 : aucun objet sauvegardé ne sera récupéré")
- return
- from Cata.cata import ASSD,entier
- from Noyau.N_CO import CO
- for elem in pickle_context.keys():
- if type(pickle_context[elem])==types.InstanceType :
- pickle_class=pickle_context[elem].__class__
- if elem in self.g_context.keys():
- poursu_class=self.g_context[elem].__class__
- if poursu_class!=pickle_class :
- UTMESS('F','Poursuite',"Types incompatibles entre glob.1 et pick.1 pour concept de nom "+elem)
- return
- elif isinstance(pickle_context[elem],ASSD) and pickle_class not in (CO,entier) :
- # on n'a pas trouvé le concept dans la base et sa classe est ASSD : ce n'est pas normal
- # sauf dans le cas de CO : il n'a alors pas été typé et c'est normal qu'il soit absent de la base
- # meme situation pour le type 'entier' produit uniquement par DEFI_FICHIER
- UTMESS('F','Poursuite',"Concept de nom "+elem+" et de type "+str(pickle_class)+" introuvable dans la base globale")
- return
- if pickle_context[elem]==None : del pickle_context[elem]
- self.g_context.update(pickle_context)
- return
-
- else:
- # Si le module d'execution n est pas accessible ou glob.1 absent on
- # demande un fichier (EFICAS)
- # Il faut éviter de réinterpréter le fichier à chaque appel de
- # POURSUITE
- if hasattr(self,'fichier_init'):
- return
- self.make_poursuite()
-
-def get_pickled_context():
- """
- Cette fonction permet de réimporter dans le contexte courant du jdc (jdc.g_context)
- les objets python qui auraient été sauvegardés, sous forme pickled, lors d'une
- précédente étude. Un fichier pick.1 doit etre présent dans le répertoire de travail
- """
- if os.path.isfile("pick.1"):
- file="pick.1"
- else: return None
-
- # Le fichier pick.1 est présent. On essaie de récupérer les objets python sauvegardés
- context={}
- try:
- file=open(file,'r')
- # Le contexte sauvegardé a été picklé en une seule fois. Il est seulement
- # possible de le récupérer en bloc. Si cette opération echoue, on ne récupère
- # aucun objet.
- context=pickle.load(file)
- file.close()
- except:
- # En cas d'erreur on ignore le contenu du fichier
- # traceback.print_exc()
- return None
-
- return context
-
-def POURSUITE_context(self,d):
- """
- Fonction op_init de la macro POURSUITE
- """
- # self représente la macro POURSUITE ...
- d.update(self.g_context)
- # Une commande POURSUITE n'est possible qu'au niveau le plus haut
- # On ajoute directement les concepts dans le contexte du jdc
- # XXX est ce que les concepts ne sont pas ajoutés plusieurs fois ??
- for v in self.g_context.values():
- if isinstance(v,ASSD) : self.jdc.sds.append(v)
-
-def build_poursuite(self,**args):
- """
- Fonction ops pour la macro POURSUITE
- """
- # Pour POURSUITE on ne modifie pas la valeur initialisee dans ops.POURSUITE
- # Il n y a pas besoin d executer self.codex.poursu (c'est deja fait dans
- # la fonction sdprod de la commande (ops.POURSUITE))
- self.set_icmd(1)
- self.jdc.UserError=self.codex.error
- return 0
-
-def INCLUDE(self,UNITE,**args):
- """
- Fonction sd_prod pour la macro INCLUDE
- """
- if not UNITE : return
- if hasattr(self,'unite'):return
- self.unite=UNITE
-
- if self.jdc and self.jdc.par_lot == 'NON':
- # On est en mode commande par commande, on appelle la methode speciale
- self.Execute_alone()
-
- self.make_include(unite=UNITE)
-
-def INCLUDE_context(self,d):
- """
- Fonction op_init pour macro INCLUDE
- """
- for k,v in self.g_context.items():
- d[k]=v
-
-def build_include(self,**args):
- """
- Fonction ops de la macro INCLUDE appelée lors de la phase de Build
- """
- # Pour presque toutes les commandes (sauf FORMULE et POURSUITE)
- # le numero de la commande n est pas utile en phase de construction
- # La macro INCLUDE ne sera pas numérotée (incrément=None)
- ier=0
- self.set_icmd(None)
- icmd=0
- # On n'execute pas l'ops d'include en phase BUILD car il ne sert a rien.
- #ier=self.codex.opsexe(self,icmd,-1,1)
- return ier
-
-def detruire(self,d):
- """
- Cette fonction est la fonction op_init de la PROC DETRUIRE
- """
- if self["CONCEPT"]!=None:
- sd=[]
- for mc in self["CONCEPT"]:
- mcs=mc["NOM"]
- if mcs is None:continue
- if type(mcs) == types.ListType or type(mcs) == types.TupleType:
- for e in mcs:
- if isinstance(e,ASSD):
- sd.append(e)
- e=e.nom
- # traitement particulier pour les listes de concepts, on va mettre à None
- # le terme de l'indice demandé dans la liste :
- # nomconcept_i est supprimé, nomconcept[i]=None
- indice=e[e.rfind('_')+1:]
- concept_racine=e[:e.rfind('_')]
- if indice!='' and d.has_key(concept_racine) and type(d[concept_racine])==types.ListType:
- try :
- indici=int(indice)
- d[concept_racine][indici]=None
- except ValueError : pass
- # pour tous les concepts :
- if d.has_key(e):del d[e]
- if self.jdc.sds_dict.has_key(e):del self.jdc.sds_dict[e]
- else:
- if isinstance(mcs,ASSD):
- sd.append(mcs)
- mcs=mcs.nom
- # traitement particulier pour les listes de concepts, on va mettre à None
- # le terme de l'indice demandé dans la liste :
- # nomconcept_i est supprimé, nomconcept[i]=None
- indice=mcs[mcs.rfind('_')+1:]
- concept_racine=mcs[:mcs.rfind('_')]
- if indice!='' and d.has_key(concept_racine) and type(d[concept_racine])==types.ListType:
- try :
- indici=int(indice)
- d[concept_racine][indici]=None
- except ValueError : pass
- # pour tous les concepts :
- if d.has_key(mcs):del d[mcs]
- if self.jdc.sds_dict.has_key(mcs):del self.jdc.sds_dict[mcs]
- for s in sd:
- # On signale au parent que le concept s n'existe plus apres l'étape self
- self.parent.delete_concept_after_etape(self,s)
-
-def subst_materiau(text,NOM_MATER,EXTRACTION,UNITE_LONGUEUR):
- """
- Cette fonction retourne un texte obtenu à partir du texte passé en argument (text)
- en substituant le nom du materiau par NOM_MATER
- et en réalisant les extractions spéciifées dans EXTRACTION
- """
- lines=string.split(text,'\n')
-
-##### traitement de UNIT : facteur multiplicatif puissance de 10
- regmcsu=re.compile(r" *(.*) *= *([^ ,]*) *## +([^ ]*) *([^ ]*)")
- ll_u=[]
- for l in lines:
- m=regmcsu.match(l)
- if m:
- if m.group(3) == "UNIT":
- if UNITE_LONGUEUR=='M' : coef = '0'
- elif UNITE_LONGUEUR=='MM' : coef = m.group(4)
- ll_u.append(m.group(1)+" = "+m.group(2)+coef)
- else : ll_u.append(l)
- else : ll_u.append(l)
-
-##### traitement de EXTRACTION
- if EXTRACTION:
- regmcf=re.compile(r" *(.*) *= *_F\( *## +(.*) +(.*)")
- regmcs=re.compile(r" *(.*) *= *([^ ,]*) *, *## +([^ ]*) *([^ ]*)")
- regfin=re.compile(r" *\) *")
- ll=[]
- temps={};lmcf=[]
- for e in EXTRACTION:
- mcf=e['COMPOR']
- lmcf.append(mcf)
- temps[mcf]=e['TEMP_EVAL']
- FLAG=0
- for l in ll_u:
- m=regmcf.match(l)
- if m: # On a trouve un mot cle facteur "commentarise"
- if m.group(2) == "SUBST": # il est de plus substituable
- if temps.has_key(m.group(3)): # Il est a substituer
- ll.append(" "+m.group(3)+"=_F(")
- mcf=m.group(3)
- TEMP=temps[mcf]
- FLAG=1 # Indique que l'on est en cours de substitution
- else: # Il n est pas a substituer car il n est pas dans la liste demandee
- ll.append(l)
- else: # Mot cle facteur commentarise non substituable
- ll.append(l)
- else: # La ligne ne contient pas un mot cle facteur commentarise
- if FLAG == 0: # On n est pas en cours de substitution
- ll.append(l)
- else: # On est en cours de substitution. On cherche les mots cles simples commentarises
- m=regmcs.match(l)
- if m: # On a trouve un mot cle simple commentarise
- if m.group(3) == "EVAL":
- ll.append(" "+m.group(1)+' = '+m.group(4)+"("+str(TEMP)+'),')
- elif m.group(3) == "SUPPR":
- pass
- else:
- ll.append(l)
- else: # On cherche la fin du mot cle facteur en cours de substitution
- m=regfin.match(l)
- if m: # On l a trouve. On le supprime de la liste
- FLAG=0
- del temps[mcf]
- ll.append(l)
- else:
- ll=ll_u
-
- lines=ll
- ll=[]
- for l in lines:
- l=re.sub(" *MAT *= *",NOM_MATER+" = ",l,1)
- ll.append(l)
- text=string.join(ll,'\n')
- return text
-
-def post_INCLUDE(self):
- """
- Cette fonction est executée apres toutes les commandes d'un INCLUDE (RETOUR)
- Elle sert principalement pour les INCLUDE_MATERIAU : remise a blanc du prefixe Fortran
- """
- self.codex.opsexe(self,0,-1,2)
-
-def INCLUDE_MATERIAU(self,NOM_AFNOR,TYPE_MODELE,VARIANTE,TYPE_VALE,NOM_MATER,
- EXTRACTION,UNITE_LONGUEUR,INFO,**args):
- """
- Fonction sd_prod pour la macro INCLUDE_MATERIAU
- """
- mat=string.join((NOM_AFNOR,'_',TYPE_MODELE,'_',VARIANTE,'.',TYPE_VALE),'')
- if not hasattr(self,'mat') or self.mat != mat or self.nom_mater != NOM_MATER :
- # On récupère le répertoire des matériaux dans les arguments
- # supplémentaires du JDC
- rep_mat=self.jdc.args.get("rep_mat","NOrep_mat")
- f=os.path.join(rep_mat,mat)
- self.mat=mat
- self.nom_mater=NOM_MATER
- if not os.path.isfile(f):
- del self.mat
- self.make_contexte(f,"#Texte sans effet pour reinitialiser le contexte a vide\n")
- raise "Erreur sur le fichier materiau: "+f
- # Les materiaux sont uniquement disponibles en syntaxe Python
- # On lit le fichier et on supprime les éventuels \r
- text=string.replace(open(f).read(),'\r\n','\n')
- # On effectue les substitutions necessaires
- self.prefix=NOM_MATER
- self.text= subst_materiau(text,NOM_MATER,EXTRACTION,UNITE_LONGUEUR)
- if INFO == 2:
- print "INCLUDE_MATERIAU: ", self.mat,' ',NOM_MATER,'\n'
- print self.text
- # on execute le texte fourni dans le contexte forme par
- # le contexte de l etape pere (global au sens Python)
- # et le contexte de l etape (local au sens Python)
- # Il faut auparavant l'enregistrer aupres du module linecache (utile pour nommage.py)
- linecache.cache[f]=0,0,string.split(self.text,'\n'),f
-
- self.postexec=post_INCLUDE
-
- if self.jdc.par_lot == 'NON':
- # On est en mode commande par commande, on appelle la methode speciale
- self.Execute_alone()
-
- self.make_contexte(f,self.text)
- for k,v in self.g_context.items() :
- if isinstance(v,ASSD) and k!=v.nom : del self.g_context[k]
-
-def build_procedure(self,**args):
- """
- Fonction ops de la macro PROCEDURE appelée lors de la phase de Build
- """
- ier=0
- # Pour presque toutes les commandes (sauf FORMULE et POURSUITE)
- # le numero de la commande n est pas utile en phase de construction
- # On ne numérote pas une macro PROCEDURE (incrément=None)
- self.set_icmd(None)
- icmd=0
- #ier=self.codex.opsexe(self,icmd,-1,3)
- return ier
-
-def build_DEFI_FICHIER(self,**args):
- """
- Fonction ops de la macro DEFI_FICHIER
- """
- ier=0
- self.set_icmd(1)
- icmd=0
- ier=self.codex.opsexe(self,icmd,-1,26)
- return ier
+Version 1.11 (12/2006):
+ Mise en synchronisation avec la version 8.4 de Code_Aster de decembre 2006.
+ Première version du Traducteur de V7 en V8
+
Version 1.10 (6/2006):
Mise en synchronisation avec la version 8.3 de Code_Aster de juin 2006.
copyfiles('.',path_distrib,['LICENSE.TERMS','INSTALL'])
copyfiles('../Editeur',os.path.join(path_distrib,'Editeur'),['*.py','faqs.txt'])
+ copyfiles('../Traducteur',os.path.join(path_distrib,'Traducteur'),['*.py'])
copyfiles('../Ihm',os.path.join(path_distrib,'Ihm'),['*.py'])
copyfiles('../Extensions',os.path.join(path_distrib,'Extensions'),['*.py'])
copyfiles('../Misc',os.path.join(path_distrib,'Misc'),['*.py'])
catalogues = (
# ('ASTER','v5.9',os.path.join(rep_cata,'cataSTA5'),'asterv5'),
# ('ASTER','v6.8',os.path.join(rep_cata,'cataSTA6'),'python6'),
-# ('ASTER','v7.7',os.path.join(rep_cata,'cataSTA7'),'python'),
- ('ASTER','v8.3',os.path.join(rep_cata,'cataSTA8'),'python','defaut'),
+ ('ASTER','v7.7',os.path.join(rep_cata,'cataSTA7'),'python'),
+# ('ASTER','v8.4',os.path.join(rep_cata,'cataSTA8'),'python'),
+ ('ASTER','v8',os.path.join(rep_cata,'cataSTA8'),'python','defaut'),
)
encoding='iso-8859-1'
labels= ('Fichier','Edition','Jeu de commandes',
-# 'Catalogue','Browsers',
'Options',
'Aide',
+ 'Traduction',
)
appli_composants=['readercata','bureau',
#('Paramètres Eficas','affichage_fichier_ini'),
]
),
+ ('Traduction',[
+ ('Traduction v7 en v8','TraduitFichier','<Control-t>','Ctrl+T'),
+ ]
+ ),
('Aide',[
('Aide EFICAS','aideEFICAS','<Control-a>','Ctrl+A'),
]
copyfiles('.',path_distrib,['LICENSE.TERMS','INSTALL','NEWS'])
copyfiles('../Editeur',os.path.join(path_distrib,'Editeur'),['*.py','faqs.txt'])
+ copyfiles('../Traducteur',os.path.join(path_distrib,'Traducteur'),['*.py'])
copyfiles('../Ihm',os.path.join(path_distrib,'Ihm'),['*.py'])
copyfiles('../Extensions',os.path.join(path_distrib,'Extensions'),['*.py'])
copyfiles('../Misc',os.path.join(path_distrib,'Misc'),['*.py'])
copyfiles('../Aster',os.path.join(path_distrib,'Aster'),['prefs.py',
'editeur.ini',
'eficas_aster.py',
+ 'test_eficas.py',
'style.py'
])
copyfiles('Cata/Utilitai',os.path.join(path_distrib,'Aster','Cata','Utilitai'),['*.py'])
copyfiles(os.path.join(path_Noyau,'Noyau'),os.path.join(path_distrib,'Noyau'),['*.py'])
copyfiles(os.path.join(path_Noyau,'Validation'),os.path.join(path_distrib,'Validation'),['*.py'])
copyfiles(os.path.join(path_Noyau,'Accas'),os.path.join(path_distrib,'Aster'),['properties.py'])
- copyfiles(os.path.join(path_Noyau,'Cata'),os.path.join(path_distrib,'Aster','Cata'),['*.py',])
+ copyfiles(os.path.join(path_Noyau,'Cata'),os.path.join(path_distrib,'Aster','Cata'),['__init__.py',])
copyfiles(os.path.join(path_Noyau,'Macro'),os.path.join(path_distrib,'Aster','Cata','cataSTA8','Macro'),['*.py'])
os.system("mv "+path_distrib+"/Aster/Cata/cata_STA8.py "+path_distrib+"/Aster/Cata/cataSTA8/cata.py")
copyfiles('../Pmw',os.path.join(path_distrib,'Pmw'),['*.py'])
copyfiles('../Pmw/Pmw_1_2',os.path.join(path_distrib,'Pmw','Pmw_1_2'),['*.py'])
copyfiles('../Pmw/Pmw_1_2/lib',os.path.join(path_distrib,'Pmw','Pmw_1_2','lib'),['*.py','Pmw.def'])
- copyfiles('Cata',os.path.join(path_distrib,'Aster','Cata'),['ops.py'])
+ #copyfiles('Cata',os.path.join(path_distrib,'Aster','Cata'),['ops.py'])
tarball= maketarball('dist',nom_distrib,nom_distrib)
import listeFichiers
import listePatrons
-VERSION="EFICAS v1.10"
+VERSION="EFICAS v1.11"
class APPLI:
def __init__ (self,master,code=prefs.code,fichier=None,test=0) :
self.top.minsize(900,500)
self.top.geometry("900x500")
self.top.title(VERSION + ' pour '+self.code)
+ self.titre=VERSION + ' pour '+self.code
self.top.withdraw()
self.initializeTk(master)
Pmw.initialise(master)
self.liste_simp_reel=[]
# L'attribut test doit valoir 1 si on ne veut pas creer les fenetres
self.test=1
+ self.titre="STANDALONE POUR TEST"
# Lecture des parametres de configuration (fichier global editeur.ini
# et utilisateur eficas.ini)
import convert
import generator
import AIDE
+import os
from jdcdisplay import JDCDISPLAY
from utils import extension_fichier,stripPath,save_in_file
-from widgets import Fenetre,Ask_Format_Fichier
+from widgets import Fenetre,Ask_Format_Fichier,FenetreSurLigneWarning
from fenetre_mc_inconnus import fenetre_mc_inconnus
from Ihm import CONNECTOR
+from Traducteur import traduitV7V8
import comploader
('Mots-clés inconnus','mc_inconnus'),
]
),
+ ('Traduction',[
+ ('Traduction v7 en v8','TraduitFichier','<Control-t>','Ctrl+T')
+ ]
+ ),
('Aide',[
('Aide EFICAS','aideEFICAS'),
]
"""
if mode == 'JDC':
if not hasattr(self,'JDC') : return
+ if self.JDC == None : return
titre="rapport de validation du jeu de commandes courant"
cr = self.JDC.report()
#self.update_jdc_courant()
def update_jdc_courant(self):
self.JDCDisplay_courant.update()
+ def TraduitFichier(self):
+ directory = self.appli.CONFIGURATION.rep_user
+ FichieraTraduire = askopenfilename(title="Nom du Fichier à Traduire",
+ defaultextension=".comm",
+ initialdir = directory
+ )
+ if (FichieraTraduire == "" or FichieraTraduire == () ) : return
+ i=FichieraTraduire.rfind(".")
+ Feuille=FichieraTraduire[0:i]
+ FichierTraduit=Feuille+"v8.comm"
+ os.system("rm -rf /tmp/convert.log")
+ Pmw.showbusycursor()
+ traduitV7V8.traduc(FichieraTraduire,FichierTraduit)
+ Pmw.hidebusycursor()
+ Entete="Fichier Traduit : "+FichierTraduit +"\n\n"
+ titre = "conversion de "+ FichieraTraduire
+
+ if os.stat("/tmp/convert.log")[6] != 0L :
+ f=open('/tmp/convert.log')
+ texte_cr= f.read()
+ f.close()
+ else :
+ texte_cr = Entete + "Pas d information de conversion \n"
+ commande="diff "+FichieraTraduire+" "+FichierTraduit+" >/dev/null"
+ try :
+ if os.system(commande) == 0 :
+ texte_cr = texte_cr + "Pas de difference entre le fichier V7 et le fichier traduit"
+ except :
+ pass
+
+ cptrendu = FenetreSurLigneWarning(self.appli,titre=titre,texte=texte_cr)
+
#
__version__="$Name: $"
-__Id__="$Id: compomacro.py,v 1.24 2005/11/03 09:03:48 eficas Exp $"
+__Id__="$Id: compomacro.py,v 1.25.10.1 2006/11/15 17:59:30 cchris Exp $"
#
class MACROPanel(panels.OngletPanel):
#print "makeEdit",self.object,self.object.nom
#print "makeEdit",self.object.jdc_aux,self.object.jdc_aux.nom
#print "makeEdit",self.object.jdc_aux.context_ini
+ if self.object.text_converted == 0:
+ # Le texte du fichier inclus n'a pas pu etre converti par le module convert
+ msg="Le fichier de commande n'a pas pu etre converti pour etre editable par Eficas\n\n"
+ msg=msg+self.object.text_error
+ Fenetre(self,titre="Include non editable",texte=msg,wrap='none')
+ return
+
if not hasattr(self.object,"jdc_aux") or self.object.jdc_aux is None:
#L'include n'est pas initialise
self.object.build_include(None,"")
+
# On cree un nouvel onglet dans le bureau
appli.bureau.ShowJDC(self.object.jdc_aux,self.object.jdc_aux.nom,
label_onglet=None,
def makeView(self,appli,node):
if not hasattr(self.object,"jdc_aux") or self.object.jdc_aux is None:
- showerror("Include vide","L'include doit etre correctement initialisé pour etre visualisé")
+ showerror("Include vide",
+ "L'include doit etre correctement initialisé pour etre visualisé")
return
+
nom=self.object.nom
if hasattr(self.object,'fichier_ini'):
if self.object.fichier_ini is None:
class POURSUITETreeItem(INCLUDETreeItemBase):
def makeEdit(self,appli,node):
+ if self.object.text_converted == 0:
+ # Le texte du fichier inclus n'a pas pu etre converti par le module convert
+ msg="Le fichier de commande n'a pas pu etre converti pour etre editable par Eficas\n\n"
+ msg=msg+self.object.text_error
+ Fenetre(self,titre="Poursuite non editable",texte=msg,wrap='none')
+ return
+
if not hasattr(self.object,"jdc_aux") or self.object.jdc_aux is None:
#La poursuite n'est pas initialisee
text="""DEBUT()
FIN()"""
self.object.build_poursuite(None,text)
+
# On cree un nouvel onglet dans le bureau
appli.bureau.ShowJDC(self.object.jdc_aux,self.object.jdc_aux.nom,
label_onglet=None,
self.clef_fonction="SALOME"
for i in range(0,len( genea )) :
self.clef_fonction=self.clef_fonction+"_"+ genea[i]
- if genea[i] == "GROUP_NO" or genea[i] == "GROUP_MA":
- self.select_noeud_maille=1
+ #if genea[i] == "GROUP_NO" or genea[i] == "GROUP_MA":
+ if "GROUP_NO" in genea[len(genea)-1] or "GROUP_MA" in genea[len(genea)-1]:
+ self.select_noeud_maille=1
recherche=panelsSalome.dict_classes_salome[self.panel]
if hasattr(recherche,self.clef_fonction):
def valide_item(self,item):
"""
- On fait un try except pour les erreurs de type (exple
- on rentre 1 pour une chaine de caracteres
+ La validation est réalisée directement par l'objet
"""
- valide=1
- if self.definition.validators :
- try :
- valide=self.definition.validators.verif_item(item)
- except :
- valide = 0
- return valide
+ return self.object.valide_item(item)
def valide_liste_partielle(self,item,listecourante):
#On protege la liste en entree en la copiant
Retourne 1 si la valeur est dans l'intervalle permis par
l'objet représenté par l'item.
"""
- return self.object.isinintervalle(valeur)
+ return self.valide_item(valeur)
def isvalid(self):
valide=self.object.isvalid()
self.nom_jdc=nom_jdc
self.appli=appli
self.barre=Tkinter.Frame(self.fenetre,relief="ridge",bd=2)
- self.barre.pack(expand=1,fill=Tkinter.X)
+ self.barre.pack(expand=0,fill=Tkinter.X)
if self.macroitem.object.fichier_text is not None:
b=Tkinter.Button(self.barre,image=images.get_image("Zoom24"),command=self.visufile)
b.pack(side='left')
try:
from prefs import labels
except:
- labels= ('Fichier','Edition','Jeu de commandes','Catalogue','Browsers','Options','Aide')
+ labels= ('Fichier','Edition','Jeu de commandes','Catalogue','Options','Aide','Traducteur')
def init(self):
self.menudict={}
def __init__(self,parent,panneau,node):
PLUSIEURS_BASE_Panel.__init__( self, parent, panneau, node )
- self.selected_valeur = None
+ #self.selected_valeur = None
def add_valeur_plusieurs_base(self,name=None):
try:
valeur,validite,commentaire=self.get_valeur()
- #print 'add_valeur_plusieurs_base', name
- #print 'valeur = %s, validite = %s,commentaire = %s'%( valeur,validite,commentaire )
if not valeur: # sélection dans salome
- #print 'CS_pbruno selection SALOME'
strSelection = ''
- selection, msg = self.parent.appli.selectGroupFromSalome()
-
- #print 'CS_pbruno selection SALOME selection ->',selection
- #print 'CS_pbruno selection SALOME msg ->',msg
-
+ genea=self.node.item.get_genealogie()
+ kwType = None
+ for e in genea:
+ if "GROUP_NO" in e:
+ kwType = "GROUP_NO"
+ if "GROUP_MA" in e:
+ kwType = "GROUP_MA"
+
+ selection, msg = self.parent.appli.selectGroupFromSalome(kwType)
if selection:
for oneSelection in selection:
strSelection +=str( oneSelection )
strSelection +=','
strSelection = strSelection.rstrip(',')
- #print 'CS_pbruno selection SALOME strSelection ->',strSelection
-
self.display_valeur( strSelection )
PLUSIEURS_BASE_Panel.add_valeur_plusieurs_base( self, name )
else:
showerror("Pas de Fichier MED","Cet Objet n a pas de fichier MED Associ\xe9")
if FileName != '' :
- self.entry2.insert(0,FileName)
self.entry.delete(0,END)
+ self.entry2.delete(0,END)
self.entry.insert(0,FileName)
+ self.entry2.insert(0,FileName)
self.valid_valeur()
EntryName=AtName.Value()
if EntryName != '':
- self.entry2.insert(0,EntryName)
self.entry.delete(0,END)
+ self.entry2.delete(0,END)
self.entry.insert(0,EntryName)
+ self.entry2.insert(0,EntryName)
self.valid_valeur()
def SALOME_DONNEES_HOMARD_FICHIER_MED_MAILLAGE_NP1(self):
self.SALOME_DONNEES_HOMARD_FICHIER_MED_MAILLAGE_N()
-
-# def SALOME_LIRE_MAILLAGE_UNITE(self):
-
-# unite=self.node.item.get_valeur()
-# entrychaine=salome.sg.getAllSelected()
-# if entrychaine != '':
-# self.entry2.delete(0,END)
-
-# try:
-# SO = salome.myStudy.FindObjectID(entrychaine[0])
-# except:
-# boo = 0
-# SO = None
-
-# if SO != None:
-# myBuilder = salome.myStudy.NewBuilder()
-# boo,FileAttr = myBuilder.FindAttribute(SO,"AttributeComment")
-#
-# FileName=''
-# if SO != None:
-# myBuilder = salome.myStudy.NewBuilder()
-# boo,FileAttr = myBuilder.FindAttribute(SO,"AttributeFileType")
-# if boo:
-# boo=0
-# val=FileAttr.Value()
-# if (val !="FICHIERMED"):
-# showerror("Pas de Fichier MED","Cet Objet n a pas de fichier MED Associ\xe9")
-# else:
-# boo,FileAttr = myBuilder.FindAttribute(SO,"AttributeExternalFileDef")
-# if boo :
-# FileName=FileAttr.Value()
-# else:
-# showerror("Pas de Fichier MED","Cet Objet n a pas de fichier MED Associ\xe9")
-
-# print "FileName = " , FileName
-# if FileName != '' :
-# self.entry2.insert(0,FileName)
-# typefic='D'
-# SALOME_UNIQUE_BASE_Panel.dict_fichier_unite[unite]=typefic+FileName
-# else :
-# print "il faut afficher une Fenetre d impossibilit\xe9"
-# showerror("Pas de Fichier MED","Cet Objet n a pas de fichier MED Associ\xe9")
+ def SALOME_DEFI_GROUP_CREA_GROUP_MA_GROUP_MA(self):
+ #try:
+ if ( 1 == 1 ) :
+ selection, msg = self.parent.appli.selectGroupFromSalome()
+ if selection:
+ strSelection =str( selection )
+ UNIQUE_BASE_Panel.valid_valeur(self,strSelection)
+ if msg:
+ self.parent.appli.affiche_infos(msg)
+ self.erase_valeur()
+ #except:
+ else :
+ print ' erreur '
+
def redistribue_selon_simp(self):
genea = self.node.item.get_genealogie()
commande="SALOME"
for i in range(0,len( genea )) :
commande=commande+"_"+ genea[i]
- (SALOME_UNIQUE_BASE_Panel.__dict__[commande])(self)
+ # --------------------------------------------------------------
+ # on verifie que la methode n est pas particularise
+ # sinon on appelle SALOME_DEFI_GROUP_CREA_GROUP_MA_GROUP_MA qui
+ # sert comme methode par defaut
+ # --------------------------------------------------------------
+ try :
+ SALOME_UNIQUE_BASE_Panel.__dict__[commande](self)
+ except :
+ SALOME_UNIQUE_BASE_Panel.SALOME_DEFI_GROUP_CREA_GROUP_MA_GROUP_MA(self)
+
def makeValeurPage(self,page):
"""
- Génère la page de saisie de la valeur du mot-clé simple courant qui doit être de type
- de base cad entier, réel, string ou complexe
- """
- # Récupération de l'aide associée au panneau, de l'aide destinée à l'utilisateur,
- # et de la liste des SD du bon type (constituant la liste des choix)
- bulle_aide=self.get_bulle_aide()
- aide=self.get_aide()
- aide= justify_text(texte=aide)
- liste_noms_sd = self.node.item.get_sd_avant_du_bon_type()
- # Remplissage du panneau
- self.frame_valeur = Frame(page)
- self.frame_valeur.pack(fill='both',expand=1)
- self.frame_valeur.bind("<Button-3>",lambda e,s=self,a=bulle_aide : s.parent.appli.affiche_aide(e,a))
- self.frame_valeur.bind("<ButtonRelease-3>",self.parent.appli.efface_aide)
- self.label = Label(self.frame_valeur,text='Valeur :')
- self.label.place(relx=0.1,rely=0.5)
- self.entry = Entry(self.frame_valeur,relief='sunken')
- self.entry.place(relx=0.28,rely=0.5,relwidth=0.6)
- self.entry.bind("<Return>",lambda e,c=self.valid_valeur:c())
- self.entry.bind("<KP_Enter>",lambda e,c=self.valid_valeur:c())
-
- # PN : Ajout d'un bouton pour selectionner à partir de Salome
+ Crée la page de saisie d'une valeur à priori quelconque,
+ cad qui ne sont pas à choisir dans une liste prédéfinie
+ Ajout d'un bouton pour selectionner à partir de Salome
+ """
+ UNIQUE_BASE_Panel.makeValeurPage(self,page)
self.b = Button(self.frame_valeur,text='Relier selection',command=self.redistribue_selon_simp)
- self.b.place(relx=0.05,rely=0.1)
- unite=self.node.item.get_valeur()
- self.entry2 = Entry(self.frame_valeur,relief='sunken')
- self.entry2.place(relx=0.3,rely=0.1)
- self.entry2.configure(width = 250)
-
- if SALOME_UNIQUE_BASE_Panel.dict_fichier_unite.has_key(unite):
- associe=SALOME_UNIQUE_BASE_Panel.dict_fichier_unite[unite][1:]
- self.entry2.delete(0,END)
- if associe != "" :
- self.entry2.insert(0,associe)
- else:
- self.entry2.delete(0,END)
-
- # aide associée au panneau
- self.frame_valeur.update()
- self.aide = Label(self.frame_valeur,
- text = aide,
- wraplength=int(self.frame_valeur.winfo_width()*0.8),
- justify='center')
- self.aide.place(relx=0.5,rely=0.7,anchor='n')
- # affichage de la valeur du MCS
- self.display_valeur()
+ self.b.place(relx=0.28,rely=0.4,relwidth=0.4)
#---------------------------------------------------------------------------------------
# Correspondances entre les classes eficas et les classes salome_eficas
Crée la page de saisie d'une liste de valeurs à priori quelconques,
cad qui ne sont pas à choisir dans une liste prédéfinie
"""
- #print "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC"
- #print " "
- #print "A priori on ne doit plus passer dans cette methode "
- #print " "
- #print "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC"
+ #print "Methode Utilisée par Salome"
# On récupère la bulle d'aide du panneau, l'objet, l'aide,min et max (cardinalité de la liste),
# et la liste des valeurs déjà affectées à l'objet courant
bulle_aide=self.get_bulle_aide()
self.frame_aide = Frame(self.frame_right)
self.frame_aide.place(relx=0.1,rely=0.8,relwidth=0.8,relheight=0.2)
self.frame_boutons = Frame(self.frame2)
- #self.frame_boutons.place(relx=0.35,rely=0.,relwidth=0.3,relheight=1.)
self.frame_boutons.place(relx=0.2,rely=0.,relwidth=1,relheight=1.)
for fram in (self.frame1,self.frame2,self.frame_right,self.frame_valeurs,
self.frame_boutons_fleches,self.frame_choix,self.frame_aide,self.frame_boutons):
if (valeurentree == None or valeurentree ==""):
return None,0,""
- #On tente une evaluation globale
+ #On tente une evaluation globale (ne fait pas de vérification de validité
+ #seulement une transformation de la chaine en objet équivalent)
valeur,validite=self.node.item.eval_valeur(valeurentree)
if valeur == valeurentree:
#L'evaluation n'a rien donné : on a toujours la string
if len(l_valeurs) > 0 :
liste_marque=l_valeurs[-1]
self.Liste_valeurs.surligne(liste_marque)
+ self.selectValeur(l_valeurs[-1])
self.Liste_choix.affiche_liste()
for fram in (self.frame_valeurs,self.frame_boutons_fleches,self.frame_choix,self.frame_boutons):
fram.bind("<Button-3>",lambda e,s=self,a=bulle_aide : s.parent.appli.affiche_aide(e,a))
encorevalide = -2
testtype=0
else :
- testtype = self.node.item.object.verif_type(valeur)
+ testtype,comment = self.node.item.object.verif_type(valeur)
if not testtype :
- commentaire ="Type de la valeur incorrecte"
+ commentaire =comment
encorevalide=-2
if (encorevalide ==0) :
self.cata = (self.cata,)
else:
self.cata = (self.cata,)
+ titreSuite=" avec le catalogue " + os.path.basename(self.fic_cata)
+ titre=self.appli.titre+titreSuite
+ if self.appli.top:
+ self.appli.top.title(titre)
+ self.appli.titre=titre
def import_cata(self,cata):
"""
text = aide,
wraplength=int(self.frame_valeur.winfo_width()*0.8),
justify='center')
- self.aide.place(relx=0.5,rely=0.7,anchor='n')
+ self.aide.place(relx=0.5,rely=0.9,anchor='n')
# bouton parametre
bouton_parametres = Button(self.frame_valeur, text="Parametres", command=self.affiche_parametre)
bouton_parametres.place(relx=0.28,rely=0.5,relwidth=0.4)
+ bouton_val = Button(self.frame_valeur, text="Valider", command=self.valide)
+ bouton_val.place(relx=0.28,rely=0.6,relwidth=0.4)
# affichage de la valeur du MCS
self.display_valeur()
+ def valide(self):
+ self.valid_valeur()
+
def affiche_parametre(self) :
if self.node.item.get_liste_param_possible() != [ ]:
txtparam=""
self.label.pack(side='top')
self.frame = Frame(page)
self.frame.place(relx=0.33,rely=0.2,relwidth=0.33,relheight=0.6)
+
+
liste_commandes = (("<Button-1>",self.selectChoix),
("<Button-3>",self.deselectChoix),
("<Double-Button-1>",self.record_valeur))
liste_commandes = liste_commandes,
titre="Valeurs possibles",optionReturn="oui")
self.Liste_choix.affiche_liste()
+ self.bouton_val = Button(self.frame_valeur,
+ text = "Valider",
+ command=self.record_valeur_ligne,
+ width=14)
+ self.bouton_val.place(relx=0.33,rely=0.85)
+
+ def record_valeur_ligne(self):
+ valeur=self.Liste_choix.arg_selected
+ self.record_valeur(valeur)
def get_bulle_aide(self):
"""
self.parent.appli.affiche_infos('Valeur du mot-clé enregistrée')
else :
cr = self.node.item.get_cr()
- mess = "Valeur du mot-clé non autorisée :"+cr.get_mess_fatal()
+ mess = "Valeur du mot-clé non autorisée "+cr.get_mess_fatal()
self.reset_old_valeur(anc_val,mess=mess)
self.display_valeur()
class Fenetre :
""" Cette classe permet de créer une fenêtre Toplevel dans laquelle
on peut afficher un texte et qui permet de le sauver"""
- def __init__(self,appli,titre="",texte=""):
+ def __init__(self,appli,titre="",texte="",wrap=WORD,width=100,height=30):
self.appli=appli
+ if self.appli.test==1 : return
self.fenetre = Toplevel()
self.fenetre.withdraw()
- self.fenetre.configure(width = 800,height=500)
+ #self.fenetre.configure(width = 800,height=500)
self.fenetre.protocol("WM_DELETE_WINDOW", self.quit)
self.fenetre.title("Visualisation du "+titre)
self.texte = string.replace(texte,'\r\n','\n')
# définition des frames
self.frame_texte = Frame(self.fenetre)
self.frame_boutons = Frame(self.fenetre)
- self.frame_texte.place(relx=0,rely=0,relwidth=1,relheight=0.9)
- self.frame_boutons.place(relheight=0.1,relx=0,rely=0.9,relwidth=1.)
+ #self.frame_texte.place(relx=0,rely=0,relwidth=1,relheight=0.9)
+ #self.frame_boutons.place(relheight=0.1,relx=0,rely=0.9,relwidth=1.)
# définition de la zone texte et du scrollbar
- self.zone_texte = Text(self.frame_texte,font=fonte)
+ self.zone_texte = Text(self.frame_texte,font=fonte,wrap=wrap,
+ height=height,width=width)
self.zone_texte.bind("<Key-Prior>", self.page_up)
self.zone_texte.bind("<Key-Next>", self.page_down)
self.zone_texte.bind("<Key-Up>", self.unit_up)
self.zone_texte.pack(side='top',fill='both',expand=1,padx=5,pady=10)
self.zone_texte.configure(yscrollcommand=self.scroll_v.set)
# définition des boutons
- self.but_quit = Button(self.frame_boutons,text = "Fermer",command=self.quit,default='active')
- self.but_save = Button(self.frame_boutons,text = "sauver",command = self.save)
- self.but_quit.place(relx=0.4,rely=0.5,anchor='center')
- self.but_save.place(relx=0.6,rely=0.5,anchor='center')
+ self.but_quit = Button(self.frame_boutons,text = "Fermer",command=self.quit,
+ default='active')
+ self.but_save = Button(self.frame_boutons,text = "Sauver",command = self.save)
+ #self.but_quit.place(relx=0.4,rely=0.5,anchor='center')
+ #self.but_save.place(relx=0.6,rely=0.5,anchor='center')
+ self.but_quit.pack(side='left',padx=25, pady=5)
+ self.but_save.pack(side='right',padx=25, pady=5)
+ self.frame_texte.pack(side='top',fill='both',expand=1)
+ self.frame_boutons.pack(side='bottom')
+ self.zone_texte.focus_set()
+ self.fenetre.bind('<Return>',self.quit) #dismiss window
+
# affichage du texte
self.affiche_texte(self.texte)
self.zone_texte.config(state=DISABLED)
def page_up(self,event):
event.widget.yview_scroll(-1, "page")
+ return "break" #Pour eviter la propagation de l'evenement a la fenetre principale
def page_down(self,event):
event.widget.yview_scroll(1, "page")
+ return "break" #Pour eviter la propagation de l'evenement a la fenetre principale
def unit_up(self,event):
event.widget.yview_scroll(-1, "unit")
+ return "break" #Pour eviter la propagation de l'evenement a la fenetre principale
def unit_down(self,event):
event.widget.yview_scroll(1, "unit")
+ return "break" #Pour eviter la propagation de l'evenement a la fenetre principale
def wait(self):
self.fenetre.grab_set()
self.zone_texte.focus_set()
self.fenetre.wait_window(self.fenetre)
- def quit(self):
+ def quit(self,event=None):
self.fenetre.destroy()
+ return "break" #Pour eviter la propagation de l'evenement a la fenetre principale
def efface_scroll(self):
""" Efface le scroll lorsqu'il n'est pas nécessaire : ne marche pas"""
except :
pass
+class FenetreSurLigneWarning(Fenetre):
+
+ def affiche_texte(self,texte):
+ """ Affiche le texte dans la fenêtre """
+ ligne=0
+ if texte != "" :
+ texte_cr=texte.splitlines()
+ for l in texte_cr:
+ ligne=ligne+1
+ l=l+"\n"
+ self.zone_texte.insert(END,l)
+ if l.find("INFO") < 0 :
+ self.zone_texte.tag_add( "Rouge", str(ligne)+".0", "end-1c" )
+ self.zone_texte.tag_config("Rouge", foreground='red')
+ try:
+ self.fenetre.update_idletasks()
+ x0,y0,x1,y1 = self.zone_texte.bbox(END)
+ if (y1-y0) < 300 : self.efface_scroll()
+ except:
+ pass
+
class FenetreYesNo(Fenetre):
def __init__(self,appli,titre="",texte="",yes="Yes",no="No"):
self.appli=appli
et retourne 0, sinon retourne 1 sans rien afficher.
"""
if message != "":
- showinfo("Problème",message)
+ showinfo("Problème",message,parent=self.fenetre)
self.fenetre.tkraise()
self.appli.affiche_infos(message_eficas)
return 0
return message,liste_valeurs
def verif_valeurs(self, liste_valeurs):
- """ Cette méthode teste tous les éléments de la liste, et retourne 1 si chaque
- élément est dans le domaine voulu.
+ """ Cette méthode teste la validité de tous les éléments de la liste,
+ retourne un message vide s'ils sont valides
+ ou un message non vide au premier élément non valide rencontré
"""
message = ""
for valeur in liste_valeurs:
- test = self.item.IsInIntervalle(valeur)
- if test == 0:
- intervalle = str(self.item.GetIntervalle()[0])+","+str(self.item.GetIntervalle()[1])
- message = "La valeur "+str(valeur)+" n'est pas dans l'intervalle ["+intervalle+"]"
- return message
+ test,message = self.item.object.verif_type(valeur)
+ if test == 0: return message
return message
def ajouter_valeurs(self, liste_valeurs):
que le jeu de commandes inclus est valide et compatible
avec le contexte avant et apres l'insertion
"""
+import string
from Accas import JDC,ASSD,AsException,JDC_CATA
from Ihm import CONNECTOR
if recorded_units is not None:self.recorded_units=recorded_units
if old_recorded_units is not None:self.old_recorded_units=old_recorded_units
+ def o_register(self,sd):
+ return self.jdc_pere.o_register(sd)
+
def NommerSdprod(self,sd,sdnom,restrict='non'):
"""
Nomme la SD apres avoir verifie que le nommage est possible : nom
#print "NommerSdprod",sd,sdnom,restrict
if self.prefix_include:
if sdnom != self.prefix_include:sdnom=self.prefix_include+sdnom
+
+ if sdnom != '' and sdnom[0] == '_':
+ # Si le nom du concept commence par le caractere _ on lui attribue
+ # un identificateur automatique comme dans JEVEUX (voir gcncon)
+ #
+ # nom commencant par __ : il s'agit de concepts qui seront detruits
+ # nom commencant par _ : il s'agit de concepts intermediaires qui seront gardes
+ # ATTENTION : il faut traiter différemment les concepts dont le nom
+ # commence par _ mais qui sont des concepts nommés automatiquement par
+ # une éventuelle sous macro.
+ if sdnom[1] in string.digits:
+ # Ce concept provient probablement d'une sous macro (cas improbable)
+ #pas de renommage
+ pass
+ elif sdnom[1] == '_':
+ #cas d'un concept à ne pas conserver apres execution de la commande
+ sdnom=sd.id[2:]
+ pass
+ else:
+ sdnom=sd.id[2:]
+ pass
+
o=self.sds_dict.get(sdnom,None)
if isinstance(o,ASSD):
raise AsException("Nom de concept deja defini : %s" % sdnom)
# Modules Eficas
import I_ETAPE
+import I_ENTITE
+import I_OBJECT
import Noyau
from Noyau.N_ASSD import ASSD
+from Noyau import N__F
import convert
+from Extensions import param2
# import rajoutés suite à l'ajout de Build_sd --> à résorber
import Noyau, Validation.V_MACRO_ETAPE
def __init__(self):
self.typret=None
+ #indique si le jeu de commande inclus a pu etre analysé par convert
+ #pour etre editable (0=NON, 1=OUI)
+ self.text_converted=1
+ self.text_error=""
self.recorded_units={}
def get_sdprods(self,nom_sd):
# Il faut convertir le texte inclus en fonction du format
# sauf les INCLUDE_MATERIAU
+ self.text_converted=0
+ self.text_error=""
if self.nom != "INCLUDE_MATERIAU":
format=self.jdc.appli.format_fichier.get()
if convert.plugins.has_key(format):
# Le convertisseur existe on l'utilise
p=convert.plugins[format]()
p.text=text
- text=p.convert('exec',self)
+ text=p.convert('exec',self.jdc.appli)
+ #Si le fichier ne peut pas etre converti, le cr n'est pas vide
+ #et le texte est retourné tel que
+ if not p.cr.estvide():
+ self.text_converted=0
+ self.text_error=str(p.cr)
+ else:
+ self.text_converted=1
j=self.JdC_aux( procedure=text, nom=fichier,
appli=self.jdc.appli,
# Erreurs dans l'INCLUDE. On garde la memoire du fichier
# mais on n'insere pas les concepts
# On retablit l'etape courante step
+ #print j.cr
CONTEXT.unset_current_step()
CONTEXT.set_current_step(step)
raise Exception("Impossible de relire le fichier\n"+str(j.cr))
# L'INCLUDE n'est pas valide.
# on produit un rapport d'erreurs
cr=j.report()
+ #print cr
# On retablit l'etape courante step
CONTEXT.unset_current_step()
CONTEXT.set_current_step(step)
CONTEXT.set_current_step(step)
raise
+ # Si on est arrivé ici, le texte du fichier inclus (INCLUDE, POURSUITE, ...)
+ # est valide et insérable dans le JDC
+
# On remplit le dictionnaire des concepts produits inclus
# en retirant les concepts présents dans le contexte initial
# On ajoute egalement le concept produit dans le sds_dict du parent
self.g_context[k]=v
self.parent.sds_dict[k]=v
+ #Ce traitement n'est réalisé que dans les cas suivants:
+ # - si convert n'a pas pu convertir le jeu de commandes
+ # - et ce n'est pas un INCLUDE_MATERIAU
+ #On collecte les variables Python qui ne sont pas dans le contexte initial
+ #et dans le contexte validé et on en fait un pseudo-parametre (Variable)
+ if self.text_converted == 0 and self.nom != "INCLUDE_MATERIAU":
+ for k,v in j.g_context.items():
+ if k in context_ini:continue
+ if k in j_context:continue
+ if isinstance(v,ASSD):continue
+ if isinstance(v,I_ENTITE.ENTITE):continue
+ if isinstance(v,I_OBJECT.OBJECT):continue
+ if callable(v):continue
+ self.g_context[k]=param2.Variable(k,v)
# On recupere le contexte courant
self.current_context=j.current_context
"""
Cette méthode sert à créer un contexte pour INCLUDE_MATERIAU
en interprétant un texte source Python
- Elle est appelee par la fonction sd_prd d'INCLUDE_MATERIAU
+ Elle est appelee par la fonction sd_prod d'INCLUDE_MATERIAU
"""
#print "make_contexte",fichier
# On supprime l'attribut mat qui bloque l'evaluation du source de l'INCLUDE_MATERIAU
import Extensions.jdc_include
self.JdC_aux=Extensions.jdc_include.JdC_include
except:
- traceback.print_exc()
raise
try:
self.make_contexte_include(self.fichier_ini ,self.fichier_text)
+ if not self.g_context.has_key(self.nom_mater):
+ #Pour permettre de lire un jeu de commandes avec des INCLUDE_MATERIAU errones
+ self.g_context[self.nom_mater]=None
+ if self.parent: self.parent.g_context[self.nom_mater]=None
except:
l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
self.fichier_err = string.join(l)
self.g_context={}
+ #Pour permettre de lire un jeu de commandes avec des INCLUDE_MATERIAU errones
+ if self.parent:
+ self.parent.g_context[self.nom_mater]=None
+ self.g_context[self.nom_mater]=None
+ #-------------
self.etapes=[]
self.jdc_aux=None
self.contexte_fichier_init={}
if self.definition.validators:
valid=self.definition.validators.verif_item(item)
except ValError,e:
+ #traceback.print_exc()
valid=0
return valid
try:
#on verifie le type
self.typeProto.adapt(item)
+ #on verifie les choix possibles
+ self.intoProto.adapt(item)
+ #on ne verifie pas la cardinalité mais on verifie les validateurs
+ if self.definition.validators:
+ valid=self.definition.validators.verif_item(item)
+ comment=""
valid=1
except ValError,e:
+ #traceback.print_exc()
+ comment=str(e)
valid=0
- return valid
+ return valid,comment
#--------------------------------------------------------------------------------
-#@ MODIF N_ETAPE Noyau DATE 10/05/2006 AUTEUR MCOURTOI M.COURTOIS
+#@ MODIF N_ETAPE Noyau DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
from N_Exception import AsException
import N_utils
from N_utils import AsType
+from N_ASSD import ASSD
class ETAPE(N_MCCOMPO.MCCOMPO):
"""
self.sd= sd_prod(etape=self)
# Si l'operateur est obligatoirement reentrant et reuse n'a pas ete specifie, c'est une erreur.
# On ne fait rien ici. L'erreur sera traiter par la suite.
+ # précaution
+ if self.sd is not None and not isinstance(self.sd, ASSD):
+ raise AsException("""
+Impossible de typer le résultat !
+Causes possibles :
+ Utilisateur : Soit la valeur fournie derrière "reuse" est incorrecte,
+ soit il y a une "," à la fin d'une commande précédente.
+ Développeur : La fonction "sd_prod" retourne un type invalide.""")
return self.sd
def get_type_produit(self):
-#@ MODIF N_MACRO_ETAPE Noyau DATE 10/05/2006 AUTEUR MCOURTOI M.COURTOIS
+#@ MODIF N_MACRO_ETAPE Noyau DATE 10/10/2006 AUTEUR MCOURTOI M.COURTOIS
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
import N_utils
from N_utils import AsType
from N_CO import CO
+from N_ASSD import ASSD
class MACRO_ETAPE(N_ETAPE.ETAPE):
"""
self.typret=sd_prod
# Si la commande est obligatoirement reentrante et reuse n'a pas ete specifie, c'est une erreur.
# On ne fait rien ici. L'erreur sera traitee par la suite.
+ # précaution
+ if self.sd is not None and not isinstance(self.sd, ASSD):
+ raise AsException("""
+Impossible de typer le résultat !
+Causes possibles :
+ Utilisateur : Soit la valeur fournie derrière "reuse" est incorrecte,
+ soit il y a une "," à la fin d'une commande précédente.
+ Développeur : La fonction "sd_prod" retourne un type invalide.""")
return self.sd
def get_type_produit(self,force=0):
-#@ MODIF N_MCLIST Noyau DATE 22/02/2005 AUTEUR DURAND C.DURAND
+#@ MODIF N_MCLIST Noyau DATE 25/09/2006 AUTEUR MCOURTOI M.COURTOIS
# -*- coding: iso-8859-1 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
return self.data[0].get_mocle(key)
else:
return self.data[key]
+
+ def List_F(self):
+ """
+ Retourne une liste de dictionnaires (eventuellement singleton) qui peut etre
+ passe directement derriere un mot-cle facteur (pour les macros).
+ """
+ dresu = []
+ for mcf in self:
+ dico = mcf.cree_dict_valeurs(mcf.mc_liste)
+ for i in dico.keys():
+ if dico[i] == None:
+ del dico[i]
+ dresu.append(dico)
+ return dresu
concept = [concept,]
l_ps = obj["SENSIBILITE"]
for co in concept:
+ if co is None:
+ text="Pas de sensibilité sur objet None"
+ return text,0
if not l_ps:
# pas de sensibilité
if hasattr(co,"sensi") and not co.sensi.get('nominal'):
-
import sys
-sys.path.insert(0,"../Aster")
import prefs
#ASTERDIR="/local/chris/ASTER/instals/STA8.2/astest"
-ASTERDIR="/local/chris/ASTER/instals/NEW8/astest"
-sys.path.insert(0,prefs.CODE_PATH)
+ASTERDIR="/local/chris/ASTER/instals/astests/V8.3.21"
--- /dev/null
+# 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.
+#
+#
+# ======================================================================
+
+import os
+
+import prefs
+
+rep_cata = os.path.abspath(os.path.join(prefs.REPINI,'../Aster/Cata'))
+rep_Pmw = os.path.join(prefs.REPINI,'../Pmw')
+
+# Accès à la documentation Aster
+path_doc = os.path.join(rep_cata,'..','Doc')
+exec_acrobat = "acroread"
+# Utilisateur/Développeur
+isdeveloppeur = "NON"
+path_cata_dev = "/tmp/cata"
+# Répertoire temporaire
+rep_travail = "/tmp"
+# Répertoire initial
+initialdir=os.curdir
+
+# Choix des catalogues
+rep_mat=os.path.join(rep_cata,'..','materiau')
+rep_mat="/local/cchris/ASTER/instals/materiaux/NEW8/materiau"
+
+catalogues = (
+ ('ASTER','petit',os.path.join(rep_cata,'petitcata'),'python'),
+ ('ASTER','v5.9',os.path.join(rep_cata,'cataSTA5'),'asterv5'),
+ ('ASTER','v6.8',os.path.join(rep_cata,'cataSTA6'),'python6'),
+ ('ASTER','v6',os.path.join(rep_cata,'cataSTA6'),'python6'),
+ ('ASTER','v7.7',os.path.join(rep_cata,'cataSTA7'),'python'),
+ ('ASTER','v7',os.path.join(rep_cata,'cataSTA7'),'python'),
+ ('ASTER','v8.4',os.path.join(rep_cata,'cataSTA8'),'python'),
+ ('ASTER','v8',os.path.join(rep_cata,'cataSTA8'),'python','defaut'),
+ )
+
--- /dev/null
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# 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.
+#
+#
+# ======================================================================
+
+"""
+ Ce module sert à lancer EFICAS configuré pour Code_Aster
+"""
+# Modules Python
+
+# Modules Eficas
+import prefs
+from Editeur import eficas_go
+
+eficas_go.lance_eficas()
+# -*- coding: utf-8 -*-
+# 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.
+#
+#
+# ======================================================================
+
+import os,sys
+
+# REPINI sert à localiser le fichier editeur.ini
+# Obligatoire
+REPINI=os.path.dirname(os.path.abspath(__file__))
+
+# INSTALLDIR sert à localiser l'installation d'Eficas
+# Obligatoire
+INSTALLDIR=os.path.join(REPINI,'..')
+
+# CODE_PATH sert à localiser Noyau et Validation éventuellement
+# non contenus dans la distribution EFICAS
+# Par défaut on utilise les modules de INSTALLDIR
+# Peut valoir None (defaut)
+CODE_PATH = None
+#CODE_PATH = os.path.join(REPINI,'../../Superv')
+
+# la variable code donne le nom du code a selectionner
+code="ASTER"
+
+# ICONDIR sert à localiser le répertoire contenant les icones
+# Par défaut on utilise le répertoire icons dans Editeur
+ICONDIR=os.path.join(INSTALLDIR,'Editeur','icons')
+
+# lang indique la langue utilisée pour les chaines d'aide : fr ou ang
+lang='fr'
+
+# Codage des strings qui accepte les accents (en remplacement de 'ascii')
+encoding='iso-8859-1'
+
+labels= ('Fichier','Edition','Jeu de commandes',
+# 'Catalogue','Browsers',
+ 'Options',
+ 'Aide',
+ )
+
+appli_composants=['readercata','bureau',
+# 'browser',
+ 'options',
+ ]
+
+menu_defs={ 'bureau': [
+ ('Fichier',[
+ ('Nouveau','newJDC','<Control-n>','Ctrl+N'),
+ ('Nouvel INCLUDE','newJDC_include'),
+ ('Ouvrir','openJDC','<Control-o>','Ctrl+O'),
+ ('Enregistrer','saveJDC','<Control-s>','Ctrl+S'),
+ ('Enregistrer sous','saveasJDC','<Control-e>','Ctrl+E'),
+ None,
+ ('Fermer','closeJDC','<Control-w>','Ctrl+W'),
+ ('Quitter','exitEFICAS','<Control-q>','Ctrl+Q'),
+ ]
+ ),
+ ('Edition',[
+ ('Copier','copy','<Control-c>','Ctrl+C'),
+ ('Couper','cut','<Control-x>','Ctrl+X'),
+ ('Coller','paste','<Control-v>','Ctrl+V'),
+ ]
+ ),
+ ('Jeu de commandes',[
+ ('Rapport de validation','visuCRJDC','<Control-r>','Ctrl+R'),
+ ('Fichier source','visu_txt_brut_JDC','<Control-b>','Ctrl+B'),
+ #('Paramètres Eficas','affichage_fichier_ini'),
+ ]
+ ),
+ ('Aide',[
+ ('Aide EFICAS','aideEFICAS','<Control-a>','Ctrl+A'),
+ ]
+ ),
+ ]
+ }
+
+if os.name == 'nt':
+ userprefs = os.sep.join( [ os.environ['HOMEDRIVE'], os.environ['HOMEPATH'], 'Eficas_install', 'prefs.py' ])
+else :
+ userprefs=os.path.expanduser("~/Eficas_install/prefs.py")
+if os.path.isfile(userprefs):
+ try:
+ execfile(userprefs)
+ except:
+ pass
+
+sys.path[:0]=[INSTALLDIR]
--- /dev/null
+#@ MODIF properties Accas DATE 26/10/2005 AUTEUR gcbhhhh M.ADMINISTRATEUR
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# RESPONSABLE D6BHHHH J-P.LEFEBVRE
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2001 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.
+# ======================================================================
+# IDENTIFICATION DU GESTIONNAIRE DE COMMANDE ACCAS A PARTIR
+# DE LA VERSION DU CODE_ASTER ASSOCIE
+#----------------------------------------------------------------------
+version = "8.2.24"
+date = "O1/06/2006"
+exploit = False
--- /dev/null
+# -*- coding: utf-8 -*-
+"""
+Pour modifier le style d'EFICAS il faut ajouter un fichier style.py qui contiendra les
+informations sur le style voulu dans son repertoire Eficas_install.
+
+La methode la plus simple consiste à modifier directement les attributs de l'objet style dans le
+fichier style.py d'Eficas_install. Exemple::
+
+ style.background='yellow'
+
+pour modifier la couleur du background.
+
+Il existe une autre méthode qui peut être utilisée quand on veut modifier plusieurs propriétés à la fois.
+
+Le fichier style.py doit définir une nouvelle classe qui dérive de la classe de base STYLE avec des attributs
+de classe qui définiront le nouveau style (par exemple, si on veut modifier le background)::
+
+ class STYLE(STYLE):
+ background='yellow'
+
+Il faut ensuite instancier cette classe, dans ce meme fichier, en donnant le nom style à l'objet cree::
+
+ style=STYLE()
+
+Tous les attributs de classe possibles sont visibles dans le module Editeur/basestyle.py::
+
+ background='gray90'
+ foreground='black'
+ entry_background='white'
+ list_background='white'
+ list_select_background='#00008b'
+ list_select_foreground='grey'
+ tooltip_background="yellow"
+
+ standard = ("Helvetica",12)
+ standard_italique = ("Helvetica",12,'italic')
+ standard_gras = ("Helvetica",12,'bold')
+ standard_gras_souligne = ("Helvetica",12,'bold','underline')
+
+ canvas = ('Helvetica',10)
+ canvas_italique = ('Helvetica',10,'italic')
+ canvas_gras = ("Helvetica",10,'bold')
+ canvas_gras_italique = ("Helvetica",12,'bold','italic')
+
+ standard12 = ("Helvetica",14)
+ standard12_gras = ("Helvetica",14,'bold')
+ standard12_gras_italique = ( "Helvetica",14,'bold','italic')
+
+
+Le fichier style.py contenu dans le répertoire Aster permet de spécifier des propriétés globales pour une installation.
+Les modifications de style contenues dans ce fichier et dans le fichier style.py d'Eficas_install
+sont prises en compte dans cet ordre.
+"""
+
+
+style.background='gray90'
+style.foreground='black'
+style.standard = ("Helvetica",10)
+style.standard_italique = ("Helvetica",10,'italic')
+style.standard_gras = ("Helvetica",10,'bold')
+style.canvas_italique = ('Helvetica',10,'italic')
+style.canvas_gras = ("Helvetica",10,'bold')
+style.statusfont = ("Helvetica",14)
--- /dev/null
+import os,glob,sys
+import unittest
+import difflib
+
+from Editeur import appli
+
+from config import ASTERDIR
+
+def cdiff(text1,text2):
+ return " ".join(difflib.context_diff(text1.splitlines(1),text2.splitlines(1)))
+
+def make_tests(files):
+ class TestCase(unittest.TestCase):
+ app=None
+
+ def setUp(self):
+ if self.app == None:
+ self.app=appli.STANDALONE(version='v8')
+ pass
+
+ def tearDown(self):
+ CONTEXT.unset_current_step()
+
+ i=0
+ for f in glob.glob(os.path.join(ASTERDIR,files)):
+ ff=open(f)
+ text=ff.read()
+ ff.close()
+ if text.find("VISU_EFICAS='NON'") != -1:continue
+ for o in ('3','2','1','0','m'):
+ f=f[:-1]+o
+ if os.path.isfile(f):break
+ i=i+1
+ name=os.path.splitext(os.path.basename(f))[0]
+
+ exec """def test_%s(self,file="%s"):
+ "fichier:%s"
+ self.commtest(file)
+""" % (name,f,f)
+ del i,f,ff,text,o,name
+
+ def commtest(self,file):
+ """ Test generique"""
+ name=os.path.splitext(os.path.basename(file))[0]
+ errfile=os.path.join(os.path.dirname(__file__),name+".err")
+ err=""
+ if os.path.isfile(errfile):
+ f=open(errfile)
+ err=f.read()
+ f.close()
+ try:
+ j=self.app.openJDC(file=file)
+ if err == "":
+ assert j.isvalid(),j.report()
+ else:
+ txt=str(j.report())
+ assert txt == err,cdiff(err,txt)
+ j.supprime()
+ assert sys.getrefcount(j) == 2,sys.getrefcount(j)
+ except ValueError,e:
+ txt=str(e)
+ if err == "":
+ raise
+ else:
+ assert txt == err,cdiff(err,txt)
+
+ return TestCase
--- /dev/null
+Compilation impossible : File "erreu01a.comm", line 44
+ UELAS=MECA_STATIQUE(MODELE=MOD,
+ ^
+ SyntaxError: invalid syntax
--- /dev/null
+import basetest
+
+files="[a-l]*.comm"
+TestCase=basetest.make_tests(files)
+class TestCase(TestCase):pass
--- /dev/null
+import basetest
+
+files="z*.comm"
+TestCase=basetest.make_tests(files)
+class TestCase(TestCase):pass
--- /dev/null
+import basetest
+
+files="[m-r]*.comm"
+TestCase=basetest.make_tests(files)
+class TestCase(TestCase):pass
+
--- /dev/null
+import basetest
+
+files="s[a-d]*.comm"
+TestCase=basetest.make_tests(files)
+class TestCase(TestCase):pass
--- /dev/null
+import basetest
+
+files="s[e-r]*.comm"
+TestCase=basetest.make_tests(files)
+class TestCase(TestCase):pass
--- /dev/null
+import basetest
+
+files="ssl[a-l]*.comm"
+TestCase=basetest.make_tests(files)
+class TestCase(TestCase):pass
--- /dev/null
+import basetest
+
+files="ssl[m-z]*.comm"
+TestCase=basetest.make_tests(files)
+class TestCase(TestCase):pass
--- /dev/null
+import basetest
+
+files="ss[m-z]*.comm"
+TestCase=basetest.make_tests(files)
+class TestCase(TestCase):pass
+
--- /dev/null
+import basetest
+
+files="s[t-z]*.comm"
+TestCase=basetest.make_tests(files)
+class TestCase(TestCase):pass
--- /dev/null
+import basetest
+
+files="[t-y]*.comm"
+TestCase=basetest.make_tests(files)
+class TestCase(TestCase):pass
--- /dev/null
+# MODIF DATE 09/05/2006 AUTEUR REZETTE C.REZETTE
+# TITRE FISSURE AU CENTRE D'UNE PLAQUE MINCE RECTANGULAIRE FAISANT
+# 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.
+# ======================================================================
+# OBSTACLE A UN FLUC DE CHALEUR UNIFORME EN MILIEU ISOTROPE
+#
+# TESTE LES DERIVEES DE G DANS LE CAS D'UN CHARGEMENT EN FORCE DE VOLUME
+
+DEBUT( CODE=_F( NOM = 'HPLP101B',NIV_PUB_WEB='INTERNET'))
+
+YOUNG = DEFI_PARA_SENSI(VALE=1.)
+FORC = DEFI_PARA_SENSI(VALE=1.)
+
+MA=LIRE_MAILLAGE( )
+
+MA=DEFI_GROUP( reuse=MA, MAILLAGE=MA,
+ CREA_GROUP_NO=_F(
+ GROUP_MA = ( 'LP9P10', 'LP9P10B',
+ 'LP8P9', 'LP8P9B',
+ ))
+ )
+
+MO=AFFE_MODELE( MAILLAGE=MA,
+ AFFE=_F( TOUT = 'OUI',
+ PHENOMENE = 'MECANIQUE',
+ MODELISATION = 'C_PLAN')
+ )
+ZERO = DEFI_CONSTANTE(VALE=0.)
+NU = DEFI_CONSTANTE(VALE=0.3)
+ALPHA = DEFI_CONSTANTE(VALE=0.)
+
+MAT=DEFI_MATERIAU(ELAS_FO=_F( E = YOUNG, NU = NU,
+ TEMP_DEF_ALPHA =20.,
+ ALPHA = ALPHA, RHO=7800.,))
+
+CHMAT=AFFE_MATERIAU( MAILLAGE=MA,
+ AFFE=_F( TOUT = 'OUI',
+ MATER = MAT)
+ )
+
+CH=AFFE_CHAR_MECA_F( MODELE=MO,
+ FORCE_INTERNE=_F(TOUT='OUI',FY=FORC,),
+ DDL_IMPO=(
+ _F( GROUP_NO = 'LP8P9',
+ DX = ZERO),
+ _F( GROUP_NO = 'LP8P9B',
+ DX = ZERO),
+ _F( GROUP_NO = 'P11',
+ DY = ZERO))
+ )
+
+DEP=MECA_STATIQUE( MODELE=MO, CHAM_MATER=CHMAT,
+ SENSIBILITE = (FORC),
+ EXCIT=_F( CHARGE = CH),
+ )
+
+DEP=CALC_ELEM(reuse=DEP,RESULTAT=DEP,
+ SENSIBILITE = (FORC),
+ OPTION=('EPSI_ELGA_DEPL','SIEF_ELGA_DEPL',),)
+
+FOND=DEFI_FOND_FISS( MAILLAGE=MA,
+ FOND_FISS=_F( GROUP_NO = ('P0',)),
+ NORMALE=(0., 1., 0.,)
+ )
+
+THETA0=CALC_THETA( MODELE=MO,
+ THETA_2D=_F( GROUP_NO = ('P0',),
+ MODULE = 1.,
+ R_INF = 3.75E-5,
+ R_SUP = 7.50E-5),
+ DIRECTION=(1., 0., 0.,)
+ )
+
+G0=CALC_G( RESULTAT=DEP,
+ THETA=_F(THETA=THETA0),
+ SYME_CHAR='SANS',
+ COMP_ELAS=_F( RELATION = 'ELAS',
+ DEFORMATION = 'PETIT')
+ )
+
+DG0=CALC_G( RESULTAT=DEP,
+ SENSIBILITE = (FORC),
+ THETA=_F(THETA=THETA0),
+ SYME_CHAR='SANS',
+ COMP_ELAS=_F( RELATION = 'ELAS',
+ DEFORMATION = 'PETIT')
+ )
+
+TEST_TABLE( TABLE=DG0,
+ NOM_PARA='DG/DF',
+ SENSIBILITE = (FORC),
+ VALE=1.06E-2,
+ REFERENCE='ANALYTIQUE',
+ PRECISION=0.0005 )
+FIN()
+
+THETA01=CALC_THETA( MODELE=MO,
+ THETA_2D=_F( GROUP_NO = ('P0',),
+ MODULE = 1.,
+ R_INF = 7.50E-5,
+ R_SUP = 1.125E-4),
+ DIRECTION=(1., 0., 0.,)
+ )
+
+G1=CALC_G( RESULTAT=DEP,
+ THETA=_F(THETA=THETA01),
+ COMP_ELAS=_F( RELATION = 'ELAS',
+ DEFORMATION = 'PETIT'),
+ SYME_CHAR='SANS'
+ )
+
+DG1=CALC_G( RESULTAT=DEP,
+ SENSIBILITE = (FORC),
+ THETA=_F(THETA=THETA01),
+ SYME_CHAR='SANS',
+ COMP_ELAS=_F( RELATION = 'ELAS',
+ DEFORMATION = 'PETIT')
+ )
+
+TEST_TABLE( TABLE=DG1,
+ NOM_PARA='G',
+ SENSIBILITE = (FORC),
+ REFERENCE='ANALYTIQUE',
+ VALE=1.06E-2,
+ PRECISION=0.0005 )
+
+#
+# DERIVEE PAR RAPPORT A E
+#
+
+DEP2=MECA_STATIQUE( MODELE=MO, CHAM_MATER=CHMAT,
+ SENSIBILITE = (YOUNG),
+ EXCIT=_F( CHARGE = CH),
+ )
+
+DEP2=CALC_ELEM(reuse=DEP2,RESULTAT=DEP2,
+ SENSIBILITE = (YOUNG),
+ OPTION=('EPSI_ELGA_DEPL','SIEF_ELGA_DEPL',),)
+
+
+DG2=CALC_G( RESULTAT=DEP2,
+ SENSIBILITE = (YOUNG),
+ THETA=_F(THETA=THETA0),
+ SYME_CHAR='SANS',
+ COMP_ELAS=_F( RELATION = 'ELAS',
+ DEFORMATION = 'PETIT')
+ )
+
+TEST_TABLE( TABLE=DG2,
+ NOM_PARA='G',
+ SENSIBILITE = (YOUNG),
+ REFERENCE='ANALYTIQUE',
+ VALE=-5.3E-3,
+ PRECISION=0.0005 )
+
+
+DG3=CALC_G( RESULTAT=DEP2,
+ SENSIBILITE = (YOUNG),
+ THETA=_F(THETA=THETA01),
+ SYME_CHAR='SANS',
+ COMP_ELAS=_F( RELATION = 'ELAS',
+ DEFORMATION = 'PETIT')
+ )
+
+TEST_TABLE( TABLE=DG3,
+ NOM_PARA='G',
+ VALE=-5.3E-3,
+ SENSIBILITE = (YOUNG),
+ REFERENCE='ANALYTIQUE',
+ PRECISION=0.0005 )
+
+
+FIN()
+
--- /dev/null
+# MODIF DATE 23/10/2006 AUTEUR VABHHTS J.PELLET
+# TITRE THERMO-PLASTICITE EN TRACTION SIMPLE (MODELISATION:C_PLAN)
+# CONFIGURATION MANAGEMENT OF EDF VERSION
+# ======================================================================
+# COPYRIGHT (C) 1991 - 2006 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.
+# ======================================================================
+#
+
+DEBUT(CODE=_F( NOM = 'HSNV100H',NIV_PUB_WEB='INTRANET'),IMPR_MACRO='OUI',DEBUG=_F(SDVERI='OUI'))
+
+#......................................................................
+# CAS TEST THERMOPLASTICITE ELEMENTAIRE
+#......................................................................
+# DEFINITION DES CARACTERISTIQUES DU MATERIAU
+#
+
+MAIL=LIRE_MAILLAGE( )
+
+INCLUDE_MATERIAU(TYPE_MODELE='REF',
+ TYPE_VALE='NOMI',
+ NOM_AFNOR='Z2CND1712',
+ VARIANTE='A',
+ NOM_MATER='MONMAT',
+ UNITE_LONGUEUR='MM'
+ )
+
+CHMAT=AFFE_MATERIAU( MAILLAGE=MAIL,AFFE=(
+ _F( TOUT='OUI',TEMP_REF=25, MATER = MONMAT),
+ ),)
+
+#
+
+FIN()
+++ /dev/null
-erreur sur defi_materiau
--- /dev/null
+POURSUITE();
+l1=DEFI_LIST_ENTI(DEBUT=mon_param,);
+FIN();
+
--- /dev/null
+DEBUT();
+mon_param = 2;
+m=LIRE_MAILLAGE()
+FIN();
--- /dev/null
+x=45
+y=77
--- /dev/null
+POURSUITE();
+l1=DEFI_LIST_ENTI(DEBUT=2*mon_param+1,);
+l2=DEFI_LIST_ENTI(DEBUT=a[1]);
+INCLUDE_MATERIAU( NOM_AFNOR='18MND5', TYPE_MODELE='REF',
+ VARIANTE='A', TYPE_VALE='NOMI',
+ NOM_MATER='MAT3', INFO=1 )
+INCLUDE(UNITE=11)
+INCLUDE(UNITE=12)
+
+FIN();
+
--- /dev/null
+DEBUT();
+mon_param = 2;
+m=LIRE_MAILLAGE()
+a=[1,2,3,4];b=2
+FIN();
zz=8.9;
#ne marche pas avec le parseur actuel
-zz=8.9;aa=10 #position
+#zz=8.9;aa=10 #position
FIN()
+++ /dev/null
-import os,glob,sys
-import unittest
-
-from Editeur import appli
-
-from config import ASTERDIR
-
-class TestCase(unittest.TestCase):
- app=None
- def setUp(self):
- if self.app == None:
- self.app=appli.STANDALONE(version='v8.3')
- pass
-
- def tearDown(self):
- CONTEXT.unset_current_step()
-
- i=0
- for f in glob.glob(os.path.join(ASTERDIR,"[a-l]*.comm")):
- ff=open(f)
- text=ff.read()
- ff.close()
- if text.find("VISU_EFICAS='NON'") != -1:continue
- for o in ('3','2','1','0','m'):
- f=f[:-1]+o
- if os.path.isfile(f):break
- i=i+1
-
- exec """def test%s(self,file="%s"):
- "fichier:%s"
- self.commtest(file)
-""" % (i,f,f)
- del i,f,ff,text,o
-
- def commtest(self,file):
- """ Test generique"""
- j=self.app.openJDC(file=file)
- assert j.isvalid(),j.report()
- j.supprime()
- assert sys.getrefcount(j) == 2,sys.getrefcount(j)
+++ /dev/null
-import os,glob,sys
-import unittest
-
-from Editeur import appli
-
-from config import ASTERDIR
-
-class TestCase(unittest.TestCase):
- app=None
- def setUp(self):
- if self.app == None:
- self.app=appli.STANDALONE(version='v8.2')
- pass
-
- def tearDown(self):
- CONTEXT.unset_current_step()
-
- i=0
- for f in glob.glob(os.path.join(ASTERDIR,"z*.comm")):
- ff=open(f)
- text=ff.read()
- ff.close()
- if text.find("VISU_EFICAS='NON'") != -1:continue
- for o in ('3','2','1','0','m'):
- f=f[:-1]+o
- if os.path.isfile(f):break
- i=i+1
- exec """def test%s(self,file="%s"):
- self.commtest(file)
-""" % (i,f)
- del i,f,o,ff,text
-
- def commtest(self,file):
- """ Test generique"""
- print file
- j=self.app.openJDC(file=file)
- assert j.isvalid(),j.report()
- j.supprime()
- assert sys.getrefcount(j) == 2,sys.getrefcount(j)
-
+++ /dev/null
-import os,glob,sys
-import unittest
-
-from Editeur import appli
-
-from config import ASTERDIR
-
-class TestCase(unittest.TestCase):
- app=None
- def setUp(self):
- if self.app == None:
- self.app=appli.STANDALONE(version='v8.3')
- pass
-
- def tearDown(self):
- CONTEXT.unset_current_step()
-
- i=0
- for f in glob.glob(os.path.join(ASTERDIR,"[m-r]*.comm")):
- ff=open(f)
- text=ff.read()
- ff.close()
- if text.find("VISU_EFICAS='NON'") != -1:continue
- for o in ('3','2','1','0','m'):
- f=f[:-1]+o
- if os.path.isfile(f):break
- i=i+1
- exec """def test%s(self,file="%s"):
- "fichier:%s"
- self.commtest(file)
-""" % (i,f,f)
- del i,f,o,ff,text
-
- def commtest(self,file):
- """ Test generique"""
- j=self.app.openJDC(file=file)
- assert j.isvalid(),j.report()
- j.supprime()
- assert sys.getrefcount(j) == 2,sys.getrefcount(j)
-
+++ /dev/null
-import os,glob,sys
-import unittest
-
-from Editeur import appli
-
-from config import ASTERDIR
-
-class TestCase(unittest.TestCase):
- app=None
- def setUp(self):
- if self.app == None:
- self.app=appli.STANDALONE(version='v8.3')
- pass
-
- def tearDown(self):
- CONTEXT.unset_current_step()
-
- i=0
- for f in glob.glob(os.path.join(ASTERDIR,"s[a-d]*.comm")):
- ff=open(f)
- text=ff.read()
- ff.close()
- if text.find("VISU_EFICAS='NON'") != -1:continue
- for o in ('3','2','1','0','m'):
- f=f[:-1]+o
- if os.path.isfile(f):break
- i=i+1
- exec """def test%s(self,file="%s"):
- "fichier:%s"
- self.commtest(file)
-""" % (i,f,f)
- del i,f,o,ff,text
-
- def commtest(self,file):
- """ Test generique"""
- j=self.app.openJDC(file=file)
- assert j.isvalid(),j.report()
- j.supprime()
- assert sys.getrefcount(j) == 2,sys.getrefcount(j)
-
+++ /dev/null
-import os,glob,sys
-import unittest
-
-from Editeur import appli
-
-from config import ASTERDIR
-
-class TestCase(unittest.TestCase):
- app=None
- def setUp(self):
- if self.app == None:
- self.app=appli.STANDALONE(version='v8.3')
- pass
-
- def tearDown(self):
- CONTEXT.unset_current_step()
-
- i=0
- for f in glob.glob(os.path.join(ASTERDIR,"s[e-r]*.comm")):
- ff=open(f)
- text=ff.read()
- ff.close()
- if text.find("VISU_EFICAS='NON'") != -1:continue
- for o in ('3','2','1','0','m'):
- f=f[:-1]+o
- if os.path.isfile(f):break
- i=i+1
- exec """def test%s(self,file="%s"):
- "fichier:%s"
- self.commtest(file)
-""" % (i,f,f)
- del i,f,o,ff,text
-
- def commtest(self,file):
- """ Test generique"""
- j=self.app.openJDC(file=file)
- assert j.isvalid(),j.report()
- j.supprime()
- assert sys.getrefcount(j) == 2,sys.getrefcount(j)
-
+++ /dev/null
-import os,glob,sys
-import unittest
-
-from Editeur import appli
-
-from config import ASTERDIR
-
-class TestCase(unittest.TestCase):
- app=None
- def setUp(self):
- if self.app == None:
- self.app=appli.STANDALONE(version='v8.3')
- pass
-
- def tearDown(self):
- CONTEXT.unset_current_step()
-
- i=0
- for f in glob.glob(os.path.join(ASTERDIR,"ssl[a-l]*.comm")):
- ff=open(f)
- text=ff.read()
- ff.close()
- if text.find("VISU_EFICAS='NON'") != -1:continue
- for o in ('3','2','1','0','m'):
- f=f[:-1]+o
- if os.path.isfile(f):
- ff=open(f)
- text=ff.read()
- ff.close()
- if text.find("VISU_EFICAS='NON'") == -1: break
- i=i+1
- exec """def test%s(self,file="%s"):
- "fichier:%s"
- self.commtest(file)
-""" % (i,f,f)
- del i,f,o,ff,text
-
- def commtest(self,file):
- """ Test generique"""
- j=self.app.openJDC(file=file)
- assert j.isvalid(),j.report()
- j.supprime()
- assert sys.getrefcount(j) == 2,sys.getrefcount(j)
-
+++ /dev/null
-import os,glob,sys
-import unittest
-
-from Editeur import appli
-
-from config import ASTERDIR
-
-class TestCase(unittest.TestCase):
- app=None
- def setUp(self):
- if self.app == None:
- self.app=appli.STANDALONE(version='v8.3')
- pass
-
- def tearDown(self):
- CONTEXT.unset_current_step()
-
- i=0
- for f in glob.glob(os.path.join(ASTERDIR,"ssl[m-z]*.comm")):
- ff=open(f)
- text=ff.read()
- ff.close()
- if text.find("VISU_EFICAS='NON'") != -1:continue
- for o in ('3','2','1','0','m'):
- f=f[:-1]+o
- if os.path.isfile(f):break
- i=i+1
- exec """def test%s(self,file="%s"):
- "fichier:%s"
- self.commtest(file)
-""" % (i,f,f)
- del i,f,o,ff,text
-
- def commtest(self,file):
- """ Test generique"""
- j=self.app.openJDC(file=file)
- assert j.isvalid(),j.report()
- j.supprime()
- assert sys.getrefcount(j) == 2,sys.getrefcount(j)
-
+++ /dev/null
-import os,glob,sys
-import unittest
-
-from Editeur import appli
-
-from config import ASTERDIR
-
-class TestCase(unittest.TestCase):
- app=None
- def setUp(self):
- if self.app == None:
- self.app=appli.STANDALONE(version='v8.2')
- pass
-
- def tearDown(self):
- CONTEXT.unset_current_step()
-
- i=0
- for f in glob.glob(os.path.join(ASTERDIR,"ss[m-z]*.comm")):
- ff=open(f)
- text=ff.read()
- ff.close()
- if text.find("VISU_EFICAS='NON'") != -1:continue
- for o in ('3','2','1','0','m'):
- f=f[:-1]+o
- if os.path.isfile(f):
- ff=open(f)
- text=ff.read()
- ff.close()
- if text.find("VISU_EFICAS='NON'") == -1: break
- i=i+1
- exec """def test%s(self,file="%s"):
- self.commtest(file)
-""" % (i,f)
- del i,f,o,ff,text
-
- def commtest(self,file):
- """ Test generique"""
- print file
- j=self.app.openJDC(file=file)
- assert j.isvalid(),j.report()
- j.supprime()
- assert sys.getrefcount(j) == 2,sys.getrefcount(j)
-
+++ /dev/null
-import os,glob,sys
-import unittest
-
-from Editeur import appli
-
-from config import ASTERDIR
-
-class TestCase(unittest.TestCase):
- app=None
- def setUp(self):
- if self.app == None:
- self.app=appli.STANDALONE(version='v8.2')
- pass
-
- def tearDown(self):
- CONTEXT.unset_current_step()
-
- i=0
- for f in glob.glob(os.path.join(ASTERDIR,"s[t-z]*.comm")):
- ff=open(f)
- text=ff.read()
- ff.close()
- if text.find("VISU_EFICAS='NON'") != -1:continue
- for o in ('3','2','1','0','m'):
- f=f[:-1]+o
- if os.path.isfile(f):break
- i=i+1
- exec """def test%s(self,file="%s"):
- self.commtest(file)
-""" % (i,f)
- del i,f,o,ff,text
-
- def commtest(self,file):
- """ Test generique"""
- print file
- j=self.app.openJDC(file=file)
- assert j.isvalid(),j.report()
- j.supprime()
- assert sys.getrefcount(j) == 2,sys.getrefcount(j)
-
+++ /dev/null
-import os,glob,sys
-import unittest
-
-from Editeur import appli
-
-from config import ASTERDIR
-
-class TestCase(unittest.TestCase):
- app=None
- def setUp(self):
- if self.app == None:
- self.app=appli.STANDALONE(version='v8.2')
- pass
-
- def tearDown(self):
- CONTEXT.unset_current_step()
-
- i=0
- for f in glob.glob(os.path.join(ASTERDIR,"[t-y]*.comm")):
- ff=open(f)
- text=ff.read()
- ff.close()
- if text.find("VISU_EFICAS='NON'") != -1:continue
- for o in ('3','2','1','0','m'):
- f=f[:-1]+o
- if os.path.isfile(f):break
- i=i+1
- exec """def test%s(self,file="%s"):
- self.commtest(file)
-""" % (i,f)
- del i,f,o,ff,text
-
- def commtest(self,file):
- """ Test generique"""
- print file
- j=self.app.openJDC(file=file)
- assert j.isvalid(),j.report()
- j.supprime()
- assert sys.getrefcount(j) == 2,sys.getrefcount(j)
-
app=None
def setUp(self):
if self.app == None:
- self.app=appli.STANDALONE(version='v8.3')
+ self.app=appli.STANDALONE(version='v8')
pass
def tearDown(self):
CONTEXT.unset_current_step()
i=0
- for f in glob.glob(os.path.join(prefs.INSTALLDIR,"Tests/testcomm/*.comm")):
+ files="Tests/testcomm/*.comm"
+ for f in glob.glob(os.path.join(prefs.INSTALLDIR,files)):
for o in ('3','2','1','0','m'):
f=f[:-1]+o
if os.path.isfile(f):break
# 'AFFE_MODELE', 'AFFE', 'PHENOMENE' --> uniqueintopanel
# 'AFFE_MODELE', 'AFFE', 'b_mecanique'--> plusieursintopanel
-F1=DEFI_FONCTION(NOM_PARA='DX',
- VALE=(5.0,3.0,
+F1=DEFI_FONCTION(NOM_PARA='DX',VALE=(5.0,3.0,
P4[1],P3,
),);
-F3=DEFI_FONCTION(NOM_PARA='DRX',
- VALE_C=(5.0,7.0,9.0,
+F3=DEFI_FONCTION(NOM_PARA='DRX',VALE_C=(5.0,7.0,9.0,
9.0,8.0,7.0,
),);
# 'DEFI_FONCTION', 'VALE' --> fonctionpanel
# 'AFFE_MODELE', 'AFFE', 'PHENOMENE' --> uniqueintopanel
# 'AFFE_MODELE', 'AFFE', 'b_mecanique'--> plusieursintopanel
-F1=DEFI_FONCTION(NOM_PARA='DX',
- VALE=(5.0,3.0,
+F1=DEFI_FONCTION(NOM_PARA='DX',VALE=(5.0,3.0,
P4[1],P3,
),);
-F3=DEFI_FONCTION(NOM_PARA='DRX',
- VALE_C=(5.0,7.0,9.0,
+F3=DEFI_FONCTION(NOM_PARA='DRX',VALE_C=(5.0,7.0,9.0,
9.0,8.0,7.0,
),);
# 'DEFI_FONCTION', 'VALE' --> fonctionpanel
def test000(self):
""" Test de construction du fichier de commandes az.comm de zero"""
- app=appli.STANDALONE(version='v7.6')
+ app=appli.STANDALONE(version='v7')
j=app.newJDC()
# commande DEBUT
co=j.addentite("DEBUT",0)
def test001(self):
""" Test de construction d'un fichier de commandes avec DEFI_LIST_REEL, fonction et parametre de zero"""
- app=appli.STANDALONE(version='v7.6')
+ app=appli.STANDALONE(version='v7')
j=app.newJDC()
# commande DEBUT
co=j.addentite("DEBUT",0)
def cdiff(text1,text2):
return " ".join(difflib.context_diff(text1.splitlines(1),text2.splitlines(1)))
-version= 'v8.3'
+version= 'v8'
class TestCase(unittest.TestCase):
""" Tests sur des items """
def cdiff(text1,text2):
return " ".join(difflib.context_diff(text1.splitlines(1),text2.splitlines(1)))
-version='v8.3'
+version='v8'
class TestCase(unittest.TestCase):
def setUp(self):
def cdiff(text1,text2):
return " ".join(difflib.context_diff(text1.splitlines(1),text2.splitlines(1)))
-version='v8.3'
+version='v8'
class TestCase(unittest.TestCase):
def setUp(self):
def cdiff(text1,text2):
return " ".join(difflib.context_diff(text1.splitlines(1),text2.splitlines(1)))
-version='v8.3'
+version='v8'
class TestCase(unittest.TestCase):
def setUp(self):
def test000(self):
""" Test de construction du fichier de commandes az.comm de zero"""
- app=appli.STANDALONE(version='v6')
+ app=appli.STANDALONE(version='v6.8')
j=app.newJDC()
# commande DEBUT
co=j.addentite("DEBUT",0)
def test001(self):
""" Test de construction d'un fichier de commandes avec DEFI_LIST_REEL, fonction et parametre de zero"""
- app=appli.STANDALONE(version='v6')
+ app=appli.STANDALONE(version='v6.8')
j=app.newJDC()
# commande DEBUT
co=j.addentite("DEBUT",0)
# -*- coding: utf-8 -*-
+from tkMessageBox import showinfo
root=None
jdcdisplay=None
def add_valeur_into(valeur,panel):
label=panel.Liste_choix.dico_labels[valeur]
+ panel.Liste_choix.afficheMot(valeur)
+ root.update()
label.event_generate("<1>")
panel.bouton_add.invoke()
root.update()
from Editeur import images
from common import *
-version='v8.3'
+version='v8'
class TestCase(unittest.TestCase):
def setUp(self):
images.update_cache()
# Analyse des arguments de la ligne de commande
options=session.parse([])
- options.cata="v8.3"
+ options.cata="v8"
pass
def tearDown(self):
images.update_cache()
# Analyse des arguments de la ligne de commande
options=session.parse([])
- options.cata="v8.3"
+ options.cata="v8"
pass
def tearDown(self):
--- /dev/null
+# -*- coding: utf-8 -*-
+# 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
+# -*- coding: utf-8 -*-
+from parseur import FactNode
+from dictErreurs import jdcSet
+import logging
+
+dict_commande={}
+dict_contexte={}
+dict_contexte_option={}
+
+import sys
+#--------------------------------------------------------------------------
+def traitementRayon(jdc):
+#--------------------------------------------------------------------------
+
+ if "DEFI_FONCTION" not in jdcSet : return
+ for c in jdc.root.childNodes:
+ if c.name != "DEFI_FONCTION" : continue
+ monTexte=jdc.getLines()[c.lineno-1]
+ monNomVariable=monTexte.split("=")[0]
+ aExecuter=monNomVariable+'=0'
+ dict_commande[monNomVariable]=c
+ exec aExecuter in dict_contexte
+ liste_MC=(("CALC_G","R_INF_FO"),("CALC_G","R_SUP_FO"),("CALC_G","MODULE_FO"))
+ liste_achanger = chercheValeurSelonGenea2 (jdc,liste_MC)
+ liste_MC=(("CALC_THETA","THETA_3D","R_INF_FO"),("CALC_THETA","THETA_3D","R_SUP_FO"),("CALC_THETA","THETA_3D","MODULE_FO"))
+ liste_achanger2 = chercheValeurSelonGenea3 (jdc,liste_MC)
+ liste_achanger=liste_achanger+liste_achanger2
+ for item in liste_achanger :
+ commande=dict_commande[item]
+ changeValeurABSCNiveau1(commande,jdc)
+
+#----------------------------------
+def changeValeurABSCNiveau1(c,jdc):
+#----------------------------------
+ for child in c.childNodes:
+ if child.name != "NOM_PARA":continue
+ MonTexte=child.getText(jdc)
+ if len(MonTexte.splitlines()) > 1 :
+ print "Le Traducteur ne sait pas gerer"
+ assert(0)
+ MonTexte=jdc.getLines()[child.lineno-1]
+ debut=MonTexte.find("NOM_PARA")
+ debChaine=MonTexte[0:debut+8]
+ ancien=MonTexte[debut+8:]
+ egal,nomval,fin=ancien.split("'",2)
+ nouvelleLigne=debChaine+egal+"'ABSC'"+fin
+ jdc.getLines()[child.lineno-1]=nouvelleLigne
+ logging.info("renommage parametre ABSC ligne %d",child.lineno-1)
+ return
+
+#--------------------------------------------------------------------------
+def chercheValeurSelonGenea2(jdc,liste_cherche_valeur):
+#
+#--------------------------------------------------------------------------
+ liste_valeurs=[]
+ for genea in liste_cherche_valeur:
+ profondeur=len(genea)
+ if profondeur > 2 :
+ print "la methode chercheValeurSelonGenea ne convient"
+ print "pas pour cette généalogie"
+ assert(0)
+ command=genea[0]
+ fact=genea[1]
+
+ for c in jdc.root.childNodes:
+ if c.name != command:continue
+ for mc in c.childNodes:
+ if mc.name != fact:continue
+ MonTexte=mc.getText(jdc)
+ try :
+ #if ( 1) :
+ exec MonTexte in dict_contexte
+ monNomVar=MonTexte.split("=")[1]
+ monNomVarOk=monNomVar
+ i=-1
+ while (monNomVar[i] == "," or monNomVar[i] == " ") :
+ monNomVarOk=monNomVar[0:i]
+ i=i-1
+ monNomVar=monNomVarOk
+ i=0
+ while (monNomVar[i] == " ") :
+ monNomVarOk=monNomVar[1:]
+ i=i+1
+ monNomVar=monNomVarOk
+ if monNomVar not in liste_valeurs : liste_valeurs.append(monNomVar)
+ except :
+ #else :
+ logging.error("Pb pour renommer le parametre ABSC dans defi_fonctions selon calcg")
+ pass
+ return liste_valeurs
+
+
+#--------------------------------------------------------------------------
+def chercheValeurSelonGenea3(jdc,liste_cherche_valeur):
+#--------------------------------------------------------------------------
+ liste_valeurs=[]
+ for genea in liste_cherche_valeur:
+ profondeur=len(genea)
+ if profondeur > 3 :
+ print "la methode chercheValeurSelonGenea ne convient"
+ print "pas pour cette généalogie"
+ assert(0)
+ command=genea[0]
+ fact=genea[1]
+ mc=genea[2]
+
+ for c in jdc.root.childNodes:
+ if c.name != command : continue
+ for mcf in c.childNodes:
+ if mcf.name != fact : continue
+ l=mcf.childNodes[:]
+ for ll in l:
+ for lc in ll.childNodes:
+ if lc.name !=mc : continue
+ MonTexte=lc.getText(jdc)
+ try :
+ #if ( 1) :
+ exec MonTexte in dict_contexte
+ #monNomVar=MonTexte.split("=")[1][0:-1]
+ monNomVar=MonTexte.split("=")[1]
+ monNomVarOk=monNomVar
+ i=-1
+ while (monNomVar[i] == "," or monNomVar[i] == " ") :
+ monNomVarOk=monNomVar[0:i]
+ i=i-1
+ monNomVar=monNomVarOk
+ i=0
+ while (monNomVar[i] == " ") :
+ monNomVarOk=monNomVar[1:]
+ i=i+1
+ monNomVar=monNomVarOk
+ if monNomVar not in liste_valeurs : liste_valeurs.append(monNomVar)
+ except :
+ #else :
+ logging.error("Pb pour renommer le parametre ABSC dans defi_fonctions selon calcg")
+ pass
+ return liste_valeurs
+
+
--- /dev/null
+# -*- coding: utf-8 -*-
+import logging
+from dictErreurs import EcritErreur
+from dictErreurs import jdcSet
+from renamemocle import decaleLignesdeNBlancs
+from removemocle import removeMotCleInFact
+
+
+#--------------------------------------------------------------------------
+def ChangementValeur(jdc,command,motcle,DictNouvVal,liste=(),defaut=0):
+#--------------------------------------------------------------------------
+ if command not in jdcSet : return
+ boolChange=0
+ for c in jdc.root.childNodes:
+ if c.name != command : continue
+ trouveUnMC=0
+ for mc in c.childNodes:
+ if mc.name != motcle : continue
+ trouveUnMC=1
+ TexteMC=mc.getText(jdc)
+ liste_ligne_MC=TexteMC.splitlines()
+ indexLigneGlob=mc.lineno-1
+ indexTexteMC=0
+ while indexLigneGlob < mc.endline :
+ if indexTexteMC > len(liste_ligne_MC)-1 : break
+ MaLigneGlob=jdc.getLines()[indexLigneGlob]
+ MaLigneTexte=liste_ligne_MC[indexTexteMC]
+ for Valeur in DictNouvVal.keys() :
+ trouve=MaLigneTexte.find(Valeur)
+ if trouve > -1 :
+ debut=MaLigneGlob.find(motcle)
+ if debut==-1 : debut=0
+ Nouveau=MaLigneGlob[debut:].replace(Valeur,DictNouvVal[Valeur])
+ Nouveau=MaLigneGlob[0:debut]+Nouveau
+ jdc.getLines()[indexLigneGlob]=Nouveau
+ MaLigneTexte=Nouveau # raccourci honteux mais ...
+ MaLigneGlob=Nouveau
+ if Valeur in liste :
+ EcritErreur((command,motcle,Valeur),indexLigneGlob)
+ else :
+ logging.info("Changement de %s par %s dans %s ligne %d",Valeur,DictNouvVal[Valeur],command,indexLigneGlob)
+ boolChange=1
+ indexLigneGlob=indexLigneGlob+1
+ indexTexteMC=indexTexteMC+1
+ if (trouveUnMC == 0) and ( defaut == 1):
+ EcritErreur((command,motcle,"DEFAUT"),c.lineno)
+ if boolChange : jdc.reset(jdc.getSource())
+
+#--------------------------------------------------------------------------------
+def ChangementValeurDsMCF(jdc,command,fact,motcle,DictNouvVal,liste=(),defaut=0):
+#--------------------------------------------------------------------------------
+
+ if command not in jdcSet : return
+ boolChange=0
+ for c in jdc.root.childNodes:
+ if c.name != command : continue
+ for mcF in c.childNodes:
+ if mcF.name != fact : continue
+ l=mcF.childNodes[:]
+ l.reverse()
+ for ll in l:
+ trouveUnMC=0
+ for mc in ll.childNodes:
+ if mc.name != motcle:continue
+ trouveUnMC=1
+ TexteMC=mc.getText(jdc)
+ liste_ligne_MC=TexteMC.splitlines()
+ indexLigneGlob=mc.lineno-1
+ indexTexteMC=0
+ while indexLigneGlob < mc.endline :
+ if indexTexteMC > len(liste_ligne_MC)-1 : break
+ MaLigneGlob=jdc.getLines()[indexLigneGlob]
+ MaLigneTexte=liste_ligne_MC[indexTexteMC]
+ for Valeur in DictNouvVal.keys() :
+ trouve=MaLigneTexte.find(Valeur)
+ if trouve > -1 :
+ debut=MaLigneGlob.find(motcle)
+ if debut==-1 : debut=0
+ Nouveau=MaLigneGlob[debut:].replace(Valeur,DictNouvVal[Valeur])
+ Nouveau=MaLigneGlob[0:debut]+Nouveau
+ jdc.getLines()[indexLigneGlob]=Nouveau
+ MaLigneTexte=Nouveau # raccourci honteux mais ...
+ MaLigneGlob=Nouveau
+ if Valeur in liste :
+ EcritErreur((command,fact,motcle,Valeur),indexLigneGlob)
+ else :
+ logging.info("Changement de %s par %s dans %s ligne %d",Valeur,DictNouvVal[Valeur],command,indexLigneGlob)
+ boolChange=1
+ indexLigneGlob=indexLigneGlob+1
+ indexTexteMC=indexTexteMC+1
+ if (trouveUnMC == 0) and ( defaut == 1):
+ logging.warning("OPTION (defaut) de CALCG à verifier ligne %s" ,c.lineno )
+ EcritErreur((command,fact,motcle,"DEFAUT"),c.lineno)
+ if boolChange : jdc.reset(jdc.getSource())
+
+#---------------------------------------------------------------------------------------
+def ChangementValeurDsMCFAvecAvertissement(jdc, command, fact,motcle,DictNouvVal,liste):
+#---------------------------------------------------------------------------------------
+ if command not in jdcSet : return
+ defaut=0
+ if liste[-1] == "defaut" :
+ defaut=1
+ ChangementValeurDsMCF(jdc,command,fact,motcle,DictNouvVal,liste,defaut)
+
+#--------------------------------------------------------------------------
+def ChangementValeurAvecAvertissement(jdc, command,motcle,DictNouvVal,liste):
+#--------------------------------------------------------------------------
+ if command not in jdcSet : return
+ defaut=0
+ if liste[-1] == "defaut" :
+ defaut=1
+ ChangementValeur(jdc,command,motcle,DictNouvVal,liste,defaut)
+
+#--------------------------------------------------------------------------
+def SuppressionValeurs(jdc, command,motcle,liste):
+#--------------------------------------------------------------------------
+
+ if command not in jdcSet : return
+ boolChange=0
+ for c in jdc.root.childNodes:
+ if c.name != command : continue
+ for mc in c.childNodes:
+ if mc.name != motcle : continue
+ indexLigneGlob=mc.lineno-1
+ while indexLigneGlob < mc.endline :
+ MaLigneTexte = jdc.getLines()[indexLigneGlob]
+ MaLigne=MaLigneTexte
+ for Valeur in liste :
+ debutMC =MaLigne.find(motcle)
+ if debutMC ==-1 : debutMC=0
+ debut1=MaLigne[0:debutMC]
+ chercheLigne=MaLigne[debutMC:]
+ trouve=chercheLigne.find(Valeur)
+ premier=0
+ if trouve > 0 :
+ debut=debut1 + chercheLigne[0:trouve]
+ index = -1
+ while (-1 * index) < len(debut) :
+ if (debut[index] == "(") :
+ premier = 1
+ if index == -1 :
+ index=len(debut)
+ else :
+ index=index+1
+ break
+ if (debut[index] == "," ) :
+ break
+ if (debut[index] != " " ) :
+ assert(0)
+ index = index -1
+ debLigne = debut[0:index]
+ fin=trouve+len(Valeur)
+ if premier == 1 : fin = fin + 1 # on supprime la ,
+ finLigne = chercheLigne[fin:]
+ MaLigne=debLigne+finLigne
+ boolChange=1
+ jdc.getLines()[indexLigneGlob]=MaLigne
+ indexLigneGlob=indexLigneGlob+1
+ if boolChange : jdc.reset(jdc.getSource())
+
+#----------------------------------------------
+def AppelleMacroSelonValeurConcept(jdc,macro,genea):
+#----------------------------------------------
+ if macro not in jdcSet : return
+ boolChange=0
+ fact=genea[0]
+ motcle=genea[1]
+ chaine="CO"
+ for c in jdc.root.childNodes:
+ if c.name != macro : continue
+ for mcF in c.childNodes:
+ if mcF.name != fact : continue
+ l=mcF.childNodes[:]
+ l.reverse()
+ for ll in l:
+ trouveValeur=0
+ for mc in ll.childNodes:
+ if mc.name != motcle:continue
+ TexteMC=mc.getText(jdc)
+ liste_ligne_MC=TexteMC.splitlines()
+ indexLigneGlob=mc.lineno-2
+ trouveTexteMC=0
+ trouveegal=0
+ trouvechaine=0
+ trouveparent=0
+ trouvequote=0
+ while indexLigneGlob < mc.endline :
+ indexLigneGlob=indexLigneGlob+1
+ MaLigneTexte=jdc.getLines()[indexLigneGlob]
+
+ # on commence par chercher TABLE par exemple
+ # si on ne trouve pas on passe a la ligne suivante
+ if ( trouveTexteMC == 0 ) :
+ indice=MaLigneTexte.find(motcle)
+ if indice < 0 : continue
+ trouveTexteMC=1
+ else :
+ indice=0
+
+ # on cherche =
+ aChercher=MaLigneTexte[indice:]
+ if (trouveegal == 0 ):
+ indice=aChercher.find("=")
+ if indice < 0 : continue
+ trouveegal = 1
+ else :
+ indice = 0
+
+ # on cherche CO
+ aChercher2=aChercher[indice:]
+ if (trouvechaine == 0 ):
+ indice=aChercher2.find(chaine)
+ if indice < 0 : continue
+ trouvechaine = 1
+ else :
+ indice = 0
+
+ #on cherche (
+ aChercher3=aChercher2[indice:]
+ if (trouveparent == 0 ):
+ indice=aChercher3.find('(')
+ if indice < 0 : continue
+ trouveparent = 1
+ else :
+ indice = 0
+
+ #on cherche la '
+ aChercher4=aChercher3[indice:]
+ if (trouvequote == 0 ):
+ indice=aChercher4.find("'")
+ indice2=aChercher4.find('"')
+ if (indice < 0) and (indice2 < 0): continue
+ if (indice < 0) : indice=indice2
+ trouvequote = 1
+ else :
+ indice = 0
+
+ trouveValeur=1
+ aChercher5=aChercher4[indice+1:]
+ indice=aChercher5.find("'")
+ if indice < 0 : indice=aChercher5.find('"')
+ valeur=aChercher5[:indice]
+ break
+
+ if trouveValeur==0 :
+ logging.error("Pb de traduction pour MACR_LIGNE_COUPE : Pas de nom de Concept identifiable")
+ return
+
+ if boolChange :
+ jdc.reset(jdc.getSource())
+ logging.error("Pb du traduction pour MACR_LIGNE_COUPE : Deux noms de Concept possibles")
+ return
+
+ boolChange=1
+ ligneaTraiter=jdc.getLines()[c.lineno-1]
+ debut=ligneaTraiter[0:c.colno]
+ suite=valeur+"="
+ fin=ligneaTraiter[c.colno:]
+ ligne=debut+suite+fin
+ jdc.getLines()[c.lineno-1]=ligne
+ nbBlanc=len(valeur)+1
+ if c.lineno < c.endline:
+ decaleLignesdeNBlancs(jdc,c.lineno,c.endline-1,nbBlanc)
+ if boolChange : jdc.reset(jdc.getSource())
+
+#----------------------------------------------
+def ChangeTouteValeur(jdc,command,motcle,DictNouvVal,liste=(),defaut=0):
+#----------------------------------------------
+ if macro not in jdcSet : return
+ boolChange=0
--- /dev/null
+# -*- coding: utf-8 -*-
+
+import logging
+import sets
+
+jdcSet=sets.Set()
+
+dict_erreurs={
+ "DIST_LIGN_3D": "la commande DIST_LIGN_3D a ete supprimee",
+ "DEFI_THER_JOULE": "la commande DIST_LIGN_3D a ete supprimee",
+ "DIST_LIGN_3D": "la commande DIST_LIGN_3D a ete supprimee",
+ "AFFE_MODELE_AFFE": "Les modelisations APPUI_REP, ASSE_GRIL et 3D_JOINT_CT ont ete supprimees",
+ "AFFE_CHAR_MECA_CONTACT_FROTTEMENT": "Suppression d un mot clef FROTTEMENT",
+ "AFFE_CHAR_MECA_SECH_CALCULEE": "le sechage est maintenant une variable de commande",
+ "AFFE_CHAR_MECA_HYDR_CALCULEE": "l'hydratation est maintenant une variable de commande",
+ "AFFE_CHAR_MECA_EPSA_CALCULEE":"EPSA est maintenant une variable de commande",
+ "AFFE_CHAR_MECA_PRESSION_CALCULEE":"PRESSION_CALCULEE est remplace par EVOL_CHAR",
+ "MACR_LIGN_COUPE" : "MACR_LIGN_COUPE demande un traitement manuel",
+ "POST_RCCM" : "POST_RCCM demande un traitement manuel",
+ "DEFI_MATERIAU_CHABOCHE" : "remplacer la valeur CINx_CHAB",
+ "DEFI_MATERIAU_POLY_CFC" : "le materiau POLY_CFC est remplace par le comportement POLYCRISTAL",
+ "DEFI_MATERIAU_ECOU_PLAS1" : "le materiau ECOU_PLAS1 est supprime",
+ "DEFI_MATERIAU_COMP_THM_ELAS_THM" : "le materiau ELAS_THM a ete supprime",
+ "DEFI_MATERIAU_COMP_THM_SURF_ETAT_SATU" : "le materiau SURF_ETAT_SATU a ete supprime",
+ "DEFI_MATERIAU_COMP_THM_SURF_ETAT_NSAT" : "le materiau SURF_ETAT_NSAT a ete supprime",
+ "DEFI_MATERIAU_COMP_THM_CAM_CLAY_THM" : "le materiau CAM_CLAY_THM a ete supprime",
+ "DEFI_MATERIAU_COMP_THM_LIQU_SATU_GAT" : "le materiau LIQU_SATU_GAT a ete supprime",
+ "DEFI_MATERIAU_COMP_THM_LIQU_NSAT_GAT" : "le materiau LIQU_NSAT_GAT a ete supprime",
+ "DEFI_MATERIAU_GLRC" : "le materiau GLRC a ete remplace par GLRC_DAMAGE",
+ "DEFI_MATERIAU_OHNO" : "le materiau OHNO a ete remplace par TAHERI",
+ "DEFI_MATERIAU_OHNO_FO" : "le materiau OHNO a ete remplace par TAHERI",
+ "CALC_CHAM_ELEM":"reecrire la partie SOUR_ELGA_ELEC",
+ "CALC_G_THETA_T_OPTION_VALEUR":"verifier la valeur d OPTION",
+ "CALC_G_THETA_T_OPTION_DEFAUT":"verifier la valeur d OPTION donnee a la place du defaut",
+ "CALC_G_MODELE":"Mot Clef MODELE supprimé sous CALC_G",
+ "CALC_G_DEPL":"Mot Clef DEPL supprimé sous CALC_G",
+ "CALC_G_CHAM_MATER":"Mot Clef CHAM_MATER supprimé sous CALC_G",
+ "CALC_G_CARA_ELEM":"Mot Clef CARA_ELEM supprimé sous CALC_G",
+ "CALC_G_RESULTAT=XXX,":"Mot Clef RESULTAT à completer sous CALC_G",
+ "AFFE_MODELE_AFFE_MODELISATION_VALEUR":"verifier la valeur de MODELISATION",
+ "STAT_NON_LINE_COMP_INCR_RELATION_VALEUR":"verifier la valeur de RELATION",
+ "STAT_NON_LINE_COMP_INCR_RELATION_KIT_VALEUR":"verifier la valeur de RELATION_KIT",
+ "STAT_NON_LINE_VARI_COMM":"suppression des variables de commande",
+ "STAT_NON_LINE_INCREMENT_SUBD_PAS":"Si SUBD_PAS=1 il n'y a pas subdivision : le mot est clef est ote du STAT_NON_LINE",
+ "DYNA_NON_LINE_COMP_INCR_RELATION_VALEUR":"verifier la valeur de RELATION",
+ "DYNA_NON_LINE_COMP_INCR_RELATION_KIT_VALEUR":"verifier la valeur de RELATION_KIT",
+ "DYNA_NON_LINE_VARI_COMM":"suppression des variables de commande",
+ "DYNA_NON_LINE_INCREMENT_SUBD_PAS":"Si SUBD_PAS=1 il n'y a pas subdivision : le mot est clef est ote du DYNA_NON_LINE",
+ "CALC_PRECONT_SUBD_PAS":"Si SUBD_PAS=1 il n'y a pas subdivision : le mot est clef est ote du CALC_PRECONT",
+ "TEST_RESU_UNITE":"suppression du mot clef UNITE dans TEST_RESU",
+ "AFFE_MODELE_AFFE":"suppression de AFFE (ancien mot clef APPUI_REP)",
+ "POST_SIMPLIFIE":"commande POST_SIMPLIFIE supprimee",
+ "POST_DYNA_ALEA_GAUSS":"la methode GAUSS a ete supprimee de POST_DYNA_ALEA",
+ "POST_DYNA_ALEA_VANMARCKE":"la methode VANMARCKE a ete supprimee de POST_DYNA_ALEA",
+ "POST_DYNA_ALEA_DEPASSEMENT":"la methode DEPASSEMENT a ete supprimee de POST_DYNA_ALEA",
+ "POST_DYNA_ALEA_RAYLEIGH":"la methode RAYLEIGH a ete supprimee de POST_DYNA_ALEA",
+ "DYNA_TRAN_MODAL_EXCIT_NUME_MODE":"le numero du mode utilise pour EXCIT DYNA_TRAN_MODAL est le numero d'ORDRE",
+ "DEFI_INTERF_DYNA_INTERFACE_DDL_ACTIF":"DDL_ACTIF supprime de DEFI_INTERF_DYNA; utiliser MASQUE",
+ "DEFI_TEXTURE":"le materiau POLY_CFC est remplace par le comportement POLYCRISTAL",
+ "CREA_RESU_NOM_CHAM_VALEUR":"HYDR_ELGA est remplace par HYDR_ELNO_ELGA et HYDR_NOEU_ELGA",
+ "COMB_CHAM_NO":"COMB_CHAM_NO est remplace par CREA_CHAMP",
+ "COMB_CHAM_ELEM":"COMB_CHAM_ELEM est remplace par CREA_CHAMP",
+ "IMPR_OAR":"IMPR_OAR doit etre traduit manuellement",
+ "IMPR_FICO_HOMARD":"IMPR_FICO_HOMARD a ete integre dans MACR_ADPA_MAIL",
+ }
+
+def EcritErreur(listeGena,ligne=None) :
+ maCle=""
+ for Mot in listeGena :
+ maCle=maCle+"_"+Mot
+ #try :
+ if ( 1 == 1) :
+ maClef=maCle[1:]
+ if maClef in dict_erreurs.keys() :
+ if ligne != None :
+ logging.warning("ligne %d : %s ligne ",ligne,dict_erreurs[maClef])
+ else :
+ logging.warning("%s",dict_erreurs[maClef])
+ else :
+ maCle=""
+ for Mot in listeGena[:-1] :
+ maCle=maCle+"_"+Mot
+ maClef=maCle[1:]
+ maClef=maCle+"_"+"VALEUR"
+ if maClef in dict_erreurs.keys() :
+ if ligne != None :
+ logging.warning("ligne %d : %s ligne ",ligne,dict_erreurs[maClef])
+ else :
+ logging.warning("%s",dict_erreurs[maClef])
+ #except :
+ # pass
+
+def GenereErreurPourCommande(jdc,listeCommande) :
+ commands= jdc.root.childNodes[:]
+ commands.reverse()
+ for c in commands:
+ jdcSet.add(c.name)
+ for Mot in listeCommande :
+ if c.name != Mot :continue
+ EcritErreur((Mot,),c.lineno)
+
# -*- coding: utf-8 -*-
import logging
from parseur import FactNode
+from dictErreurs import jdcSet
+from dictErreurs import EcritErreur
import string
-debug=1
+import regles
+debug=0
#-----------------------------------
-def inseremotcle(jdc,recepteur,texte):
+def insereMotCle(jdc,recepteur,texte):
#-----------------------------------
# appelle la methode selon la classe
# du recepteur
+ if recepteur.name not in jdcSet : return
if recepteur.__class__.__name__ == "Command" :
if debug : print " Ajout de ", texte, "dans la commande : " ,recepteur.name
- inseremotcleincommand(jdc,recepteur,texte)
+ insereMotCleDansCommande(jdc,recepteur,texte)
return
#--------------------------------------------
-def inseremotcleincommand(jdc,command,texte):
+def insereMotCleDansCommande(jdc,command,texte):
#---------------------------------------------
# insere le texte comme 1er mot cle
# de la commande
- if debug : print "inseremotcle ", texte , " dans ", command.name
- numcol=chercheDebut1mot(jdc,command)
+ if command.name not in jdcSet : return
+ if debug : print "insereMotCle ", texte , " dans ", command.name
+ numcol=chercheDebut1Mot(jdc,command)
if numcol > 0 :
jdc.splitLine(command.lineno,numcol)
- debut=chercheAlignement(jdc,command)
- texte=debut+texte+"\n"
+ indice = -1
+ while texte[indice] == " " :
+ indice = indice -1
+ if texte[indice] != "," : texte=texte+","
+ texteinfo=texte
+ texte=texte+'\n'
jdc.addLine(texte,command.lineno)
+ logging.info("Insertion de : %s ligne %d", texteinfo,command.lineno)
if numcol > 0 : # Les mots clefs etaient sur la même ligne
jdc.joinLineandNext(command.lineno)
#---------------------------------------------
-def inseremotcleinfacteur(jdc,facteur,texte):
+def insereMotCleDansFacteur(jdc,facteur,texte):
#-------------------------------------------------
- if debug : print "inseremotcle ", texte , " dans ", facteur.name
- ancien=jdc.getLine(facteur.lineno )
- # On va chercher la dernier ) pour ajouter avant
+ if debug : print "insereMotCle ", texte , " dans ", facteur.name
+
+ if texte[-1] == "\n" : texte=texte[0:-1]
+ ancien=jdc.getLine(facteur.lineno)
+
+ # On va chercher la derniere ) pour ajouter avant
# on va verifier s il il y a un , avant
- ligne,col,boolvirgule=chercheDerniereParenthese(jdc,facteur)
- if col > 0 :
- jdc.splitLine(ligne,col)
- if boolvirgule == 0 :
- jdc.addLine(",\n",ligne)
- jdc.joinLineandNext(ligne)
- debut=ancien.find("_F") + 3
- aligne=debut*" "
+ # si le texte ne finit pas par une ","
+ # on en met une
+
+ indice = -1
+ while texte[indice] == " " :
+ indice = indice -1
+ if texte[indice] != "," : texte=texte+","
+ texteinfo=texte
+ texte=texte+"\n"
+
+ ligneaCouper=facteur.lineno
+ trouve=0
+ trouveF=0
+ trouveP=0
+ while ligneaCouper < facteur.endline + 1 :
+ indiceDeCoupe=0
+ while ancien.find("_F") > 0 :
+ longueur=len(ancien)
+ indice=ancien.find("_F")
+ indiceParcours=0
+ # pour ne pas tenir compte des autres noms
+ # Attention si 2 MCF sur la meme ligne (la 1ere)
+ if trouveF == 0 :
+ if ((ligneaCouper!=facteur.lineno) or ((ancien.find(facteur.name) < indice ) or (ancien.find(facteur.name) < 0))) :
+ trouveF=1
+ indiceParcours=indice + 2
+ # attention pour regler DEFI_FONCTION ..
+ else :
+ indiceDeCoupe=indiceDeCoupe+indice+2
+ ancien=ancien[indice +2:]
+ continue
+
+ if trouveF == 1 :
+ indiceDeCoupe=indiceDeCoupe+indice
+ # print "indice de Parcours" ,indiceParcours
+ # print ancien[indiceParcours]
+ # print ancien[indiceParcours+1]
+ # print ancien[indiceParcours+2]
+ while indiceParcours < longueur :
+ if ancien[indiceParcours] == "(" :
+ trouveP=1
+ # print "trouve"
+ break
+ if ancien[indiceParcours] != " " :
+ trouveP=0
+ # print "mouv"
+ break
+ indiceParcours = indiceParcours+1
+ trouve = trouveP * trouveF
+ if trouve : break
+ ancien=ancien[indice+1:]
+
+ trouve = trouveP * trouveF
+ if trouve : break
+ ligneaCouper=ligneaCouper+1
+ ancien=jdc.getLine(ligneaCouper)
+
+ if trouve :
+ debut=indiceDeCoupe + 3
+ jdc.splitLine(ligneaCouper,debut)
+ else :
+ print "Le traducteur ne sait pas faire"
+ assert 0
+
# enleve les blancs en debut de texte
i = 0
while i < len(texte) :
if texte[i] != " " : break
i = i +1
- texte=aligne+texte+"\n"
- jdc.addLine(texte,ligne)
- jdc.joinLineandNext(ligne+1)
-
-#---------------------------------------
-def chercheDerniereParenthese(jdc,facteur):
-#---------------------------------------
- ligne=facteur.endline-1
- col=-1
- boolvirgule=0
- trouveParent=0
- while ( trouveParent == 0) :
- texte=jdc.getLine(ligne)
- col=texte.rfind(")")
- if col < 0 :
- ligne=ligne-1
- else :
- trouveParent=1
- indice=col -1
- while ( indice > -1 and texte[indice] == " " ):
- indice = indice -1
- if texte[indice]=="," :
- boolvirgule = 1
- return (ligne,col,boolvirgule)
+
+ jdc.addLine(texte,ligneaCouper)
+ jdc.joinLineandNext(ligneaCouper)
+ logging.info("Insertion de %s ligne %d", texteinfo,ligneaCouper)
+ # Gestion du cas particulier du mot clef facteur vide
+ if facteur.childNodes == []:
+ jdc.joinLineandNext(facteur.lineno)
+
#-----------------------------------
-def chercheDebut1mot(jdc,command):
+def chercheDebut1Mot(jdc,command):
#-----------------------------------
# Retourne le numero de colonne si le 1er mot clef est
# sur la meme ligne que le mot clef facteur
if node1.lineno == command.lineno :
debut=node1.colno
else:
- debut=chercheDebutfacteur(jdc,command)
+ debut=chercheDebutFacteur(jdc,command)
if debut == -1 and debug : print "attention!!! pb pour trouver le debut dans ", command
return debut
#-----------------------------------
-def chercheDebutfacteur(jdc,facteur):
+def chercheDebutFacteur(jdc,facteur):
#-----------------------------------
debut=-1
ligne=jdc.getLines()[facteur.lineno]
return debut
-
#-----------------------------------
def chercheAlignement(jdc,command):
#-----------------------------------
nbBlanc=node1.colno
return " "*nbBlanc
+#---------------------------------------------------------------------------------------------------------
+def chercheOperInsereFacteur(jdc,nomcommande,nouveau,ensemble=regles.SansRegle, estunFacteur=1, erreur=0):
+#--------------------------------------------------------------------------------------------------------
+# Cherche l oper
+# cree le texte
+# appelle insereMotCle pour ajouter le texte
+#
+ boolChange=0
+ if estunFacteur :
+ texte=nouveau+"=_F(),"
+ else :
+ texte=nouveau
+ if nomcommande not in jdcSet : return
+ commands= jdc.root.childNodes[:]
+ commands.reverse()
+ for c in commands:
+ if c.name != nomcommande:continue
+ if ensemble.verif(c) == 0 : continue
+ if erreur : EcritErreur((nomcommande,nouveau),c.lineno)
+ boolChange=1
+ insereMotCle(jdc,c,texte)
+ if boolChange : jdc.reset(jdc.getSource())
+
+#----------------------------------------------------------------------------------------
+def chercheOperInsereFacteurSiRegle(jdc,nomcommande,nouveau,liste_regles, estunFacteur=1):
+#----------------------------------------------------------------------------------------
+# Cherche l oper
+# cree le texte
+# appelle insereMotCle pour ajouter le texte
+#
+ if nomcommande not in jdcSet : return
+ mesRegles=regles.ensembleRegles(liste_regles)
+ chercheOperInsereFacteur(jdc,nomcommande,nouveau,mesRegles,estunFacteur)
+
+#---------------------------------------------------------------------------------------------------------
+def chercheOperInsereFacteurSiRegleAvecAvertissement(jdc,nomcommande,nouveau,liste_regles, estunFacteur=1):
+#---------------------------------------------------------------------------------------------------------
+ if nomcommande not in jdcSet : return
+ mesRegles=regles.ensembleRegles(liste_regles)
+ chercheOperInsereFacteur(jdc,nomcommande,nouveau,mesRegles,estunFacteur,erreur=1)
+
+#-------------------------------------------------------------------------------------------------
+def AjouteMotClefDansFacteur(jdc,commande,fact,nouveau,ensemble=regles.SansRegle, estunFacteur=0):
+#-------------------------------------------------------------------------------------------------
+# Cherche la commande
+# Cherche le MCF
+# cree le texte
+# appelle insereMotCle pour ajouter le texte
+#
+ if commande not in jdcSet : return
+ if estunFacteur :
+ texte=nouveau+"=_F(),"
+ else :
+ texte=nouveau
+ commands= jdc.root.childNodes[:]
+ commands.reverse()
+ boolChange=0
+ for c in commands:
+ if c.name != commande : continue
+ for mcF in c.childNodes:
+ if mcF.name != fact : continue
+ if ensemble.verif(c) == 0 : continue
+ l=mcF.childNodes[:]
+ l.reverse()
+ boolChange=1
+ insereMotCleDansFacteur(jdc,mcF,texte)
+ if boolChange : jdc.reset(jdc.getSource())
+
+#-------------------------------------------------------------------------------------------
+def AjouteMotClefDansFacteurSiRegle(jdc,commande,fact,nouveau,liste_regles,estunFacteur=0):
+#-------------------------------------------------------------------------------------------
+#
+ if commande not in jdcSet : return
+ mesRegles=regles.ensembleRegles(liste_regles)
+ AjouteMotClefDansFacteur(jdc,commande,fact,nouveau,mesRegles,estunFacteur)
+++ /dev/null
-# -*- coding: utf-8 -*-
-
-import log
-
-from load import getJDC
-from mocles import parseKeywords
-import removemocle
-import renamemocle
-import movemocle
-
-#atraiter=("DEBUT","LIRE_MAILLAGE","AFFE_MODELE","DEFI_GROUP",
-# "AFFE_MATERIAU","DEFI_MATERIAU","STAT_NONLINE",
-# )
-
-atraiter=("CALC_FONCTION","IMPR_GENE","STAT_NON_LINE","DEFI_MATERIAU")
-filename="toto.comm"
-jdc=getJDC(filename,atraiter)
-root=jdc.root
-
-#Parse les mocles des commandes
-parseKeywords(root)
-
-#removemocle.removemocleinfact(jdc,"AFFE_MATERIAU","AFFE","TOUT")
-#removemocle.removemocle(jdc,"STAT_NONLINE","SOLVEUR")
-#renamemocle.renamemocleinfact(jdc,"AFFE_MODELE","AFFE","PHENOMENE","TOTO")
-#renamemocle.renamemocleinfact(jdc,"AFFE_MODELE","AFFE","MODELISATION","TITI")
-#renamemocle.renamemocleinfact(jdc,"DEFI_GROUP","CREA_GROUP_NO","GROUP_MA","TUTU")
-#removemocle.removemocle(jdc,"LIRE_MAILLAGE","INFO")
-#removemocle.removemocle(jdc,"LIRE_MAILLAGE","UNITE")
-#renamemocle.renamemocle(jdc,"DEFI_MATERIAU","ELAS","ELASTIC")
-#renamemocle.renamemocle(jdc,"AFFE_MATERIAU","MAILLAGE","MAILL")
-#removemocle.removemocleinfact(jdc,"STAT_NONLINE","SOLV","METHOD")
-#removemocle.removemocle(jdc,"STAT_NONLINE","AFFE")
-#renamemocle.renamecommande(jdc,"AFFE_CHAR_MECA","AFFE_CHAR_MECA_PN")
-#renamemocle.renamecommande(jdc,"DEBUT","DEBUT_PN")
-
-# les arguments sont jdc,ancien-nom-de-commande,nouveau-nom-de-commande
-renamemocle.renamecommande(jdc,"CALC_FONCTION","INFO_FONCTION")
-
-# Les arguments sont - jdc,
-# - nom de la procedure (pas teste avec autre chose)
-# - nom du mot clef facteur contenant,
-# - nom du mot cle simple
-# Attention ne fonctionne pas pour l instant avec +sieurs occurences du mot cle à déplacer
-movemocle.movemoclefromfacttofather(jdc,"IMPR_GENE","GENE","UNITE")
-movemocle.movemoclefromfacttofather(jdc,"IMPR_GENE","GENE","FORMAT")
-
-# Les arguments sont - jdc
-# - nom de l operateur (pas teste avec autre chose)
-# - nom du mot clef facteur source,
-# - nom du mot cle simple
-# - liste de mots clef facteur arrivée possible
-# Attention ne fonctionne pas pour l instant avec +sieurs occurences du mot cle à déplacer
-movemocle.movemoclefromfacttofactmulti(jdc,"STAT_NON_LINE","CONVERGENCE","RESI_INTE_RELA",("COMP_INCR","COMP_ELAS"))
-
-
-renamemocle.renamemocle(jdc,"DEFI_MATERIAU","LEMAITRE","LEMAITRE_IRRA")
-movemocle.movemoclefromfacttofactmulti(jdc,"DEFI_MATERIAU","FLU_IRRA","QSR_K",("LEMAITRE_IRRA",))
-movemocle.movemoclefromfacttofactmulti(jdc,"DEFI_MATERIAU","FLU_IRRA","BETA",("LEMAITRE_IRRA",))
-movemocle.movemoclefromfacttofactmulti(jdc,"DEFI_MATERIAU","FLU_IRRA","PHI_ZERO",("LEMAITRE_IRRA",))
-movemocle.movemoclefromfacttofactmulti(jdc,"DEFI_MATERIAU","FLU_IRRA","L",("LEMAITRE_IRRA",))
-removemocle.removemocle(jdc,"DEFI_MATERIAU","FLU_IRRA")
-
-renamemocle.renamemocleinfact(jdc,"DEFI_MATERIAU","GRAN_IRRA","A","GRAN_A")
-renamemocle.renamemocleinfact(jdc,"DEFI_MATERIAU","GRAN_IRRA","B","GRAN_B")
-renamemocle.renamemocleinfact(jdc,"DEFI_MATERIAU","GRAN_IRRA","S","GRAN_S")
-movemocle.movemoclefromfacttofactmulti(jdc,"DEFI_MATERIAU","GRAN_IRRA","GRAN_A",("LEMAITRE_IRRA",))
-movemocle.movemoclefromfacttofactmulti(jdc,"DEFI_MATERIAU","GRAN_IRRA","GRAN_B",("LEMAITRE_IRRA",))
-movemocle.movemoclefromfacttofactmulti(jdc,"DEFI_MATERIAU","GRAN_IRRA","GRAN_S",("LEMAITRE_IRRA",))
-removemocle.removemocle(jdc,"DEFI_MATERIAU","GRAN_IRRA")
-
-
-f=open("tutu.comm",'w')
-f.write(jdc.getSource())
-f.close()
# -*- coding: utf-8 -*-
import os
+import re
import parseur
from mocles import parseKeywords
def init(self,src,atraiter):
#---------------------------
# construction de self.lines
- self.root=parseur.parser(src,atraiter)
+ self.root=parseur.Parser(src,atraiter)
self.lines=src.splitlines(1)
def parseKeywords(self):
Lmilieu=[ligne,]
Lfin=self.lines[numero:]
self.lines=Ldebut+Lmilieu+Lfin
- src=self.getSource()
- self.reset(src)
+
def splitLine(self,numeroLigne,numeroColonne) :
#----------------------------------------------
Lmilieu=[LigneSplitDebut,LigneSplitFin]
self.lines=Ldebut+Lmilieu+Lfin
- src=self.getSource()
- self.reset(src)
def joinLineandNext(self,numeroLigne) :
#--------------------------------------
Lmilieu=[ligneMilieuDeb+ligneMilieuFin,]
self.lines=Ldebut+Lmilieu+Lfin
- src=self.getSource()
- self.reset(src)
+
+ def supLignes(self,debut,fin):
+ #------------------------
+ Ldebut=self.lines[0:debut-1]
+ Lfin=self.lines[fin:]
+ self.lines=Ldebut+Lfin
+
+ def remplaceLine(self,numeroLigne,nouveauTexte) :
+ #------------------------------------------------
+ self.lines[numeroLigne]=nouveauTexte
def getJDC(filename,atraiter):
#---------------------------_
import logging
logger=logging.getLogger()
-hdlr=logging.FileHandler('convert.log','w')
-#formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
-formatter = logging.Formatter('%(levelname)s: %(message)s')
-hdlr.setFormatter(formatter)
-logger.addHandler(hdlr)
-logger.setLevel(logging.INFO)
+
+def initialise() :
+ hdlr=logging.FileHandler('/tmp/convert.log','w')
+ formatter = logging.Formatter('%(levelname)s: %(message)s')
+ hdlr.setFormatter(formatter)
+ logger.addHandler(hdlr)
+ logger.setLevel(logging.INFO)
+ return hdlr
+
+
+def ferme (hdlr) :
+ logger.removeHandler(hdlr)
import compiler
import types
-from parseur import Keyword,FactNode,lastparen,lastparen2
-from visiteur import KeywordFinder,visitor
-from utils import indexToCoordinates
+from parseur import Keyword, FactNode, lastparen, lastparen2,maskStringsAndComments
+from visiteur import KeywordFinder, visitor
+from utils import indexToCoordinates
+import traceback
debug=0
+#------------------------
def parseFact(match,c,kw):
+#------------------------
submatch=match[2]
lastpar=match[0]+lastparen(c.src[match[0]:])
if type(submatch[0][0]) ==types.IntType:
no.addChild(Keyword(e[1],lineno,colno,endline,endcol))
+#-----------------------
def parseKeywords(root):
- """A partir d'un arbre contenant des commandes, ajoute les noeuds fils correspondant aux mocles
- de la commande
+#-----------------------
+ """A partir d'un arbre contenant des commandes, ajoute les noeuds
+ fils correspondant aux mocles de la commande
"""
+ #print "parseKeywords"
+ #traceback.print_stack(limit=5)
+
matchFinder=KeywordFinder()
for c in root.childNodes:
- ast=compiler.parse(c.src)
+ maskedsrc=maskStringsAndComments(c.src)
+ #on supprime seulement les blancs du debut pour pouvoir compiler
+ #meme si la commande est sur plusieurs lignes seul le debut compte
+ ast=compiler.parse(c.src.lstrip())
#print ast
- matchFinder.reset(c.src)
+ #Ne pas supprimer les blancs du debut pour avoir les bons numeros de colonne
+ matchFinder.reset(maskedsrc)
visitor.walk(ast, matchFinder)
#print matchFinder.matches
if len(matchFinder.matches) > 1:
- #plusieurs mocles trouvés : un mocle commence au début du keyword (matchFinder.matches[i][0])
- # et finit juste avant le keyword suivant (matchFinder.matches[i+1][0]])
+ # plusieurs mocles trouvés :
+ # un mocle commence au début du keyword (matchFinder.matches[i][0])
+ # et finit juste avant le keyword suivant
+ # (matchFinder.matches[i+1][0]])
for i in range(len(matchFinder.matches)-1):
if debug:print "texte:",c.src[matchFinder.matches[i][0]:matchFinder.matches[i+1][0]]
x,y=indexToCoordinates(c.src,matchFinder.matches[i][0])
submatch= matchFinder.matches[i][2]
if submatch:
parseFact(matchFinder.matches[i],c,kw)
- #dernier mocle : il commence au debut du dernier keyword (matchFinder.matches[i+1][0]) et
- #finit avant la parenthese fermante de la commande (c.lastparen)
+
+ # dernier mocle :
+ # il commence au debut du dernier keyword
+ # (matchFinder.matches[i+1][0]) et
+ # finit avant la parenthese fermante de la commande (c.lastparen)
+
if debug:print "texte:",c.src[matchFinder.matches[i+1][0]:c.lastparen]
x,y=indexToCoordinates(c.src,matchFinder.matches[i+1][0])
lineno=y+c.lineno
parseFact(matchFinder.matches[i+1],c,kw)
elif len(matchFinder.matches) == 1:
- #un seul mocle trouve : il commence au début du keyword (matchFinder.matches[0][0]) et
- #finit juste avant la parenthese fermante de la commande (c.lastparen)
+ #un seul mocle trouve :
+ # il commence au début du keyword (matchFinder.matches[0][0]) et
+ # finit juste avant la parenthese fermante de la
+ # commande (c.lastparen)
if debug:print "texte:",c.src[matchFinder.matches[0][0]:c.lastparen]
x,y=indexToCoordinates(c.src,matchFinder.matches[0][0])
lineno=y+c.lineno
import removemocle
import inseremocle
from parseur import FactNode
-debug=1
+from dictErreurs import jdcSet
+debug=0
-def movemoclefromfacttofather(jdc,command,fact,mocle):
+#-----------------------------------------------------
+def moveMotCleFromFactToFather(jdc,command,fact,mocle):
+#-----------------------------------------------------
# exemple type : IMPR_GENE
- for c in jdc.root.childNodes:
+
+ if command not in jdcSet : return
+ boolChange=0
+ commands= jdc.root.childNodes[:]
+ commands.reverse()
+ for c in commands:
if c.name != command:continue
for mc in c.childNodes:
if mc.name != fact:continue
if n.name != mocle:continue
if debug : print "Changement de place :", n.name, n.lineno, n.colno
MonTexte=n.getText(jdc);
- inseremocle.inseremotcle(jdc,c,MonTexte)
- logging.info("Changement de place : %s,%s, %s ",n.name, n.lineno, n.colno)
+ boolChange=1
+ inseremocle.insereMotCle(jdc,c,MonTexte)
+ logging.info("Changement de place %s ligne %s ",n.name, n.lineno)
- removemocle.removemocleinfact(jdc,command,fact,mocle)
+ if boolChange : jdc.reset(jdc.getSource())
+ removemocle.removeMotCleInFact(jdc,command,fact,mocle)
+
-def movemoclefromfacttofactmulti(jdc,oper,factsource,mocle,liste_factcible):
+#----------------------------------------------------------------------------
+def moveMotCleFromFactToFactMulti(jdc,oper,factsource,mocle,liste_factcible):
+#----------------------------------------------------------------------------
# exemple type STAT_NON_LINE et RESI_INTER_RELA
for factcible in liste_factcible :
- movemoclefromfacttofact(jdc,oper,factsource,mocle,factcible)
- removemocle.removemocleinfact(jdc,oper,factsource,mocle)
+ moveMotCleFromFactToFact(jdc,oper,factsource,mocle,factcible)
+ removemocle.removeMotCleInFact(jdc,oper,factsource,mocle)
-def movemoclefromfacttofact(jdc,oper,factsource,mocle,factcible):
- if debug : print "movemoclefromfacttofact pour " ,oper,factsource,mocle,factcible
- for c in jdc.root.childNodes:
+#----------------------------------------------------------------------------
+def moveMotCleFromFactToFact(jdc,oper,factsource,mocle,factcible):
+#----------------------------------------------------------------------------
+ if oper not in jdcSet : return
+ if debug : print "moveMotCleFromFactToFact pour " ,oper,factsource,mocle,factcible
+ boolChange=0
+ commands= jdc.root.childNodes[:]
+ commands.reverse()
+ for c in commands:
if c.name != oper : continue
cible=None
for mc in c.childNodes:
cible=mc
break
if cible==None :
- logging.info("Pas de changement pour %s,%s,%s", oper, factsource,mocle)
- logging.info("Le mot clef cible %s n est pas présent", factcible)
if debug : print "Pas de changement pour ", oper, " ", factsource, " ",mocle, "cible non trouvée"
continue
source=mc
break
if source==None :
- logging.info("Pas de changement pour %s,%s,%s", oper, factsource,mocle)
- logging.info("Le mot clef source %s n est pas présent", factsource)
if debug : print "Pas de changement pour ", oper, " ", factsource, " ",mocle, "source non trouvée"
continue
for n in ll.childNodes:
if n.name != mocle:continue
MonTexte=n.getText(jdc);
- inseremocle.inseremotcleinfacteur(jdc,cible,MonTexte)
- logging.info("Changement de place : %s,%s, %s ",n.name, n.lineno, n.colno)
- logging.info("vers : %s", cible.name)
+ inseremocle.insereMotCleDansFacteur(jdc,cible,MonTexte)
+ boolChange=1
+ logging.info("Changement de place %s ligne %s vers %s",n.name, n.lineno, cible.name)
+ if boolChange : jdc.reset(jdc.getSource())
+
+
+
+
+#------------------------------------------------------
+def moveMotClefInOperToFact(jdc,oper,mocle,factcible):
+#------------------------------------------------------
+# Attention le cas type est THETA_OLD dans calc_G
+
+ if oper not in jdcSet : return
+ if debug : print "movemocleinoper pour " ,oper,mocle,factcible
+ boolChange=9
+ commands= jdc.root.childNodes[:]
+ commands.reverse()
+ for c in commands:
+ if c.name != oper : continue
+ cible=None
+ for mc in c.childNodes:
+ if mc.name != factcible :
+ continue
+ else :
+ cible=mc
+ break
+ if cible==None :
+ if debug : print "Pas de changement pour ", oper, " ", factcible, " ", "cible non trouvée"
+ continue
+ source=None
+ for mc in c.childNodes:
+ if mc.name != mocle:
+ continue
+ else :
+ source=mc
+ break
+ if source==None :
+ if debug : print "Pas de changement pour ", oper, " ", mocle, " source non trouvée"
+ continue
+ MonTexte=source.getText(jdc);
+ boolChange=1
+ inseremocle.insereMotCleDansFacteur(jdc,cible,MonTexte)
+ if boolChange : jdc.reset(jdc.getSource())
+ removemocle.removeMotCle(jdc,oper,mocle)
allcharsExceptNewline = allchars[: allchars.index('\n')]+allchars[allchars.index('\n')+1:]
allcharsExceptNewlineTranstable = string.maketrans(allcharsExceptNewline, '*'*len(allcharsExceptNewline))
+#------------------------------
def maskStringsAndComments(src):
+#------------------------------
"""Remplace tous les caracteres dans commentaires et strings par des * """
+
src = escapedQuotesRE.sub("**", src)
allstrings = stringsAndCommentsRE.split(src)
# every odd element is a string or comment
linecontinueRE = re.compile(r"\\\s*(#.*)?$")
emptyHangingBraces = [0,0,0,0,0]
+#--------------------------------------
class UnbalancedBracesException: pass
+#--------------------------------------
+#-----------
class Node:
+#-----------
def __init__(self):
self.childNodes=[]
self.childNodes.append(node)
-class FactNode(Node):pass
+#-------------------
+class FactNode(Node):
+#-------------------
+ pass
+
+
+#-------------------
class JDCNode(Node):
+#-------------------
def __init__(self,src):
Node.__init__(self)
self.src=src
+#-------------------
class Command(Node):
+#-------------------
def __init__(self,name,lineno,colno,firstparen):
Node.__init__(self)
self.name=name
self.colno=colno
self.firstparen=firstparen
+#-------------------
class Keyword(Node):
+#-------------------
def __init__(self,name,lineno,colno,endline,endcol):
Node.__init__(self)
self.name=name
def getText(self,jdc):
if self.endline > self.lineno:
- lignecourante=self.lineno + 1
debut=jdc.getLines()[self.lineno-1][self.colno:]
fin = jdc.getLines()[self.endline-1][:self.endcol]
texte=debut
- lignecourante=self.lineno + 1
- while lignecourante > self.endline :
+ lignecourante=self.lineno
+ while lignecourante < self.endline -1 :
texte = texte + jdc.getLines()[lignecourante]
lignecourante = lignecourante + 1
if chaineBlanche(fin) == 0 :
texte = jdc.getLines()[self.lineno-1][self.colno:self.endcol]
return texte
+#-------------------------
def chaineBlanche(texte) :
+#-------------------------
# retourne 1 si la chaine est composee de " "
# retourne 0 sinon
bool = 1 ;
if texte[i] != " " : bool = 0
return bool
+#-------------------
def printNode(node):
+#-------------------
if hasattr(node,'name'):
print node.name
else:
for c in node.childNodes:
printNode(c)
-def parser(src,atraiter):
+#------------------------
+def Parser(src,atraiter):
+#------------------------
"""Parse le texte src et retourne un arbre syntaxique (root).
Cet arbre syntaxique a comme noeuds (childNodes) les commandes à traiter (liste atraiter)
root=JDCNode(src)
- # (a) dans un premier temps on extrait les commandes et on les insère dans un arbre (root)
- # les noeuds fils sont stockés dans root.childNodes (liste)
+ # (a) dans un premier temps on extrait les commandes et on les insère
+ # dans un arbre (root) les noeuds fils sont stockés dans
+ # root.childNodes (liste)
lineno=0
for line in maskedLines:
lineno=lineno+1
if m and (m.group(2) in atraiter):
root.addChild(Command(m.group(2),lineno,m.start(2),m.end(4)))
- #(b) dans un deuxième temps , on récupère le texte complet de la commande jusqu'à la
- # dernière parenthèse fermante
+ #(b) dans un deuxième temps , on récupère le texte complet de la commande
+ # jusqu'à la dernière parenthèse fermante
- #iterateur sur les lignes physiques masquées
+ # iterateur sur les lignes physiques masquées
iterlines=iter(maskedLines)
linenum=0
for c in root.childNodes:
lineno=c.lineno
- colno=c.colno # début de la commande
+ colno=c.colno # début de la commande
while linenum < lineno:
line=iterlines.next()
linenum=linenum+1
return root
+#-----------------
def lastparen(src):
+#-----------------
"""Retourne la position de la derniere parenthese fermante dans src a partir du debut de la string
La string doit contenir la premiere parenthese ouvrante
"""
+
src=maskStringsAndComments(src)
level=0
i,n=0,len(src)
#derniere parenthese fermante
return i
+#-------------------
def lastparen2(src):
+#-------------------
"""Retourne la position de la derniere parenthese fermante dans src a partir du debut de la string
La string ne contient pas la premiere parenthese ouvrante
--- /dev/null
+# -*- coding: utf-8 -*-
+import logging
+import string
+from parseur import FactNode
+debug=0
+
+
+#--------------------
+class ensembleRegles:
+#--------------------
+
+ def __init__(self,liste_regles):
+ self.liste=[]
+ for item in liste_regles :
+ args,clefRegle=item
+ r=regle(clefRegle,args)
+ self.liste.append(r)
+
+ def verif(self,commande) :
+ bool=1
+ for regle in self.liste :
+ result=regle.verif(commande)
+ bool=bool*result
+ return bool
+
+#--------------------------------
+class pasDeRegle(ensembleRegles):
+#--------------------------------
+ def __init__(self) :
+ pass
+
+ def verif (self,commande) :
+ return 1
+
+
+#------------
+class regle :
+#------------
+
+ def __init__(self,clef_regle,args):
+ self.fonction=dictionnaire_regle[clef_regle]
+ self.list_args=args
+ self.bool=0
+
+ def verif(self,commande):
+ f=self.fonction(self.list_args)
+ return f.verif(commande)
+
+#---------------------
+class existeMCFParmi :
+#---------------------
+ def __init__(self,list_arg):
+ self.listeMCF=list_arg;
+
+ def verif(self,commande):
+ bool=0
+ for c in commande.childNodes :
+ if c.name in self.listeMCF :
+ bool=1
+ break
+ return bool
+
+#----------------------
+class existeMCsousMCF :
+#----------------------
+ def __init__(self,list_arg):
+ self.liste=list_arg;
+ self.MCF=self.liste[0]
+ self.MC=self.liste[1]
+
+ def verif(self,commande):
+ bool=0
+ for mcf in commande.childNodes :
+ if mcf.name != self.MCF : continue
+ l=mcf.childNodes[:]
+ l.reverse()
+ for ll in l:
+ for mc in ll.childNodes:
+ if mc.name != self.MC : continue
+ bool=1
+ return bool
+
+#-----------------------------------------
+class nexistepasMCsousMCF(existeMCsousMCF):
+#-----------------------------------------
+ def __init__(self,list_arg):
+ existeMCsousMCF.__init__(self,list_arg)
+
+
+ def verif(self,commande):
+ bool=existeMCsousMCF.verif(self,commande)
+ if bool : return 0
+ return 1
+
+#-------------
+class existe :
+#--------------
+ def __init__(self,list_arg):
+ self.genea=list_arg
+
+ def cherche_mot(self,niveau,commande):
+ if commande == None : return 0
+ if niveau == len(self.genea) : return 1
+ texte=self.genea[niveau]
+ for c in commande.childNodes :
+ if c.name == texte :
+ niveau = niveau+1
+ return self.cherche_mot(niveau,c)
+ return None
+
+ def verif(self,commande):
+ bool=self.cherche_mot(0,commande)
+ if bool == None : bool = 0
+ return bool
+
+#-------------------------------
+class MCsousMCFaPourValeur :
+#------------------------------
+ def __init__(self,list_arg):
+ assert (len(list_arg)==4)
+ self.genea=list_arg[0:-2]
+ self.MCF=list_arg[0]
+ self.MC=list_arg[1]
+ self.Val=list_arg[2]
+ self.Jdc=list_arg[3]
+
+ def verif(self,commande):
+ bool=0
+ for mcf in commande.childNodes :
+ if mcf.name != self.MCF : continue
+ l=mcf.childNodes[:]
+ l.reverse()
+ for ll in l:
+ for mc in ll.childNodes:
+ if mc.name != self.MC : continue
+ TexteMC=mc.getText(self.Jdc)
+ if (TexteMC.find(self.Val) < 0 ): continue
+ bool=1
+ return bool
+
+#-------------------------------
+class MCaPourValeur :
+#------------------------------
+ def __init__(self,list_arg):
+ assert (len(list_arg)==3)
+ self.MC=list_arg[0]
+ self.Val=list_arg[1]
+ self.Jdc=list_arg[2]
+
+ def verif(self,commande):
+ bool=0
+ for mc in commande.childNodes :
+ if mc.name != self.MC : continue
+ TexteMC=mc.getText(self.Jdc)
+ if (TexteMC.find(self.Val) < 0 ): continue
+ bool=1
+ return bool
+
+dictionnaire_regle={"existe":existe,"existeMCFParmi":existeMCFParmi,"existeMCsousMCF":existeMCsousMCF,"nexistepasMCsousMCF":nexistepasMCsousMCF,"MCsousMCFaPourValeur":MCsousMCFaPourValeur,"MCaPourValeur":MCaPourValeur}
+SansRegle=pasDeRegle()
# -*- coding: utf-8 -*-
import logging
+import regles
from parseur import FactNode
+from dictErreurs import EcritErreur
+from dictErreurs import jdcSet
#debug=1
debug=0
#on n'a qu'un mocle par commande. On peut donc supprimer le mocle sans trop de précautions (a part iterer a l'envers sur les commandes)
#avant de supprimer un autre mocle, on remet à jour l'arbre syntaxique (lineno,colno,etc.)
-def removemocle(jdc,command,mocle):
+
+
+#-----------------------------------------------------------------------
+def removeMotCle(jdc,command,mocle,ensemble=regles.SansRegle,erreur = 0):
+#-----------------------------------------------------------------------
#on itere sur les commandes a l'envers pour ne pas polluer les numeros de ligne avec les modifications
+ if command not in jdcSet : return
+ boolChange=0
commands= jdc.root.childNodes[:]
commands.reverse()
for c in commands:
if c.name != command:continue
for mc in c.childNodes:
if mc.name != mocle:continue
- removemc(jdc,c,mc)
+ if ensemble.verif(c) == 0 : continue
+ if erreur : EcritErreur((command,mocle),c.lineno)
+ boolChange=1
+ removeMC(jdc,c,mc)
+
+ if boolChange : jdc.reset(jdc.getSource())
+
+#-------------------------------------------------------
+def removeMotCleSiRegle(jdc,command,mocle,liste_regles) :
+#-------------------------------------------------------
+ if command not in jdcSet : return
+ mesRegles=regles.ensembleRegles(liste_regles)
+ removeMotCle(jdc,command,mocle,mesRegles,erreur=0)
+
+#----------------------------------------------------------------
+def removeMotCleSiRegleAvecErreur(jdc,command,mocle,liste_regles) :
+#--------------------------------------------------------------
+ if command not in jdcSet : return
+ mesRegles=regles.ensembleRegles(liste_regles)
+ removeMotCle(jdc,command,mocle,mesRegles,erreur=1)
+
+#----------------------------------------------------------------
+def removeMotCleAvecErreur(jdc,command,mocle) :
+#--------------------------------------------------------------
+ if command not in jdcSet : return
+ removeMotCle(jdc,command,mocle,erreur=1)
+
+
+#--------------------------------------------------------------------
+def removeCommande(jdc,command,ensemble=regles.SansRegle,erreur=0):
+#--------------------------------------------------------------------
+ if command not in jdcSet : return
+ boolChange=0
+ commands= jdc.root.childNodes[:]
+ commands.reverse()
+ for c in commands:
+ if c.name != command:continue
+ if ensemble.verif(c) == 0 : continue
+ boolChange=1
+ if erreur : EcritErreur((command,),c.lineno)
+ jdc.supLignes(c.lineno,c.endline)
+ logging.warning("Suppression de: %s ligne %s",c.name,c.lineno)
+ if boolChange : jdc.reset(jdc.getSource())
- jdc.reset(jdc.getSource())
+#-------------------------------------------------------------
+def removeCommandeSiRegleAvecErreur(jdc,command,liste_regles):
+#-------------------------------------------------------------
+ if command not in jdcSet : return
+ mesRegles=regles.ensembleRegles(liste_regles)
+ removeCommande(jdc,command,mesRegles,1)
-def removemc(jdc,c,mc):
- if debug:print "Suppression de:",c.name,mc.name,mc.lineno,mc.colno,mc.endline,mc.endcol
- logging.info("Suppression de: %s, %s, %s, %s, %d, %d",c.name,mc.name,mc.lineno,mc.colno,mc.endline,mc.endcol)
+#---------------------------------
+def removeMC(jdc,c,mc):
+#---------------------------------
+ if debug : print "Suppression de:",c.name,mc.name,mc.lineno,mc.colno,mc.endline,mc.endcol
+ logging.info("Suppression de: %s, %s, ligne %d",c.name,mc.name,mc.lineno)
+
if mc.endline > mc.lineno:
if debug:print "mocle sur plusieurs lignes--%s--" % jdc.getLines()[mc.lineno-1][mc.colno:]
jdc.getLines()[mc.lineno-1]=jdc.getLines()[mc.lineno-1][:mc.colno]
jdc.getLines()[mc.endline-1]=jdc.getLines()[mc.endline-1][mc.endcol:]
+
#attention : supprimer les lignes à la fin
jdc.getLines()[mc.lineno:mc.endline-1]=[]
else:
if debug:print "mocle sur une ligne--%s--" % jdc.getLines()[mc.lineno-1][mc.colno:mc.endcol]
s=jdc.getLines()[mc.lineno-1]
jdc.getLines()[mc.lineno-1]=s[:mc.colno]+s[mc.endcol:]
- fusionne(jdc,mc.lineno-1)
- jdc.reset(jdc.getSource())
+ fusionne(jdc,mc.lineno-1)
-def removemocleinfact(jdc,command,fact,mocle):
- #on itere sur les commandes a l'envers pour ne pas polluer les numeros de ligne avec les modifications
+#---------------------------------------------------------------------------------
+def removeMotCleInFact(jdc,command,fact,mocle,ensemble=regles.SansRegle,erreur=0):
+#----------------------------------------------------------------------------------
+ # on itere sur les commandes a l'envers pour ne pas polluer
+ # les numeros de ligne avec les modifications
+ if command not in jdcSet : return
commands= jdc.root.childNodes[:]
commands.reverse()
+ boolChange=0
for c in commands:
if c.name != command:continue
for mc in c.childNodes:
for ll in l:
for n in ll.childNodes:
if n.name != mocle:continue
- removemc(jdc,c,n)
+ if ensemble.verif(c) == 0 : continue
+ if erreur : EcritErreur((command,fact,mocle),c.lineno)
+ boolChange=1
+ removeMC(jdc,c,n)
- jdc.reset(jdc.getSource())
+ if boolChange : jdc.reset(jdc.getSource())
+#------------------------------------------------------------------
+def removeMotCleInFactSiRegle(jdc,command,fact,mocle,liste_regles):
+#------------------------------------------------------------------
+ if command not in jdcSet : return
+ erreur=0
+ mesRegles=regles.ensembleRegles(liste_regles)
+ removeMotCleInFact(jdc,command,fact,mocle,mesRegles,erreur)
+
+#----------------------------------------------------------------------
+def removeMotCleInFactSiRegleAvecErreur(jdc,command,fact,mocle,liste_regles):
+#----------------------------------------------------------------------
+ if command not in jdcSet : return
+ erreur=1
+ mesRegles=regles.ensembleRegles(liste_regles)
+ removeMotCleInFact(jdc,command,fact,mocle,mesRegles,erreur)
+
+
+#------------------------------------------
def fusionne(jdc,numLigne):
+#------------------------------------------
+# fusionne la ligne numLigne et numLigne+1
+# si la ligne numLigne+1 ne contient que des parentheses
+# fermantes
+# et si la ligne numLigne ne contient pas par un "#"
+# Attention a la difference de numerotation
+# jdc.getLines()[numLigne] donne la ligne numLigne + 1
+# alors que joinLineandNext(numLigne) travaille sur le tableau
index=0
texte=jdc.getLines()[numLigne]
fusion=1
fusion=0
break
index=index+1
+
+ if fusion == 0 : return;
+
+ texte=jdc.getLines()[numLigne -1]
+ if texte.find("#") < 0 :
+ fusion=1
+ else :
+ fusion=0
+
if fusion :
import load
jdc.joinLineandNext(numLigne)
# -*- coding: utf-8 -*-
import logging
+import sys
from parseur import FactNode
-debug=1
+from dictErreurs import jdcSet
+import regles
+from dictErreurs import EcritErreur
+#debug=1
+debug=0
#on n'a qu'un mocle par commande.
#en fin de traitement, on remet à jour l'arbre syntaxique (lineno,colno,etc.)
-def renamemocle(jdc,command,mocle,new_name):
+#--------------------------------------------------------------------------------
+def renameMotCle(jdc,command,mocle,new_name, erreur=0,ensemble=regles.SansRegle):
+#--------------------------------------------------------------------------------
+ if command not in jdcSet : return
+ boolChange=0
for c in jdc.root.childNodes:
if c.name != command:continue
for mc in c.childNodes:
if mc.name != mocle:continue
+ if ensemble.verif(c) == 0 : continue
+ boolChange=1
if debug:print "Renommage de:",c.name,mc.name,mc.lineno,mc.colno
- logging.info("Renommage de: %s, %s, %s, %s en %s",c.name,mc.name,mc.lineno,mc.colno,new_name)
+ if erreur :
+ EcritErreur((command,mocle),c.lineno)
+ else :
+ logging.info("Renommage de: %s %s ligne %d en %s",c.name,mc.name,mc.lineno,new_name)
s=jdc.getLines()[mc.lineno-1]
jdc.getLines()[mc.lineno-1]=s[:mc.colno]+new_name+s[mc.colno+len(mocle):]
+ diff=len(new_name) - len(mocle)
+ decaleLignesdeNBlancs(jdc,mc.lineno,mc.endline-1,diff)
- jdc.reset(jdc.getSource())
+ if boolChange : jdc.reset(jdc.getSource())
-def renamemocleinfact(jdc,command,fact,mocle,new_name):
+#------------------------------------------------------
+def renameMotCleAvecErreur(jdc,command,mocle,new_name):
+#------------------------------------------------------
+ if command not in jdcSet : return
+ renameMotCle(jdc,command,mocle,new_name,1,regles.SansRegle)
+
+#--------------------------------------------------------------------------
+def renameMotCleSiRegle(jdc,command,mocle,new_name,liste_regles, erreur=0):
+#--------------------------------------------------------------------------
+ if command not in jdcSet : return
+ mesRegles=regles.ensembleRegles(liste_regles)
+ renameMotCle(jdc,command,mocle,new_name, erreur,mesRegles)
+
+#-------------------------------------------
+def renameOper(jdc,command,new_name):
+#-------------------------------------------
+ if command not in jdcSet : return
+ jdcSet.add(new_name)
+ boolChange=0
+ for c in jdc.root.childNodes:
+ if c.name != command:continue
+ if debug:print "Renommage de:",c.name,c.lineno,c.colno
+ logging.info("Renommage de: %s ligne %d en %s",c.name,c.lineno,new_name)
+ boolChange=1
+ s=jdc.getLines()[c.lineno-1]
+ jdc.getLines()[c.lineno-1]=s[:c.colno]+new_name+s[c.colno+len(command):]
+ diff=len(new_name) - len(command)
+ decaleLignesdeNBlancs(jdc,c.lineno,c.endline,diff)
+ if boolChange : jdc.reset(jdc.getSource())
+
+#----------------------------------------------------------
+def decaleLignesdeNBlancs(jdc,premiere,derniere,nbBlanc):
+#----------------------------------------------------------
+ ligne = premiere + 1
+ while ligne < derniere :
+ s=jdc.getLines()[ligne]
+ if nbBlanc > 0 :
+ jdc.getLines()[ligne] = nbBlanc*" " + s
+ else :
+ toutblancs=-1*nbBlanc*" "
+ if jdc.getLines()[ligne][0:-1*nbBlanc] == toutblancs:
+ jdc.getLines()[ligne] = s[-1*nbBlanc:]
+ ligne=ligne+1
+
+#---------------------------------------------------------------------------------------------
+def renameMotCleInFact(jdc,command,fact,mocle,new_name, ensemble=regles.SansRegle, erreur=0):
+#---------------------------------------------------------------------------------------------
+ if command not in jdcSet : return
+ boolChange=0
for c in jdc.root.childNodes:
if c.name != command:continue
for mc in c.childNodes:
for ll in l:
for n in ll.childNodes:
if n.name != mocle:continue
+ if ensemble.verif(c) == 0 : continue
s=jdc.getLines()[n.lineno-1]
jdc.getLines()[n.lineno-1]=s[:n.colno]+new_name+s[n.colno+len(mocle):]
+ boolChange=1
+ if erreur :
+ EcritErreur((command,fact,mocle),c.lineno)
+ else :
+ logging.info("Renommage de: %s, %s, %s, en %s",n.name,n.lineno,n.colno,new_name)
+
+ if boolChange : jdc.reset(jdc.getSource())
- jdc.reset(jdc.getSource())
+#--------------------------------------------------------------------------
+def renameMotCleInFactSiRegle(jdc,command,fact,mocle,new_name,liste_regles):
+#--------------------------------------------------------------------------
+ if command not in jdcSet : return
+ mesRegles=regles.ensembleRegles(liste_regles)
+ renameMotCleInFact(jdc,command,fact,mocle,new_name,mesRegles)
-def renamecommande(jdc,command,new_name):
+#-----------------------------------------------------------------
+def renameCommande(jdc,command,new_name,ensemble=regles.SansRegle):
+#-----------------------------------------------------------------
# nom de la commande "ancien format" , nom de la commande " nouveau format "
+ if command not in jdcSet : return
+ jdcSet.add(new_name)
+ boolChange=0
+ if debug :
+ if ensemble != regles.SansRegle :
+ logging.info("Traitement de %s renomme en %s sous conditions", command, new_name)
+ else :
+ logging.info("Traitement de %s renomme en %s ", command, new_name)
for c in jdc.root.childNodes:
if c.name != command:continue
+ if ensemble.verif(c) == 0 : continue
+ boolChange=1
if debug:print "Renommage de:",c.name,new_name ,c.lineno,c.colno
- logging.info("Renommage de: %s, %s, %s, %s en %s",c.name,"",c.lineno,c.colno,new_name)
+ logging.info("Renommage de: %s en ligne %d en %s",c.name,c.lineno,new_name)
s=jdc.getLines()[c.lineno-1]
jdc.getLines()[c.lineno-1]=s[:c.colno]+new_name+s[c.colno+len(command):]
- jdc.reset(jdc.getSource())
+ if boolChange : jdc.reset(jdc.getSource())
+#-----------------------------------------------------------
+def renameCommandeSiRegle(jdc,command,new_name,liste_regles):
+#-----------------------------------------------------------
+
+ if command not in jdcSet : return
+ mesRegles=regles.ensembleRegles(liste_regles)
+ renameCommande(jdc,command,new_name,mesRegles)
--- /dev/null
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+"""
+usage="""usage: %prog [options]
+Typical use is:
+ python traduitV7V8.py --infile=xxxx --outfile=yyyy
+"""
+
+import log
+import optparse
+
+from load import getJDC
+from mocles import parseKeywords
+from removemocle import *
+from renamemocle import *
+from renamemocle import *
+from inseremocle import *
+from changeValeur import *
+from movemocle import *
+from dictErreurs import GenereErreurPourCommande
+
+# Demander a emmanuel pour affe_char_ther et test_resu
+import calcG
+
+atraiter=( "IMPR_GENE","CALC_FONCTION", "DEFI_MATERIAU","STAT_NON_LINE",
+ "CALC_G_LOCAL_T","CALC_G_THETA_T","CALC_G","AFFE_CHAR_MECA",
+ "AFFE_CHAR_THER_F","IMPR_CO","DEFI_SQUELETTE","DEFI_FONCTION",
+ "CALC_THETA","AFFE_MODELE","DYNA_NON_LINE","CALC_ELEM",
+ "CALC_NO","EXTR_MODE","CALC_META","IMPR_RESU","TEST_RESU",
+ "DEFI_THER_JOULE","DYNA_TRAN_EXPLI","DEBUT","CALC_CHAM_ELEM",
+ "AFFE_CHAR_THER", "MACR_LIGN_COUPE","POST_RCCM","PROJ_MESU_MODAL",
+ "CREA_RESU","CREA_CHAMP","DIST_LIGN_3D","MODI_MAILLAGE","LIRE_TABLE",
+ "POST_SIMPLIFIE","AFFE_MATERIAU","DEFI_MAILLAGE","DEPL_INTERNE",
+ "POST_DYNA_ALEA","RECU_FONCTION","DYNA_TRAN_MODAL","DEFI_INTERF_DYNA",
+ "CALC_PRECONT","DEFI_TEXTURE","TEST_RESU","COMB_CHAM_NO","COMB_CHAM_ELEM",
+ "CALC_FATIGUE","IMPR_OAR",
+ "MACR_ASCOUF_CALC","MACR_ASPIC_CALC","MACR_CABRI_CALC",
+ "MACR_ADAP_MAIL","IMPR_FICO_HOMARD"
+ )
+
+#atraiter=( "MACR_ADAP_MAIL",)
+
+def traduc(infile,outfile):
+
+ hdlr=log.initialise()
+ jdc=getJDC(infile,atraiter)
+ root=jdc.root
+
+ #Parse les mocles des commandes
+ parseKeywords(root)
+
+ ####################### traitement erreurs ########################
+ GenereErreurPourCommande(jdc,("POST_RCCM","DIST_LIGN_3D","IMPR_OAR","COMB_CHAM_NO","COMB_CHAM_ELEM"))
+
+ ####################### traitement CALC_META #######################
+ renameMotCleInFact(jdc,"CALC_META","ETAT_INIT","META_INIT","META_INIT_ELNO")
+
+ ####################### traitement CALC_FONCTION #######################
+ removeMotCleSiRegle(jdc,"CALC_FONCTION","NOM_PARA",((("MAX"),"existeMCFParmi"),))
+ renameCommandeSiRegle(jdc,"CALC_FONCTION","INFO_FONCTION", ((("RMS","MAX","NOCI_SEISME","NORME","ECART-TYPE"),"existeMCFParmi"),))
+
+ ####################### traitement IMPR_GENE #######################
+ moveMotCleFromFactToFather(jdc,"IMPR_GENE","GENE","UNITE")
+ moveMotCleFromFactToFather(jdc,"IMPR_GENE","GENE","FORMAT")
+
+ ####################### traitement STAT/DYNA_NON_LINE #######################
+ moveMotCleFromFactToFactMulti(jdc,"STAT_NON_LINE","CONVERGENCE","RESI_INTE_RELA",("COMP_INCR","COMP_ELAS"))
+ moveMotCleFromFactToFactMulti(jdc,"STAT_NON_LINE","CONVERGENCE","ITER_INTE_MAXI",("COMP_INCR","COMP_ELAS"))
+ moveMotCleFromFactToFactMulti(jdc,"STAT_NON_LINE","CONVERGENCE","ITER_INTE_PAS",("COMP_INCR","COMP_ELAS"))
+ moveMotCleFromFactToFactMulti(jdc,"STAT_NON_LINE","CONVERGENCE","RESO_INTE",("COMP_INCR","COMP_ELAS"))
+ removeMotCleAvecErreur(jdc,"STAT_NON_LINE","VARI_COMM")
+ moveMotCleFromFactToFactMulti(jdc,"DYNA_NON_LINE","CONVERGENCE","RESI_INTE_RELA",("COMP_INCR","COMP_ELAS"))
+ moveMotCleFromFactToFactMulti(jdc,"DYNA_NON_LINE","CONVERGENCE","ITER_INTE_MAXI",("COMP_INCR","COMP_ELAS"))
+ moveMotCleFromFactToFactMulti(jdc,"DYNA_NON_LINE","CONVERGENCE","ITER_INTE_PAS",("COMP_INCR","COMP_ELAS"))
+ moveMotCleFromFactToFactMulti(jdc,"DYNA_NON_LINE","CONVERGENCE","RESO_INTE",("COMP_INCR","COMP_ELAS"))
+ removeMotCleAvecErreur(jdc,"DYNA_NON_LINE","VARI_COMM")
+
+ dStatNonLine={"ELAS":"ELAS_THER"}
+ lavertit=("ELAS")
+ ChangementValeurDsMCFAvecAvertissement(jdc,"STAT_NON_LINE","COMP_INCR","RELATION_KIT",dStatNonLine,lavertit)
+
+ lavertit=("CHABOCHE","ASSE_COMBU","OHNO","GLRC")
+ dchaboche={"CHABOCHE":"VMIS_CIN1_CHAB","ASSE_COMBU":"XXX_IRA","OHNO":"VISC_TAHERI","GLRC":"GLRC_DAMAGE"}
+ ChangementValeurDsMCFAvecAvertissement(jdc,"STAT_NON_LINE","COMP_INCR","RELATION",dchaboche,lavertit)
+ ChangementValeurDsMCFAvecAvertissement(jdc,"DYNA_NON_LINE","COMP_INCR","RELATION",dchaboche,lavertit)
+
+ removeMotCleInFactSiRegle(jdc,"STAT_NON_LINE","INCREMENT","SUBD_PAS_MINI",((("INCREMENT","SUBD_PAS","1",jdc),"MCsousMCFaPourValeur"),))
+ removeMotCleInFactSiRegle(jdc,"STAT_NON_LINE","INCREMENT","COEF_SUBD_PAS_1",((("INCREMENT","SUBD_PAS","1",jdc),"MCsousMCFaPourValeur"),))
+ removeMotCleInFactSiRegleAvecErreur(jdc,"STAT_NON_LINE","INCREMENT","SUBD_PAS",((("INCREMENT","SUBD_PAS","1",jdc),"MCsousMCFaPourValeur"),))
+ AjouteMotClefDansFacteurSiRegle(jdc,"STAT_NON_LINE","INCREMENT","SUBD_METHODE='UNIFORME',",((("INCREMENT","SUBD_PAS"),"existeMCsousMCF"),))
+ renameMotCleInFact(jdc,"STAT_NON_LINE","INCREMENT","COEF_SUBD_PAS_1","SUBD_COEF_PAS_1")
+ removeMotCleInFactSiRegle(jdc,"DYNA_NON_LINE","INCREMENT","SUBD_PAS_MINI",((("INCREMENT","SUBD_PAS","1",jdc),"MCsousMCFaPourValeur"),))
+ removeMotCleInFactSiRegle(jdc,"DYNA_NON_LINE","INCREMENT","COEF_SUBD_PAS_1",((("INCREMENT","SUBD_PAS","1",jdc),"MCsousMCFaPourValeur"),))
+ removeMotCleInFactSiRegleAvecErreur(jdc,"DYNA_NON_LINE","INCREMENT","SUBD_PAS",((("INCREMENT","SUBD_PAS","1",jdc),"MCsousMCFaPourValeur"),))
+ AjouteMotClefDansFacteurSiRegle(jdc,"DYNA_NON_LINE","INCREMENT","SUBD_METHODE='UNIFORME',",((("INCREMENT","SUBD_PAS"),"existeMCsousMCF"),))
+ renameMotCleInFact(jdc,"DYNA_NON_LINE","INCREMENT","COEF_SUBD_PAS_1","SUBD_COEF_PAS_1")
+
+ moveMotClefInOperToFact(jdc,"STAT_NON_LINE","PARM_THETA","COMP_INCR")
+ moveMotClefInOperToFact(jdc,"DYNA_NON_LINE","PARM_THETA","COMP_INCR")
+ moveMotClefInOperToFact(jdc,"DYNA_TRAN_EXPLI","PARM_THETA","COMP_INCR")
+
+ ####################### traitement DEFI_MATERIAU #######################
+ renameMotCle(jdc,"DEFI_MATERIAU","LEMAITRE","LEMAITRE_IRRA")
+ moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","FLU_IRRA","QSR_K",("LEMAITRE_IRRA",))
+ moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","FLU_IRRA","BETA",("LEMAITRE_IRRA",))
+ moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","FLU_IRRA","PHI_ZERO",("LEMAITRE_IRRA",))
+ moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","FLU_IRRA","L",("LEMAITRE_IRRA",))
+ removeMotCle(jdc,"DEFI_MATERIAU","FLU_IRRA")
+ renameMotCleAvecErreur(jdc,"DEFI_MATERIAU","CHABOCHE","CINx_CHAB")
+ renameMotCleAvecErreur(jdc,"DEFI_MATERIAU","OHNO","TAHERI")
+ renameMotCleAvecErreur(jdc,"DEFI_MATERIAU","OHNO_FO","TAHERI_FO")
+ renameMotCleAvecErreur(jdc,"DEFI_MATERIAU","GLRC","GLRC_DAMAGE")
+
+ renameMotCleInFact(jdc,"DEFI_MATERIAU","GRAN_IRRA","A","GRAN_A")
+ renameMotCleInFact(jdc,"DEFI_MATERIAU","GRAN_IRRA","B","GRAN_B")
+ renameMotCleInFact(jdc,"DEFI_MATERIAU","GRAN_IRRA","S","GRAN_S")
+ moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","GRAN_IRRA","GRAN_A",("LEMAITRE_IRRA",))
+ moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","GRAN_IRRA","GRAN_B",("LEMAITRE_IRRA",))
+ moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","GRAN_IRRA","GRAN_S",("LEMAITRE_IRRA",))
+ removeMotCle(jdc,"DEFI_MATERIAU","GRAN_IRRA")
+
+ chercheOperInsereFacteurSiRegle(jdc,"DEFI_MATERIAU","ELAS",((("CABLE",),"existe"),))
+ moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","CABLE","E", ("ELAS",))
+ moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","CABLE","NU", ("ELAS",))
+ moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","CABLE","RHO",("ELAS",))
+ moveMotCleFromFactToFactMulti(jdc,"DEFI_MATERIAU","CABLE","ALPHA",("ELAS",))
+ AjouteMotClefDansFacteurSiRegle(jdc,"DEFI_MATERIAU","ELAS","NU=0.,",((("ELAS","NU"),"nexistepasMCsousMCF"),))
+
+ removeMotCleAvecErreur(jdc,"DEFI_MATERIAU","POLY_CFC")
+ removeMotCleAvecErreur(jdc,"DEFI_MATERIAU","ECOU_PLAS1")
+
+ lavertit=("ELAS_THM","SURF_ETAT_SATU","SURF_ETAT_NSAT","CAM_CLAY_THM","LIQU_SATU_GAT","LIQU_NSAT_GAT")
+ dTHM={"ELAS_THM":"xxx", "SURF_ETAT_SATU":"xxx", "SURF_ETAT_NSAT":"xxx","CAM_CLAY_THM":"xxx","LIQU_SATU_GAT":"xxx","LIQU_NSAT_GAT":"xxx"}
+ ChangementValeurAvecAvertissement(jdc,"DEFI_MATERIAU","COMP_THM",dTHM,lavertit)
+
+ dfatigue={"MATAKE":"MATAKE_MODI_AC", "DOMM_MAXI":"MATAKE_MODI_AV", "FATEMI_SOCIE":"FATESOCI_MODI_AV"}
+ ChangementValeurDsMCF(jdc,"DEFI_MATERIAU","CISA_PLAN_CRIT","CRITERE",dfatigue)
+
+ ####################### traitement IMPR_CO #######################
+ chercheOperInsereFacteurSiRegle(jdc,"IMPR_CO","CONCEPT",((("CO",),"existe"),))
+ moveMotClefInOperToFact(jdc,"IMPR_CO","CO","CONCEPT")
+ renameMotCleInFact(jdc,"IMPR_CO","CONCEPT","CO","NOM")
+
+ ####################### traitement DEFI_SQUELETTE #######################
+ chercheOperInsereFacteurSiRegle(jdc,"DEFI_SQUELETTE","CYCLIQUE",((("MODE_CYCL",),"existe"),))
+ moveMotClefInOperToFact(jdc,"DEFI_SQUELETTE","MODE_CYCL","CYCLIQUE")
+
+ ####################### traitement AFFE_CHAR_* #######################
+ removeMotCle(jdc,"AFFE_CHAR_MECA","VERI_DDL")
+ removeMotCle(jdc,"AFFE_CHAR_MECA","SECH_CALCULEE")
+ removeMotCle(jdc,"AFFE_CHAR_MECA","HYDR_CALCULEE")
+ removeMotCle(jdc,"AFFE_CHAR_MECA","PRESSION_CALCULEE")
+ removeMotCleAvecErreur(jdc,"AFFE_CHAR_MECA","EPSA_CALCULEE")
+ removeMotCle(jdc,"AFFE_CHAR_THER_F","VERI_DDL")
+ removeMotCle(jdc,"AFFE_CHAR_THER","VERI_DDL")
+
+ ####################### traitement AFFE_CHAR_MECA (CONTACT) #######################
+ renameMotCleInFact(jdc,"AFFE_CHAR_MECA","CONTACT","COEF_MULT_ESCL","COEF_MULT")
+ renameMotCleInFact(jdc,"AFFE_CHAR_MECA","CONTACT","NOM_CHAM","NOM_CMP")
+ renameMotCleInFact(jdc,"AFFE_CHAR_MECA","CONTACT","NOM_CHAM","NOM_CMP")
+ renameMotCleInFact(jdc,"AFFE_CHAR_MECA","CONTACT","GROUP_MA_ESCL","GROUP_MA")
+ renameMotCleSiRegle(jdc,"AFFE_CHAR_MECA","CONTACT","LIAISON_UNILATER",((("CONTACT","NOM_CMP"),"existeMCsousMCF"),))
+ removeMotCleInFact(jdc,"AFFE_CHAR_MECA","LIAISON_UNILATER","APPARIEMENT")
+
+ ####################### traitement CALC_G #######################
+ chercheOperInsereFacteurSiRegle(jdc,"CALC_G_LOCAL_T","LISSAGE",((("LISSAGE_G","LISSAGE_THETA","DEGRE"),"existeMCFParmi"),))
+ moveMotClefInOperToFact(jdc,"CALC_G_LOCAL_T","LISSAGE_THETA","LISSAGE")
+ moveMotClefInOperToFact(jdc,"CALC_G_LOCAL_T","LISSAGE_G","LISSAGE")
+ moveMotClefInOperToFact(jdc,"CALC_G_LOCAL_T","DEGRE","LISSAGE")
+
+ dlocal={"CALC_G_LGLO":"G_LAGR", "G_BILINEAIRE":"G_BILI", "CALC_G_MAX":"G_MAX"}
+ ChangementValeur(jdc,"CALC_G_LOCAL_T","OPTION",dlocal)
+ #
+ dtheta={"CALC_G_LAGR":"G_LAGR_GLOB", "G_BILINEAIRE":"G_BILI_GLOB", "CALC_G_MAX":"G_MAX_GLOB","CALC_G":"CALC_G_GLOB"}
+ # Attention si le defaut doit generer un avertissement Il faut le mettre comme dernier mot de la liste
+ lavertit=("CALC_G_LAGR","CALC_G","defaut")
+ ChangementValeurAvecAvertissement(jdc,"CALC_G_THETA_T","OPTION",dtheta,lavertit)
+ renameOper(jdc,"CALC_G_LOCAL_T","CALC_G")
+ renameOper(jdc,"CALC_G_THETA_T","CALC_G")
+
+ # Attention cela necessite un traitement particulier et ne peut pas etre generalise tel quel
+ # Attention egalement doit etre fait avant le regroupement dans THETA
+ calcG.traitementRayon(jdc)
+ renameMotCle(jdc,"CALC_G","THETA","THETA_OLD")
+ chercheOperInsereFacteur(jdc,"CALC_G","THETA")
+ moveMotClefInOperToFact(jdc,"CALC_G","THETA_OLD","THETA")
+ renameMotCleInFact(jdc,"CALC_G","THETA","THETA_OLD","THETA")
+
+ moveMotClefInOperToFact(jdc,"CALC_G","FOND_FISS","THETA")
+ moveMotClefInOperToFact(jdc,"CALC_G","R_INF_FO","THETA")
+ moveMotClefInOperToFact(jdc,"CALC_G","R_SUP_FO","THETA")
+ moveMotClefInOperToFact(jdc,"CALC_G","R_INF","THETA")
+ moveMotClefInOperToFact(jdc,"CALC_G","R_SUP","THETA")
+ moveMotClefInOperToFact(jdc,"CALC_G","FISSURE","THETA")
+ renameMotCleInFactSiRegle(jdc,"CALC_G","THETA","THETA","THETA_LAGR",((("THETA","R_INF"),"existeMCsousMCF"),))
+ renameMotCleInFactSiRegle(jdc,"CALC_G","THETA","THETA","THETA_LAGR",((("THETA","R_SUP"),"existeMCsousMCF"),))
+ moveMotCleFromFactToFather(jdc,"CALC_G","THETA","THETA_LAGR")
+ removeMotCleAvecErreur(jdc,"CALC_G","MODELE")
+ removeMotCleAvecErreur(jdc,"CALC_G","DEPL")
+ removeMotCleAvecErreur(jdc,"CALC_G","CHAM_MATER")
+ removeMotCleAvecErreur(jdc,"CALC_G","CARA_ELEM")
+ chercheOperInsereFacteurSiRegleAvecAvertissement(jdc,"CALC_G","RESULTAT=XXX,",((("THETA_LAGR",),"existeMCFParmi"),),0)
+
+ ####################### traitement AFFE_MODELE #######################
+ daffeModele={"PLAN_FISSURE":"PLAN_JOINT", "AXIS_FISSURE":"AXIS_JOINT"}
+ ChangementValeurDsMCF(jdc,"AFFE_MODELE","AFFE","MODELISATION",daffeModele)
+ removeMotCleSiRegleAvecErreur(jdc,"AFFE_MODELE","AFFE",((("AFFE","MODELISATION","APPUI_REP",jdc),"MCsousMCFaPourValeur"),))
+ removeMotCleSiRegleAvecErreur(jdc,"AFFE_MODELE","AFFE",((("AFFE","MODELISATION","ASSE_GRIL",jdc),"MCsousMCFaPourValeur"),))
+ removeMotCleSiRegleAvecErreur(jdc,"AFFE_MODELE","AFFE",((("AFFE","MODELISATION","3D_JOINT_CT",jdc),"MCsousMCFaPourValeur"),))
+ renameMotCleInFact(jdc,"AFFE_MODELE","AFFE_SOUS_STRUC","MAILLE","SUPER_MAILLE")
+
+ ####################### traitement PROJ_MESU_MODAL #######################
+ removeMotCleInFact(jdc,"PROJ_MESU_MODAL","MODELE_MESURE","NOM_PARA")
+ removeMotCleInFactSiRegleAvecErreur(jdc,"AFFE_CHAR_MECA","CONTACT","FROTTEMENT",((("CONTACT","METHODE","CONTRAINTE",jdc),"MCsousMCFaPourValeur"),))
+
+ ####################### traitement CALC_ELEM / CALC_NO #######################
+ dcalcelemno={"ERRE_ELGA_NORE":"ERRE_ELEM_SIGM","ERRE_ELEM_NOZ1":"ERZ1_ELEM_SIGM","ERRE_ELEM_NOZ2":"ERZ2_ELEM_SIGM","ERRE_ELNO_ELGA":"ERRE_ELNO_ELEM","ERRE_NOEU_ELGA":"ERRE_NOEU_ELEM","ERTH_ELEM_TEMP":"ERRE_ELEM_TEMP","ERTH_ELNO_ELEM":"ERRE_ELNO_ELEM","EPGR_ELNO":"EPFP_ELNO","EPGR_ELGA":"EPFP_ELGA","DURT_ELGA_TEMP":"DURT_ELNO_TEMP"}
+ ChangementValeur(jdc,"CALC_ELEM","OPTION",dcalcelemno)
+ ChangementValeur(jdc,"CALC_NO","OPTION",dcalcelemno)
+ ChangementValeurDsMCF(jdc,"IMPR_RESU","RESU","NOM_CHAM",dcalcelemno)
+ ChangementValeur(jdc,"TEST_RESU","RESU",dcalcelemno)
+ removeMotCleAvecErreur(jdc,"TEST_RESU","UNITE")
+
+ chercheOperInsereFacteurSiRegle(jdc,"CALC_ELEM","REPE_COQUE",((("NUME_COUCHE","NIVE_COUCHE","ANGLE","PLAN"),"existeMCFParmi"),))
+ moveMotClefInOperToFact(jdc,"CALC_ELEM","NIVE_COUCHE","REPE_COQUE")
+ moveMotClefInOperToFact(jdc,"CALC_ELEM","NUME_COUCHE","REPE_COQUE")
+ moveMotClefInOperToFact(jdc,"CALC_ELEM","ANGLE","REPE_COQUE")
+ moveMotClefInOperToFact(jdc,"CALC_ELEM","PLAN","REPE_COQUE")
+
+
+ ####################### traitement EXTR_MODE #######################
+ AjouteMotClefDansFacteurSiRegle(jdc,"EXTR_MODE","FILTRE_MODE","SEUIL=1.E-3", ((("FILTRE_MODE","CRIT_EXTR",),"existeMCsousMCF"),(("FILTRE_MODE","SEUIL",),"nexistepasMCsousMCF")))
+
+ ####################### traitement DYNA_TRAN_EXPLI #######################
+ removeMotCle(jdc,"DYNA_TRAN_EXPLI","NEWMARK")
+ removeMotCle(jdc,"DYNA_TRAN_EXPLI","HHT")
+ chercheOperInsereFacteur(jdc,"DYNA_TRAN_EXPLI","DIFF_CENT")
+
+ ####################### traitement CREA_RESU #######################
+ dcrearesu={"HYDR_ELGA":"HYDR_NOEU_ELGA"}
+ lavertit=("HYDR_ELGA",)
+ ChangementValeur(jdc,"CREA_RESU","NOM_CHAM",dcrearesu,lavertit)
+
+ ####################### traitement CREA_CHAMP #######################
+ dcrearesu={"HYDR_ELGA":"HYDR_ELNO_ELGA"}
+ lavertit=("HYDR_ELGA",)
+ ChangementValeur(jdc,"CREA_CHAMP","NOM_CHAM",dcrearesu,lavertit)
+ ChangementValeur(jdc,"CREA_CHAMP","TYPE_CHAM",dcrearesu,lavertit)
+
+ ####################### traitement TEST_RESU #######################
+ dcrearesu={"HYDR_ELGA":"HYDR_NOEU_ELGA"}
+ lavertit=("HYDR_ELGA",)
+ ChangementValeurDsMCFAvecAvertissement(jdc,"TEST_RESU","RESU","NOM_CHAM",dcrearesu,lavertit)
+
+ ####################### traitement DEBUT #######################
+ removeMotCleSiRegle(jdc,"DEBUT","BASE",((("BASE","FICHIER","LOCALE",jdc),"MCsousMCFaPourValeur"),))
+
+ ####################### traitement DEFI_THER_JOULE #######################
+ removeCommande(jdc,"DEFI_THER_JOULE")
+
+ ####################### traitement CALC_CHAM_ELEM #######################
+ removeCommandeSiRegleAvecErreur(jdc,"CALC_CHAM_ELEM",((("OPTION","SOUR_ELGA_ELEC",jdc),"MCaPourValeur"),))
+
+ ####################### traitement MACR_LIGNE_COUPE #######################
+ AppelleMacroSelonValeurConcept(jdc,"MACR_LIGN_COUPE",("LIGN_COUPE","TABLE"))
+ removeMotCleInFact(jdc,"MACR_LIGN_COUPE","LIGN_COUPE","TABLE")
+
+ ####################### traitement MODI_MAILLAGE #######################
+ removeMotCle(jdc,"MODI_MAILLAGE","MODELE")
+
+ ####################### traitement LIRE_TABLE #######################
+ removeMotCle(jdc,"LIRE_TABLE","TYPE_TABLE")
+
+ ####################### traitement POST_SIMPLIFIE #######################
+ removeCommande(jdc,"POST_SIMPLIFIE")
+
+ ####################### traitement AFFE_MATERIAU #######################
+ removeMotCleInFact(jdc,"AFFE_MATERIAU","AFFE","SECH_REF")
+
+ ####################### traitement DEFI_MAILLAGE #######################
+ renameMotCleInFact(jdc,"DEFI_MAILLAGE","DEFI_MAILLE","MAILLE","SUPER_MAILLE")
+ renameMotCle(jdc,"DEFI_MAILLAGE","DEFI_MAILLE","DEFI_SUPER_MAILLE")
+ renameMotCleInFact(jdc,"DEFI_MAILLAGE","RECO_GLOBAL","MAILLE","SUPER_MAILLE")
+ renameMotCleInFact(jdc,"DEFI_MAILLAGE","RECO_MAILLE","MAILLE","SUPER_MAILLE")
+ renameMotCle(jdc,"DEFI_MAILLAGE","RECO_MAILLE","RECO_SUPER_MAILLE")
+ renameMotCleInFact(jdc,"DEFI_MAILLAGE","DEFI_NOEUD","MAILLE","SUPER_MAILLE")
+ renameMotCleInFact(jdc,"DEFI_MAILLAGE","DEFI_GROUP_NO","MAILLE","SUPER_MAILLE")
+
+ ####################### traitement DEPL_INTERNE #######################
+ renameMotCle(jdc,"DEPL_INTERNE","MAILLE","SUPER_MAILLE")
+
+
+ ####################### traitement POST_DYNA_ALEA #######################
+ removeMotCleAvecErreur(jdc,"POST_DYNA_ALEA","GAUSS")
+ removeMotCleAvecErreur(jdc,"POST_DYNA_ALEA","RAYLEIGH")
+ removeMotCleAvecErreur(jdc,"POST_DYNA_ALEA","DEPASSEMENT")
+ removeMotCleAvecErreur(jdc,"POST_DYNA_ALEA","VANMARCKE")
+
+ ####################### traitement RECU_FONCTION #######################
+# il faut aussi ajouter la regle suivante :
+# s'il existe TYPE_RESU='FONCTION_C', renommer NOM_PARA_TABL='FONCTION_C'
+ removeMotCleSiRegle(jdc,"RECU_FONCTION","NOM_PARA_TABL",((("TYPE_RESU","FONCTION_C",jdc),"MCaPourValeur"),))
+ chercheOperInsereFacteurSiRegle(jdc,"RECU_FONCTION","NOM_PARA_TABL='FONCTION_C',",((("TYPE_RESU","FONCTION_C",jdc),"MCaPourValeur"),),estunFacteur=0)
+ removeMotCle(jdc,"RECU_FONCTION","TYPE_RESU")
+ chercheOperInsereFacteurSiRegle(jdc,"RECU_FONCTION","NOM_PARA_TABL='FONCTION',",((("OBSTACLE",),"existe"),),estunFacteur=0)
+ chercheOperInsereFacteurSiRegle(jdc,"RECU_FONCTION","FILTRE",((("OBSTACLE",),"existe"),))
+ AjouteMotClefDansFacteurSiRegle(jdc,"RECU_FONCTION","FILTRE","NOM_PARA='LIEU',",((("OBSTACLE",),"existe"),))
+ AjouteMotClefDansFacteurSiRegle(jdc,"RECU_FONCTION","FILTRE","VALE_K='DEFIOBST',",((("OBSTACLE",),"existe"),))
+ renameMotCle(jdc,"RECU_FONCTION","OBSTACLE","TABLE")
+
+ ####################### traitement DYNA_TRAN_MODAL #######################
+ renameMotCleInFact(jdc,"DYNA_TRAN_MODAL","EXCIT","NUME_MODE","NUME_ORDRE",erreur=1)
+
+ ####################### traitement DEFI_INTERF_DYNA #######################
+ removeMotCleInFact(jdc,"DEFI_INTERF_DYNA","INTERFACE","DDL_ACTIF",erreur=1)
+
+
+ ####################### traitement CALC_PRECONT #######################
+ removeMotCleInFactSiRegle(jdc,"CALC_PRECONT","INCREMENT","SUBD_PAS_MINI",((("INCREMENT","SUBD_PAS","1",jdc),"MCsousMCFaPourValeur"),))
+ removeMotCleInFactSiRegle(jdc,"CALC_PRECONT","INCREMENT","COEF_SUBD_PAS_1",((("INCREMENT","SUBD_PAS","1",jdc),"MCsousMCFaPourValeur"),))
+ removeMotCleInFactSiRegleAvecErreur(jdc,"CALC_PRECONT","INCREMENT","SUBD_PAS",((("INCREMENT","SUBD_PAS","1",jdc),"MCsousMCFaPourValeur"),))
+ AjouteMotClefDansFacteurSiRegle(jdc,"CALC_PRECONT","INCREMENT","SUBD_METHODE='UNIFORME',",((("INCREMENT","SUBD_PAS"),"existeMCsousMCF"),))
+ moveMotCleFromFactToFactMulti(jdc,"CALC_PRECONT","CONVERGENCE","RESI_INTE_RELA",("COMP_INCR","COMP_ELAS"))
+ moveMotCleFromFactToFactMulti(jdc,"CALC_PRECONT","CONVERGENCE","ITER_INTE_MAXI",("COMP_INCR","COMP_ELAS"))
+ moveMotCleFromFactToFactMulti(jdc,"CALC_PRECONT","CONVERGENCE","ITER_INTE_PAS",("COMP_INCR","COMP_ELAS"))
+ moveMotCleFromFactToFactMulti(jdc,"CALC_PRECONT","CONVERGENCE","RESO_INTE",("COMP_INCR","COMP_ELAS"))
+ renameMotCleInFact(jdc,"CALC_PRECONT","INCREMENT","COEF_SUBD_PAS_1","SUBD_COEF_PAS_1")
+
+
+ ####################### traitement DEFI_TEXTURE #######################
+ removeCommande(jdc,"DEFI_TEXTURE")
+
+
+ ####################### traitement COMB_CHAM_NO #######################
+ renameMotCleInFact(jdc,"COMB_CHAM_NO","COMB_C","CHAM_NO","CHAM_GD")
+ chercheOperInsereFacteur(jdc,"COMB_CHAM_NO","TYPE_CHAM='xxx',",estunFacteur=0,erreur=1)
+ chercheOperInsereFacteur(jdc,"COMB_CHAM_NO","MODELE='xxx',",estunFacteur=0,erreur=1)
+ chercheOperInsereFacteur(jdc,"COMB_CHAM_NO","OPERATION='ASSE',",estunFacteur=0,erreur=1)
+ renameMotCle(jdc,"COMB_CHAM_NO","COMB_C","ASSE")
+ AjouteMotClefDansFacteur(jdc,"COMB_CHAM_NO","ASSE","CUMUL='NON',")
+ AjouteMotClefDansFacteur(jdc,"COMB_CHAM_NO","ASSE","TOUT='OUI',")
+ renameOper(jdc,"COMB_CHAM_NO","CREA_CHAMP")
+
+
+ ####################### traitement MACR_ASCOUF_CALC #######################
+ AjouteMotClefDansFacteurSiRegle(jdc,"MACR_ASCOUF_CALC","INCREMENT","SUBD_METHODE='UNIFORME',",((("INCREMENT","SUBD_PAS"),"existeMCsousMCF"),))
+ renameMotCleInFact(jdc,"MACR_ASCOUF_CALC","INCREMENT","COEF_SUBD_PAS_1","SUBD_COEF_PAS_1")
+ moveMotCleFromFactToFactMulti(jdc,"MACR_ASCOUF_CALC","CONVERGENCE","RESI_INTE_RELA",("COMP_INCR","COMP_ELAS"))
+ moveMotCleFromFactToFactMulti(jdc,"MACR_ASCOUF_CALC","CONVERGENCE","ITER_INTE_MAXI",("COMP_INCR","COMP_ELAS"))
+ moveMotCleFromFactToFactMulti(jdc,"MACR_ASCOUF_CALC","CONVERGENCE","ITER_INTE_PAS",("COMP_INCR","COMP_ELAS"))
+ moveMotCleFromFactToFactMulti(jdc,"MACR_ASCOUF_CALC","CONVERGENCE","RESO_INTE",("COMP_INCR","COMP_ELAS"))
+
+
+ ####################### traitement MACR_ASPIC_CALC #######################
+ AjouteMotClefDansFacteurSiRegle(jdc,"MACR_ASPIC_CALC","INCREMENT","SUBD_METHODE='UNIFORME',",((("INCREMENT","SUBD_PAS"),"existeMCsousMCF"),))
+ renameMotCleInFact(jdc,"MACR_ASPIC_CALC","INCREMENT","COEF_SUBD_PAS_1","SUBD_COEF_PAS_1")
+ moveMotCleFromFactToFactMulti(jdc,"MACR_ASPIC_CALC","CONVERGENCE","RESI_INTE_RELA",("COMP_INCR","COMP_ELAS"))
+ moveMotCleFromFactToFactMulti(jdc,"MACR_ASPIC_CALC","CONVERGENCE","ITER_INTE_MAXI",("COMP_INCR","COMP_ELAS"))
+ moveMotCleFromFactToFactMulti(jdc,"MACR_ASPIC_CALC","CONVERGENCE","ITER_INTE_PAS",("COMP_INCR","COMP_ELAS"))
+
+
+ ####################### traitement MACR_CABRI_CALC #######################
+ AjouteMotClefDansFacteurSiRegle(jdc,"MACR_CABRI_CALC","INCREMENT","SUBD_METHODE='UNIFORME',",((("INCREMENT","SUBD_PAS"),"existeMCsousMCF"),))
+ renameMotCleInFact(jdc,"MACR_CABRI_CALC","INCREMENT","COEF_SUBD_PAS_1","SUBD_COEF_PAS_1")
+ moveMotCleFromFactToFactMulti(jdc,"MACR_CABRI_CALC","CONVERGENCE","RESI_INTE_RELA",("COMP_INCR","COMP_ELAS"))
+ moveMotCleFromFactToFactMulti(jdc,"MACR_CABRI_CALC","CONVERGENCE","ITER_INTE_MAXI",("COMP_INCR","COMP_ELAS"))
+ moveMotCleFromFactToFactMulti(jdc,"MACR_CABRI_CALC","CONVERGENCE","ITER_INTE_PAS",("COMP_INCR","COMP_ELAS"))
+
+
+ ####################### traitement CALC_FATIGUE #######################
+ dfatigue={"MATAKE":"MATAKE_MODI_AC", "DOMM_MAXI":"MATAKE_MODI_AV", "FATEMI_SOCIE":"FATESOCI_MODI_AV"}
+ ChangementValeur(jdc,"CALC_FATIGUE","CRITERE",dfatigue)
+
+
+ ####################### traitement MACR_ADAP_MAIL #######################
+ moveMotCleFromFactToFather(jdc,"MACR_ADAP_MAIL","ADAPTATION","MAILLAGE_N")
+ moveMotCleFromFactToFather(jdc,"MACR_ADAP_MAIL","ADAPTATION","MAILLAGE_NP1")
+ moveMotCleFromFactToFather(jdc,"MACR_ADAP_MAIL","ADAPTATION","RESULTAT_N")
+ moveMotCleFromFactToFather(jdc,"MACR_ADAP_MAIL","ADAPTATION","INDICATEUR")
+ moveMotCleFromFactToFather(jdc,"MACR_ADAP_MAIL","ADAPTATION","NOM_CMP_INDICA")
+ moveMotCleFromFactToFather(jdc,"MACR_ADAP_MAIL","ADAPTATION","CRIT_RAFF_PE")
+ moveMotCleFromFactToFather(jdc,"MACR_ADAP_MAIL","ADAPTATION","CRIT_RAFF_ABS")
+ moveMotCleFromFactToFather(jdc,"MACR_ADAP_MAIL","ADAPTATION","CRIT_RAFF_REL")
+ moveMotCleFromFactToFather(jdc,"MACR_ADAP_MAIL","ADAPTATION","CRIT_DERA_PE")
+ moveMotCleFromFactToFather(jdc,"MACR_ADAP_MAIL","ADAPTATION","CRIT_DERA_ABS")
+ moveMotCleFromFactToFather(jdc,"MACR_ADAP_MAIL","ADAPTATION","CRIT_DERA_REL")
+ moveMotCleFromFactToFather(jdc,"MACR_ADAP_MAIL","ADAPTATION","NIVE_MAX")
+ moveMotCleFromFactToFather(jdc,"MACR_ADAP_MAIL","ADAPTATION","INST")
+ moveMotCleFromFactToFather(jdc,"MACR_ADAP_MAIL","ADAPTATION","PRECISION")
+ moveMotCleFromFactToFather(jdc,"MACR_ADAP_MAIL","ADAPTATION","CRITERE")
+ chercheOperInsereFacteurSiRegle(jdc,"MACR_ADAP_MAIL","ADAPTATIONEW='RAFFINEMENT',",((("ADAPTATION","LIBRE","RAFFINEMENT",jdc),"MCsousMCFaPourValeur"),),estunFacteur=0)
+ chercheOperInsereFacteurSiRegle(jdc,"MACR_ADAP_MAIL","ADAPTATIONEW='DERAFFINEMENT',",((("ADAPTATION","LIBRE","DERAFFINEMENT",jdc),"MCsousMCFaPourValeur"),),estunFacteur=0)
+ chercheOperInsereFacteurSiRegle(jdc,"MACR_ADAP_MAIL","ADAPTATIONEW='RAFF_DERA',",((("ADAPTATION","LIBRE","RAFF_DERA",jdc),"MCsousMCFaPourValeur"),),estunFacteur=0)
+ chercheOperInsereFacteurSiRegle(jdc,"MACR_ADAP_MAIL","ADAPTATIONEW='RAFFINEMENT_UNIFORME',",((("ADAPTATION","UNIFORME","RAFFINEMENT",jdc),"MCsousMCFaPourValeur"),),estunFacteur=0)
+ chercheOperInsereFacteurSiRegle(jdc,"MACR_ADAP_MAIL","ADAPTATIONEW='DERAFFINEMENT_UNIFORME',",((("ADAPTATION","UNIFORME","DERAFFINEMENT",jdc),"MCsousMCFaPourValeur"),),estunFacteur=0)
+ chercheOperInsereFacteurSiRegle(jdc,"MACR_ADAP_MAIL","ADAPTATIONEW='RIEN',",((("ADAPTATION","UNIFORME","RIEN",jdc),"MCsousMCFaPourValeur"),),estunFacteur=0)
+ removeMotCle(jdc,"MACR_ADAP_MAIL","ADAPTATION")
+ renameMotCle(jdc,"MACR_ADAP_MAIL","ADAPTATIONEW","ADAPTATION")
+ dcalcelemno={"ERRE_ELGA_NORE":"ERRE_ELEM_SIGM","ERRE_ELEM_NOZ1":"ERZ1_ELEM_SIGM","ERRE_ELEM_NOZ2":"ERZ2_ELEM_SIGM","ERRE_ELNO_ELGA":"ERRE_ELNO_ELEM","ERRE_NOEU_ELGA":"ERRE_NOEU_ELEM","ERTH_ELEM_TEMP":"ERRE_ELEM_TEMP","ERTH_ELNO_ELEM":"ERRE_ELNO_ELEM","EPGR_ELNO":"EPFP_ELNO","EPGR_ELGA":"EPFP_ELGA","DURT_ELGA_TEMP":"DURT_ELNO_TEMP"}
+ ChangementValeur(jdc,"MACR_ADAP_MAIL","ADAPTATION",dcalcelemno)
+
+
+ ####################### traitement IMPR_FICO_HOMARD #######################
+ removeCommande(jdc,"IMPR_FICO_HOMARD")
+
+
+ #########################################################################
+
+
+ f=open(outfile,'w')
+ f.write(jdc.getSource())
+ f.close()
+
+ log.ferme(hdlr)
+
+def main():
+ parser = optparse.OptionParser(usage=usage)
+
+ parser.add_option('-i','--infile', dest="infile", default='toto.comm',
+ help="Le fichier à traduire")
+ parser.add_option('-o','--outfile', dest="outfile", default='tutu.comm',
+ help="Le fichier traduit")
+
+ options, args = parser.parse_args()
+ traduc(options.infile,options.outfile)
+
+if __name__ == '__main__':
+ main()
+
x = index-startOfLineIdx
return x, y
-def linetodict(line):
- """Transforme une ligne (string) en un dictionnaire de mots repérés par le numéro de la colonne"""
+def lineToDict(line):
+ """Transforme une ligne (string) en un dictionnaire de mots
+ repérés par le numéro de la colonne"""
words = re.split("(\w+)", line)
h = {};i = 0
i+=len(word)
return h
-def dicttoline(d):
+def DictToLine(d):
"""Transformation inverse: à partir d'un dictionnaire retourne une ligne"""
cols = d.keys()
cols.sort()
class MatchFinder:
"""Visiteur de base : gestion des matches """
def reset(self,line):
- self.matches = []
+ self.matches=[]
+ self._matches = []
self.words = re.split("(\w+)", line) # every other one is a non word
self.positions = []
i = 0
def appendMatch(self,name):
idx = self.getNextIndexOfWord(name)
- self.matches.append((idx, name))
+ self._matches.append((idx, name))
def getNextIndexOfWord(self,name):
return self.positions[self.words.index(name)]
def visitKeyword(self,node):
idx = self.getNextIndexOfWord(node.name)
- #self.appendMatch(node.name)
self.popWordsUpTo(node.name)
- prevmatches=self.matches
- self.matches = []
+ prevmatches=self._matches
+ self._matches = []
for child in node.getChildNodes():
self.visit(child)
- prevmatches.append((idx, node.name,self.matches))
- self.matches=prevmatches
+ prevmatches.append((idx, node.name,self._matches))
+ self._matches=prevmatches
+ #on ne garde que les matches du niveau Keyword le plus haut
+ self.matches=self._matches
def visitTuple(self,node):
matchlist=[]
for child in node.getChildNodes():
- self.matches = []
+ self._matches = []
self.visit(child)
- if self.matches:
- #Pour eviter les tuples et listes ordinaires, on ne garde que les visites fructueuses
- matchlist.append(self.matches)
- self.matches=matchlist
+ if self._matches:
+ # Pour eviter les tuples et listes ordinaires,
+ # on ne garde que les visites fructueuses
+ matchlist.append(self._matches)
+ self._matches=matchlist
visitList=visitTuple
def visitName(self,node):
self.popWordsUpTo(node.name)
+
def visitAssName(self,node):
self.popWordsUpTo(node.name)
#fin de ligne ; suivi d'un nombre quelconque de blancs (pas multiligne)
pattern_fin = re.compile(r"; *$")
#pattern pour supprimer les blancs, tabulations et fins de ligne
-pattern_blancs = re.compile(r"[\s\n]")
+pattern_blancs = re.compile(r"[ \t\r\f\v]")
+#pattern_blancs = re.compile(r"[\s\n]")
number_kw_pattern=re.compile(r"""
(
#groupe nombre decimal
#argument keyword
[a-zA-Z_]\w*=
)
-""",re.VERBOSE)
+""",re.VERBOSE|re.MULTILINE)
def construit_genea(texte,liste_mc):
"""Retourne un dictionnaire dont les cles sont des reels et les valeurs sont leurs representations textuelles.
Realise un filtrage sur les reels :
- Ne garde que les reels pour lesquels str ne donne pas une bonne representation.
- Ne garde que les reels derriere un argument keyword dont le nom est dans liste_mc
- >>> s = 'a=+21.3e-5*85,b=-.1234,c=81.6 , d= -8 , e=_F(x=342.67,y=-1), f=+1.1, g=(1.3,-5,1.54E-3)'
+ >>> s = '''a=+21.3e-5*85,b=-.1234,c=81.6 , d= -8 , e=_F(x=342.67,y=-1), f=+1.1, g=(1.3,-5,1.54E-3),
+ ... #POMPE_PRIMA._BOUCLE_N._2_ELEMENT_NUMERO:0239
+ ... h=_F(x=34.6,y=-1)'''
>>> construit_genea(s,['a','x'])
{0.000213: '21.3e-5'}
"""
if commande_courante :
#on a une commande en cours. On l'enrichit ou on la termine
commande_courante.append_text(ligne)
- if not linecontinueRE.search(line) and (hangingBraces == emptyHangingBraces) and not hangingComments:
+ if not linecontinueRE.search(line) \
+ and (hangingBraces == emptyHangingBraces) \
+ and not hangingComments:
#la commande est terminée
#print "fin de commande"
self.analyse_reel(commande_courante.texte)
if affectation_courante != None :
#poursuite d'une affectation
affectation_courante.append_text(ligne)
- if not linecontinueRE.search(line) and (hangingBraces == emptyHangingBraces) and not hangingComments:
+ if not linecontinueRE.search(line) \
+ and (hangingBraces == emptyHangingBraces) \
+ and not hangingComments:
#L'affectation est terminée
affectation_courante=None
#on passe à la ligne suivante
affectation_courante = AFFECTATION(self)
affectation_courante.append_text(text)
- if not linecontinueRE.search(line) and (hangingBraces == emptyHangingBraces) and not hangingComments:
+ if not linecontinueRE.search(line) \
+ and (hangingBraces == emptyHangingBraces) \
+ and not hangingComments:
#L'affectation est terminée
affectation_courante=None
#on passe à la ligne suivante
commande_courante = COMMANDE(self)
commande_courante.append_text(ligne)
#si la commande est complète, on la termine
- if not linecontinueRE.search(line) and (hangingBraces == emptyHangingBraces) and not hangingComments:
+ if not linecontinueRE.search(line) \
+ and (hangingBraces == emptyHangingBraces) \
+ and not hangingComments:
#la commande est terminée
#print "fin de commande"
self.analyse_reel(commande_courante.texte)
txt=self.texte
return txt
+def test():
+ import parseur_python
+ import doctest
+ doctest.testmod(parseur_python)
+
+
if __name__ == "__main__" :
import time
#fichier = 'D:/Eficas_dev/Tests/zzzz100a.comm'
self.indent=[]
self.texte_etape = etape
self.jdc_fini = self.jdc_fini + '\n' + self.texte_etape
+ #on enleve la premiere ligne si elle est blanche :
return self.jdc_fini
#
# Ajout PN pour defi_fonction
if self.texte_etape.find("DEFI_FONCTION") > 1 :
+ bool_fonction=1
if s_mcsimp.find("\n") > 1:
txt=""; bool = 0; numident=1
for l in s_mcsimp.splitlines() :
else :
txt=txt+('\n'+self.indent_courant*' '+numident*' ')*ind+l
s_mcsimp = txt
+ else :
+ bool_fonction=0
longueur = self.longueur(self.texte_etape)
increment = len(('\n'+self.indent_courant*' ')*ind + string.strip(s_mcsimp))
#self.jdc_fini = self.jdc_fini + ('\n'+self.indent_courant*' ')*ind + string.strip(s_mcsimp)
- if ((1-ind)*longueur+increment) <= self.l_max :
+ if (bool_fonction == 1 ) :
+ self.texte_etape = self.texte_etape +s_mcsimp
+ elif ( ((1-ind)*longueur+increment) <= self.l_max ) :
self.texte_etape = self.texte_etape + ('\n'+self.indent_courant*' ')*ind + string.strip(s_mcsimp)
else :
# il faut couper ...
s=texte + label
longueur = len(increment + label)
- if '(' not in valeur:
+ if ('(' not in valeur) or (valeur[0:3]=='"""'):
+# if ('(' not in valeur):
# il s'agit d'une vraie chaîne de caractères
val = len(valeur)
texte = (self.l_max-2-val)*' '+valeur
place (dépend des gouts !!!)
"""
# ATTENTION a l'ordre des tests : il peut avoir de l'importance (héritage)
+ premier=1
if isinstance(obj,Accas.PROC_ETAPE):
return self.generPROC_ETAPE(obj)
# Attention doit etre placé avant MACRO (raison : héritage)
elif isinstance(obj,Accas.ETAPE_NIVEAU):
return self.generETAPE_NIVEAU(obj)
elif isinstance(obj,Accas.COMMENTAIRE):
- return self.generCOMMENTAIRE(obj)
+ return self.generCOMMENTAIRE(obj,premier)
# Attention doit etre placé avant PARAMETRE (raison : héritage)
elif isinstance(obj,Accas.PARAMETRE_EVAL):
return self.generPARAMETRE_EVAL(obj)
return self.generFormula(obj)
else:
raise "Type d'objet non prévu",obj
+ premier=0
def generJDC(self,obj):
"""
"""
return 'EVAL("""'+ obj.valeur +'""")'
- def generCOMMENTAIRE(self,obj):
+ def generCOMMENTAIRE(self,obj,premier=0):
"""
Cette méthode convertit un COMMENTAIRE
en une liste de chaines de caractères à la syntaxe python
sans_saut = re.sub("\n$","",obj.valeur)
l_lignes = string.split(sans_saut,'\n')
txt=''
+ i=1
for ligne in l_lignes:
txt = txt + '#'+ligne+'\n'
# suppression du dernier saut de ligne
txt = re.sub("\n$","",txt)
+ # on ajoute un saut de ligne avant
+ pattern=re.compile(" ?\#")
+ m=pattern.match(txt)
+ if m and not premier:
+ txt="\n"+txt
return txt
def generPARAMETRE_EVAL(self,obj):
return repr(obj)
def generFormula(self,obj):
- return repr(obj)
+ #return repr(obj)
+ return str(obj)
def generPARAMETRE(self,obj):
"""
# Pour un flottant on utilise str
# ou la notation scientifique
s = str(valeur)
- try :
- clefobj=obj.GetNomConcept()
- if self.appli.dict_reels.has_key(clefobj):
- if self.appli.dict_reels[clefobj].has_key(valeur):
- s=self.appli.dict_reels[clefobj][valeur]
- except:
- pass
+ clefobj=etape.get_sdname()
+ if self.appli.dict_reels.has_key(clefobj):
+ if self.appli.dict_reels[clefobj].has_key(valeur):
+ s=self.appli.dict_reels[clefobj][valeur]
elif type(valeur) == types.StringType :
if valeur.find('\n') == -1:
# pas de retour chariot, on utilise repr
"""
import traceback
import types,string,re
+import math
from Noyau import N_CR
from Noyau.N_utils import repr_float
def SECTION(self,obj):
assert (self.commande != "" )
- if self.commande == "VisuCable" :
- self.dict_attributs["R"]=obj.val
+ if self.commande == "VisuCable" :
+ self.dict_attributs["R"]= math.sqrt(obj.val/math.pi).eval()
elif (self.commande !="VisuGrille") :
self.commande=self.commande+self.dict_suite_com[obj.valeur]
