From f915c06cd9182a855ff99527a373ff976fbcd815 Mon Sep 17 00:00:00 2001 From: Christian Caremoli <> Date: Fri, 15 Dec 2006 16:00:27 +0000 Subject: [PATCH] =?utf8?q?CCAR:=20merge=20de=20la=20branche=20de=20d=C3=A9?= =?utf8?q?veloppement=20V1=5F11a1=20dans=20la=20branche=20principale=20(ta?= =?utf8?q?g=20V1=5F11b5)?= MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit --- AIDE/fichiers/NEWS | 4 + Aster/Cata/Utilitai/Graph.py | 208 +- Aster/Cata/Utilitai/Sensibilite.py | 78 + Aster/Cata/Utilitai/System.py | 217 ++ Aster/Cata/Utilitai/Table.py | 554 ++- Aster/Cata/Utilitai/UniteAster.py | 35 +- Aster/Cata/Utilitai/Utmess.py | 47 +- Aster/Cata/Utilitai/liss_enveloppe.py | 931 +++++ Aster/Cata/Utilitai/optimize.py | 593 ++++ Aster/Cata/Utilitai/sup_gmsh.py | 5 +- Aster/Cata/Utilitai/t_fonction.py | 241 +- .../Cata/cataSTA7/Macro/defi_cable_bp_ops.py | 19 +- .../cataSTA7/Macro/macr_ascouf_mail_ops.py | 48 +- .../cataSTA7/Macro/macr_aspic_mail_ops.py | 16 +- .../cataSTA7/Macro/macro_matr_asse_ops.py | 8 +- Aster/Cata/cataSTA7/Macro/reca_algo.py | 8 +- Aster/Cata/cataSTA7/Macro/recal.py | 19 +- Aster/Cata/cataSTA7/__init__.py | 4 +- Aster/Cata/cataSTA7/cata.py | 356 +- Aster/Cata/cataSTA7/ops.py | 6 +- Aster/Cata/cataSTA8/Macro/calc_precont_ops.py | 20 +- Aster/Cata/cataSTA8/Macro/calc_table_ops.py | 25 +- .../cataSTA8/Macro/creation_donnees_homard.py | 93 +- .../Cata/cataSTA8/Macro/defi_cable_bp_ops.py | 23 +- .../Cata/cataSTA8/Macro/defi_inte_spec_ops.py | 153 + .../Cata/cataSTA8/Macro/exec_logiciel_ops.py | 184 + Aster/Cata/cataSTA8/Macro/impr_oar_ops.py | 769 ++++ Aster/Cata/cataSTA8/Macro/impr_table_ops.py | 10 +- .../Cata/cataSTA8/Macro/info_fonction_ops.py | 85 +- .../Cata/cataSTA8/Macro/lire_inte_spec_ops.py | 7 +- Aster/Cata/cataSTA8/Macro/lire_table_ops.py | 279 +- .../Cata/cataSTA8/Macro/macr_adap_mail_ops.py | 232 +- .../cataSTA8/Macro/macr_ascouf_calc_ops.py | 6 +- .../cataSTA8/Macro/macr_ascouf_mail_ops.py | 87 +- .../cataSTA8/Macro/macr_aspic_calc_ops.py | 18 +- .../cataSTA8/Macro/macr_aspic_mail_ops.py | 34 +- .../cataSTA8/Macro/macr_cabri_calc_ops.py | 4 +- .../cataSTA8/Macro/macr_cabri_mail_ops.py | 6 +- .../Cata/cataSTA8/Macro/macr_fiabilite_ops.py | 139 +- .../cataSTA8/Macro/macr_lign_coupe_ops.py | 6 +- Aster/Cata/cataSTA8/Macro/macr_recal_ops.py | 1053 +++++- Aster/Cata/cataSTA8/Macro/macr_spectre_ops.py | 357 ++ .../cataSTA8/Macro/macro_elas_mult_ops.py | 6 +- .../cataSTA8/Macro/macro_matr_asse_ops.py | 15 +- .../Cata/cataSTA8/Macro/macro_miss_3d_ops.py | 86 +- .../Cata/cataSTA8/Macro/post_dyna_alea_ops.py | 254 ++ Aster/Cata/cataSTA8/Macro/post_gp_ops.py | 371 ++ .../Cata/cataSTA8/Macro/post_k1_k2_k3_ops.py | 239 +- Aster/Cata/cataSTA8/Macro/post_k_trans_ops.py | 245 ++ Aster/Cata/cataSTA8/Macro/reca_algo.py | 182 +- .../Cata/cataSTA8/Macro/reca_calcul_aster.py | 909 +++++ Aster/Cata/cataSTA8/Macro/reca_controles.py | 228 ++ Aster/Cata/cataSTA8/Macro/reca_interp.py | 296 +- Aster/Cata/cataSTA8/Macro/reca_message.py | 170 +- Aster/Cata/cataSTA8/Macro/reca_utilitaires.py | 225 ++ Aster/Cata/cataSTA8/Macro/recal.py | 37 +- .../Cata/cataSTA8/Macro/simu_point_mat_ops.py | 327 ++ Aster/Cata/cataSTA8/Macro/stanley_ops.py | 7 +- Aster/Cata/cataSTA8/__init__.py | 6 +- Aster/Cata/cataSTA8/cata.py | 3121 ++++++++++------- Aster/Cata/cataSTA8/ops.py | 8 +- Aster/Cata/ops.py | 448 --- Aster/NEWS | 4 + Aster/alphasdist.py | 1 + Aster/editeur.ini | 5 +- Aster/prefs.py | 6 +- Aster/sdist.py | 6 +- Editeur/appli.py | 4 +- Editeur/bureau.py | 41 +- Editeur/compomacro.py | 22 +- Editeur/composimp.py | 18 +- Editeur/macrodisplay.py | 2 +- Editeur/menubar.py | 2 +- Editeur/panelsSalome.py | 145 +- Editeur/plusieursbasepanel.py | 10 +- Editeur/plusieursintopanel.py | 1 + Editeur/plusieurspanel.py | 4 +- Editeur/readercata.py | 5 + Editeur/uniquebasepanel.py | 7 +- Editeur/uniqueintopanel.py | 11 + Editeur/uniquepanel.py | 2 +- Editeur/widgets.py | 70 +- Extensions/jdc_include.py | 26 + Ihm/I_MACRO_ETAPE.py | 50 +- Ihm/I_MCSIMP.py | 11 +- Noyau/N_ETAPE.py | 11 +- Noyau/N_MACRO_ETAPE.py | 11 +- Noyau/N_MCLIST.py | 16 +- Noyau/N_SENSIBILITE.py | 3 + Tests/config.py | 5 +- Tests/editeur.ini | 53 + Tests/eficas_aster.py | 32 + Tests/prefs.py | 104 + Tests/properties.py | 25 + Tests/style.py | 63 + Tests/testastest/basetest.py | 67 + Tests/testastest/erreu01a.err | 4 + Tests/testastest/testaster1.py | 5 + Tests/testastest/testaster10.py | 5 + Tests/testastest/testaster2.py | 6 + Tests/testastest/testaster3.py | 5 + Tests/testastest/testaster4.py | 5 + Tests/testastest/testaster5.py | 5 + Tests/testastest/testaster6.py | 5 + Tests/testastest/testaster7.py | 6 + Tests/testastest/testaster8.py | 5 + Tests/testastest/testaster9.py | 5 + Tests/testcomm/hplp101b.comm | 189 + Tests/testcomm/hsnv100h.comm | 46 + Tests/testcomm/param1.err | 1 - Tests/testcomm/param2.com0 | 4 + Tests/testcomm/param2.comm | 4 + Tests/testcomm/param3.11 | 2 + Tests/testcomm/param3.12 | 1 + Tests/testcomm/param3.com0 | 11 + Tests/testcomm/param3.comm | 5 + Tests/testcomm/parseur.comm | 2 +- Tests/testcomm/testaster1.py | 40 - Tests/testcomm/testaster10.py | 40 - Tests/testcomm/testaster2.py | 40 - Tests/testcomm/testaster3.py | 40 - Tests/testcomm/testaster4.py | 40 - Tests/testcomm/testaster5.py | 44 - Tests/testcomm/testaster6.py | 40 - Tests/testcomm/testaster7.py | 44 - Tests/testcomm/testaster8.py | 40 - Tests/testcomm/testaster9.py | 40 - Tests/testcomm/testcomm.py | 5 +- Tests/testelem/az.comm | 6 +- Tests/testelem/azv6.comm | 6 +- Tests/testelem/testaz76.py | 4 +- Tests/testelem/testitem1.py | 2 +- Tests/testelem/testjdc1.py | 2 +- Tests/testelem/testjdc3.py | 2 +- Tests/testelem/testjdc4.py | 2 +- Tests/testelem/testzzz6az.py | 4 +- Tests/testihm/common.py | 3 + Tests/testihm/testihm1.py | 2 +- Tests/testihm/testihm2.py | 2 +- Tests/testihm/testihm4.py | 2 +- Traducteur/__init__.py | 20 + Traducteur/calcG.py | 139 + Traducteur/changeValeur.py | 270 ++ Traducteur/dictErreurs.py | 101 + Traducteur/inseremocle.py | 223 +- Traducteur/jdcparser.py | 75 - Traducteur/load.py | 20 +- Traducteur/log.py | 18 +- Traducteur/mocles.py | 46 +- Traducteur/movemocle.py | 95 +- Traducteur/parseur.py | 51 +- Traducteur/regles.py | 160 + Traducteur/removemocle.py | 126 +- Traducteur/renamemocle.py | 114 +- Traducteur/traduitV7V8.py | 430 +++ Traducteur/utils.py | 7 +- Traducteur/visiteur.py | 28 +- convert/parseur_python.py | 31 +- generator/Formatage.py | 11 +- generator/generator_python.py | 26 +- generator/generator_vers3DSalome.py | 5 +- 161 files changed, 13728 insertions(+), 4049 deletions(-) create mode 100644 Aster/Cata/Utilitai/Sensibilite.py create mode 100644 Aster/Cata/Utilitai/System.py create mode 100644 Aster/Cata/Utilitai/liss_enveloppe.py create mode 100644 Aster/Cata/Utilitai/optimize.py create mode 100644 Aster/Cata/cataSTA8/Macro/defi_inte_spec_ops.py create mode 100644 Aster/Cata/cataSTA8/Macro/exec_logiciel_ops.py create mode 100644 Aster/Cata/cataSTA8/Macro/impr_oar_ops.py create mode 100644 Aster/Cata/cataSTA8/Macro/macr_spectre_ops.py create mode 100644 Aster/Cata/cataSTA8/Macro/post_dyna_alea_ops.py create mode 100644 Aster/Cata/cataSTA8/Macro/post_gp_ops.py create mode 100644 Aster/Cata/cataSTA8/Macro/post_k_trans_ops.py create mode 100644 Aster/Cata/cataSTA8/Macro/reca_calcul_aster.py create mode 100644 Aster/Cata/cataSTA8/Macro/reca_controles.py create mode 100644 Aster/Cata/cataSTA8/Macro/reca_utilitaires.py create mode 100644 Aster/Cata/cataSTA8/Macro/simu_point_mat_ops.py delete mode 100644 Aster/Cata/ops.py create mode 100644 Tests/editeur.ini create mode 100755 Tests/eficas_aster.py create mode 100644 Tests/properties.py create mode 100644 Tests/style.py create mode 100644 Tests/testastest/basetest.py create mode 100644 Tests/testastest/erreu01a.err create mode 100644 Tests/testastest/testaster1.py create mode 100644 Tests/testastest/testaster10.py create mode 100644 Tests/testastest/testaster2.py create mode 100644 Tests/testastest/testaster3.py create mode 100644 Tests/testastest/testaster4.py create mode 100644 Tests/testastest/testaster5.py create mode 100644 Tests/testastest/testaster6.py create mode 100644 Tests/testastest/testaster7.py create mode 100644 Tests/testastest/testaster8.py create mode 100644 Tests/testastest/testaster9.py create mode 100755 Tests/testcomm/hplp101b.comm create mode 100755 Tests/testcomm/hsnv100h.comm delete mode 100644 Tests/testcomm/param1.err create mode 100644 Tests/testcomm/param2.com0 create mode 100644 Tests/testcomm/param2.comm create mode 100644 Tests/testcomm/param3.11 create mode 100644 Tests/testcomm/param3.12 create mode 100644 Tests/testcomm/param3.com0 create mode 100644 Tests/testcomm/param3.comm delete mode 100644 Tests/testcomm/testaster1.py delete mode 100644 Tests/testcomm/testaster10.py delete mode 100644 Tests/testcomm/testaster2.py delete mode 100644 Tests/testcomm/testaster3.py delete mode 100644 Tests/testcomm/testaster4.py delete mode 100644 Tests/testcomm/testaster5.py delete mode 100644 Tests/testcomm/testaster6.py delete mode 100644 Tests/testcomm/testaster7.py delete mode 100644 Tests/testcomm/testaster8.py delete mode 100644 Tests/testcomm/testaster9.py create mode 100644 Traducteur/__init__.py create mode 100644 Traducteur/calcG.py create mode 100644 Traducteur/changeValeur.py create mode 100644 Traducteur/dictErreurs.py delete mode 100644 Traducteur/jdcparser.py create mode 100644 Traducteur/regles.py create mode 100644 Traducteur/traduitV7V8.py diff --git a/AIDE/fichiers/NEWS b/AIDE/fichiers/NEWS index 1c80a9f9..60749235 100644 --- a/AIDE/fichiers/NEWS +++ b/AIDE/fichiers/NEWS @@ -1,3 +1,7 @@ +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. diff --git a/Aster/Cata/Utilitai/Graph.py b/Aster/Cata/Utilitai/Graph.py index e4fa2a28..6cc8ab3d 100644 --- a/Aster/Cata/Utilitai/Graph.py +++ b/Aster/Cata/Utilitai/Graph.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -19,6 +19,7 @@ # ====================================================================== # RESPONSABLE MCOURTOI M.COURTOIS +__all__ = ['Graph', 'AjoutParaCourbe'] import sys import os @@ -104,12 +105,12 @@ class Graph: 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' @@ -118,31 +119,56 @@ class Graph: 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): @@ -269,7 +295,7 @@ class Graph: if opts<>{}: kargs['opts']=opts if not FORMAT in para.keys(): - print ' Format inconnu : %s' % FORMAT + UTMESS('A', 'Objet Graph', 'Format inconnu : %s' % FORMAT) else: kargs['fmod']=para[FORMAT]['mode'] self.LastTraceArgs = kargs.copy() @@ -333,12 +359,24 @@ class TraceGraph: # 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={ @@ -355,7 +393,7 @@ class TraceGraph: # let's go self.Trace() - return + # ------------------------------------------------------------------------------ def __del__(self): """Fermeture du(des) fichier(s) à la destruction""" @@ -380,19 +418,19 @@ class TraceGraph: # ------------------------------------------------------------------------------ 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." # ------------------------------------------------------------------------------ @@ -420,12 +458,12 @@ class TraceTableau(TraceGraph): max0=max(abs(t0)) for i in range(1,g.NbCourbe): if g.Courbe(i)['NbPts']<>g.Courbe(0)['NbPts']: - msg.append(" 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(" 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.") @@ -462,7 +500,7 @@ class TraceTableau(TraceGraph): Tab.Impr(FICHIER=self.NomFich[0], FORMAT='TABLEAU') # erreurs ? if msg: - print '\n'.join(msg) + UTMESS('A', 'Graph.TraceTableau', '\n'.join(msg)) return # ------------------------------------------------------------------------------ @@ -796,23 +834,29 @@ class TraceXmgrace(TraceGraph): 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 @@ -826,9 +870,13 @@ class TraceXmgrace(TraceGraph): 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): @@ -836,62 +884,66 @@ class TraceXmgrace(TraceGraph): 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 @@ -1142,10 +1194,14 @@ def IniGrace(fich): fnew.write(line) fpre.close() fnew.close() - print """ + try: + UTMESS('I', 'Graph.IniGrace', """ 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 diff --git a/Aster/Cata/Utilitai/Sensibilite.py b/Aster/Cata/Utilitai/Sensibilite.py new file mode 100644 index 00000000..9d0ad2b0 --- /dev/null +++ b/Aster/Cata/Utilitai/Sensibilite.py @@ -0,0 +1,78 @@ +#@ 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 diff --git a/Aster/Cata/Utilitai/System.py b/Aster/Cata/Utilitai/System.py new file mode 100644 index 00000000..9ecb9b66 --- /dev/null +++ b/Aster/Cata/Utilitai/System.py @@ -0,0 +1,217 @@ +#@ 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), _('_ALARM')) + if self.debug: + self._print(' ', cmd) + self._print(' 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...') + diff --git a/Aster/Cata/Utilitai/Table.py b/Aster/Cata/Utilitai/Table.py index b923acf3..9ad24144 100644 --- a/Aster/Cata/Utilitai/Table.py +++ b/Aster/Cata/Utilitai/Table.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -19,22 +19,29 @@ # ====================================================================== # 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: @@ -43,15 +50,18 @@ if not sys.modules.has_key('Graph'): 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' # ------------------------------------------------------------------------------ # ------------------------------------------------------------------------------ @@ -61,13 +71,26 @@ class TableBase(object): (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, @@ -87,7 +110,7 @@ class TableBase(object): '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) @@ -98,36 +121,36 @@ class TableBase(object): 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) @@ -147,7 +170,8 @@ class TableBase(object): 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 @@ -156,6 +180,8 @@ class TableBase(object): 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=[] @@ -172,9 +198,9 @@ class TableBase(object): 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') @@ -182,7 +208,7 @@ class TableBase(object): 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) @@ -196,7 +222,7 @@ class TableBase(object): 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: @@ -210,9 +236,14 @@ class TableBase(object): 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): @@ -223,19 +254,23 @@ class TableBase(object): 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) @@ -285,6 +320,7 @@ class Table(TableBase): 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) @@ -292,22 +328,124 @@ class Table(TableBase): 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 ilen(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: @@ -360,16 +488,17 @@ class Table(TableBase): 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 ' args=',args new_rows=[] new_para=args new_type=[] @@ -384,6 +513,7 @@ class Table(TableBase): 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: @@ -393,6 +523,7 @@ class Table(TableBase): 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: @@ -403,6 +534,7 @@ class Table(TableBase): 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. @@ -412,25 +544,67 @@ class Table(TableBase): 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] @@ -459,6 +633,20 @@ class Table(TableBase): 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] + # ------------------------------------------------------------------------------ # ------------------------------------------------------------------------------ # ------------------------------------------------------------------------------ @@ -469,13 +657,14 @@ class Colonne(TableBase): 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). @@ -486,6 +675,7 @@ class Colonne(TableBase): 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, @@ -493,18 +683,23 @@ class Colonne(TableBase): """ 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 vNone 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) @@ -522,6 +717,16 @@ class Colonne(TableBase): vmax=(1.+PRECISION)*VALE return self._extract(lambda v: v<>None and vminNone and (vs',dform['form'+typAster]) - #print nform, typAster, fmt else: fmt=dform[nform] else: @@ -647,76 +871,96 @@ def FMT(dform, nform, typAster=None, larg=0, val=''): 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.' diff --git a/Aster/Cata/Utilitai/UniteAster.py b/Aster/Cata/Utilitai/UniteAster.py index 141b3249..54e2adc4 100644 --- a/Aster/Cata/Utilitai/UniteAster.py +++ b/Aster/Cata/Utilitai/UniteAster.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -84,16 +84,17 @@ class UniteAster: print __tab.EXTR_TABLE() raise aster.FatalError," %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) @@ -103,7 +104,7 @@ class UniteAster: self.infos[unit]['nom'] raise aster.FatalError," %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' @@ -129,8 +130,9 @@ class UniteAster: """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: @@ -156,17 +158,26 @@ class UniteAster: 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'] diff --git a/Aster/Cata/Utilitai/Utmess.py b/Aster/Cata/Utilitai/Utmess.py index 1659f9ef..11810168 100644 --- a/Aster/Cata/Utilitai/Utmess.py +++ b/Aster/Cata/Utilitai/Utmess.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -23,42 +23,27 @@ import aster 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 diff --git a/Aster/Cata/Utilitai/liss_enveloppe.py b/Aster/Cata/Utilitai/liss_enveloppe.py new file mode 100644 index 00000000..0545b1d5 --- /dev/null +++ b/Aster/Cata/Utilitai/liss_enveloppe.py @@ -0,0 +1,931 @@ +#@ 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 (k2kr) : kr = k2 + kinf = kr + + kr = max(dct.keys()) + for k2 in dct.keys() : + if (k2>k1) and (k2 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 diff --git a/Aster/Cata/Utilitai/optimize.py b/Aster/Cata/Utilitai/optimize.py new file mode 100644 index 00000000..7735eb75 --- /dev/null +++ b/Aster/Cata/Utilitai/optimize.py @@ -0,0 +1,593 @@ +#@ 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] + + + + + + + + + + + + + + + + diff --git a/Aster/Cata/Utilitai/sup_gmsh.py b/Aster/Cata/Utilitai/sup_gmsh.py index a173ab11..94e323ce 100644 --- a/Aster/Cata/Utilitai/sup_gmsh.py +++ b/Aster/Cata/Utilitai/sup_gmsh.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -1320,8 +1320,9 @@ class Mesh : 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) diff --git a/Aster/Cata/Utilitai/t_fonction.py b/Aster/Cata/Utilitai/t_fonction.py index 0ead839c..ed6042b1 100644 --- a/Aster/Cata/Utilitai/t_fonction.py +++ b/Aster/Cata/Utilitai/t_fonction.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -20,8 +20,14 @@ 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))) @@ -29,38 +35,41 @@ def interp(typ_i,val,x1,x2,y1,y2) : 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) @@ -71,10 +80,11 @@ class t_fonction : 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) @@ -86,34 +96,37 @@ class t_fonction : 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], @@ -124,7 +137,7 @@ class t_fonction : 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], @@ -138,11 +151,12 @@ class t_fonction : 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 @@ -165,18 +179,19 @@ class t_fonction : 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) @@ -186,9 +201,10 @@ class t_fonction : 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)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] @@ -391,31 +420,35 @@ class t_fonction : 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 @@ -439,7 +472,7 @@ class t_fonction_c(t_fonction) : 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) @@ -456,42 +489,45 @@ class t_fonction_c(t_fonction) : 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[-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], @@ -514,30 +550,43 @@ class t_nappe : 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]) @@ -545,10 +594,11 @@ class t_nappe : 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() @@ -565,11 +615,12 @@ class t_nappe : 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':[]} diff --git a/Aster/Cata/cataSTA7/Macro/defi_cable_bp_ops.py b/Aster/Cata/cataSTA7/Macro/defi_cable_bp_ops.py index 3d234d76..8608ddec 100644 --- a/Aster/Cata/cataSTA7/Macro/defi_cable_bp_ops.py +++ b/Aster/Cata/cataSTA7/Macro/defi_cable_bp_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -54,7 +54,7 @@ def defi_cable_bp_ops(self,MAILLAGE,MODELE,CHAM_MATER,CARA_ELEM,GROUP_MA_BETON, 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 @@ -151,7 +151,12 @@ def defi_cable_bp_ops(self,MAILLAGE,MODELE,CHAM_MATER,CARA_ELEM,GROUP_MA_BETON, 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 ' # ---------------------------------------------------------------------------' @@ -187,7 +192,13 @@ def defi_cable_bp_ops(self,MAILLAGE,MODELE,CHAM_MATER,CARA_ELEM,GROUP_MA_BETON, 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 ' # ---------------------------------------------------------------------------' diff --git a/Aster/Cata/cataSTA7/Macro/macr_ascouf_mail_ops.py b/Aster/Cata/cataSTA7/Macro/macr_ascouf_mail_ops.py index 3d035a34..86357d0f 100644 --- a/Aster/Cata/cataSTA7/Macro/macr_ascouf_mail_ops.py +++ b/Aster/Cata/cataSTA7/Macro/macr_ascouf_mail_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -2572,15 +2572,16 @@ def macr_ascouf_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,COUDE, # 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 @@ -2741,8 +2742,8 @@ def macr_ascouf_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,COUDE, CRITERE = CRITER,),) - nomres=DEFI_GROUP(reuse =nomres, - MAILLAGE=nomres, + __nomres=DEFI_GROUP(reuse =__nomres, + MAILLAGE=__nomres, **motscles ) # # DEFI_GROUP 2 @@ -2771,12 +2772,12 @@ def macr_ascouf_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,COUDE, 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' , ) @@ -2801,8 +2802,8 @@ def macr_ascouf_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,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 @@ -2811,27 +2812,22 @@ def macr_ascouf_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,COUDE, 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,] diff --git a/Aster/Cata/cataSTA7/Macro/macr_aspic_mail_ops.py b/Aster/Cata/cataSTA7/Macro/macr_aspic_mail_ops.py index d1140f87..bb872ef0 100644 --- a/Aster/Cata/cataSTA7/Macro/macr_aspic_mail_ops.py +++ b/Aster/Cata/cataSTA7/Macro/macr_aspic_mail_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -222,6 +222,17 @@ def write_file_dgib_ASPID2(nomFichierDATG,UNITD, EPT1, DET1, D1, D2, EPT2, DET2, 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) : @@ -418,6 +429,7 @@ def macr_aspic_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,RAFF_MAIL,TUBULURE, 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) @@ -686,6 +698,8 @@ def macr_aspic_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,RAFF_MAIL,TUBULURE, 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), ), ) diff --git a/Aster/Cata/cataSTA7/Macro/macro_matr_asse_ops.py b/Aster/Cata/cataSTA7/Macro/macro_matr_asse_ops.py index 063c28a0..ee260dca 100644 --- a/Aster/Cata/cataSTA7/Macro/macro_matr_asse_ops.py +++ b/Aster/Cata/cataSTA7/Macro/macro_matr_asse_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -18,8 +18,6 @@ # 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): """ @@ -104,6 +102,10 @@ def macro_matr_asse_ops(self,MODELE,CHAM_MATER,CARA_ELEM,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): ier=ier+1 diff --git a/Aster/Cata/cataSTA7/Macro/reca_algo.py b/Aster/Cata/cataSTA7/Macro/reca_algo.py index 7854c628..61ccdc9d 100644 --- a/Aster/Cata/cataSTA7/Macro/reca_algo.py +++ b/Aster/Cata/cataSTA7/Macro/reca_algo.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -243,7 +243,11 @@ def actualise_lambda(l,val,new_val,A,erreur,new_J,old_J): 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(" Erreur dans le test de convergence de MACR_RECAL") + return epsilon = epsilon**0.5 return epsilon diff --git a/Aster/Cata/cataSTA7/Macro/recal.py b/Aster/Cata/cataSTA7/Macro/recal.py index 23781944..4de35252 100644 --- a/Aster/Cata/cataSTA7/Macro/recal.py +++ b/Aster/Cata/cataSTA7/Macro/recal.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -254,6 +254,21 @@ def compare__dim_rep__dim_RESU_EXP(REPONSES,RESU_EXP): txt="\nVous avez entré " +str(len(REPONSES))+ " réponses et "+str(len(RESU_EXP))+ " expériences ; On doit avoir autant de réponses que de résultats expérimentaux" return txt +def verif_RESU_EXP(RESU_EXP): + # RESU_EXP doit etre une liste de tableaux Numeric de taille Nx2 + # pour éviter l'arret du programme + txt="" + for index,resu in enumerate(RESU_EXP): + if (isinstance(resu,Numeric.ArrayType)): + if (len(Numeric.shape(resu)) != 2): + txt="\nLa courbe experimentale no " +str(index+1)+ " n'est pas un tableau de N lignes et 2 colonnes." + else: + if (Numeric.shape(resu)[1] != 2): + txt="\nLa courbe experimentale no " +str(index+1)+ " n'est pas un tableau de N lignes et 2 colonnes." + 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 @@ -348,6 +363,8 @@ def gestion(UL,PARAMETRES,REPONSES,RESU_EXP,POIDS,GRAPHIQUE,UNITE_RESU): #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 diff --git a/Aster/Cata/cataSTA7/__init__.py b/Aster/Cata/cataSTA7/__init__.py index 654fb130..0a644069 100644 --- a/Aster/Cata/cataSTA7/__init__.py +++ b/Aster/Cata/cataSTA7/__init__.py @@ -1,6 +1,4 @@ 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 * diff --git a/Aster/Cata/cataSTA7/cata.py b/Aster/Cata/cataSTA7/cata.py index 837b4826..b9c5aa0d 100644 --- a/Aster/Cata/cataSTA7/cata.py +++ b/Aster/Cata/cataSTA7/cata.py @@ -34,8 +34,8 @@ except: 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, @@ -4109,15 +4109,20 @@ ASSE_MATRICE=OPER(nom="ASSE_MATRICE",op=12,sd_prod=asse_matrice_prod, # 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 @@ -4137,20 +4142,15 @@ ASSE_VECT_GENE=OPER(nom="ASSE_VECT_GENE",op= 140,sd_prod=vect_asse_gene, # 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 @@ -5054,7 +5054,7 @@ CALC_FONC_INTERP=OPER(nom="CALC_FONC_INTERP",op= 134,sd_prod=calc_fonc_interp_pr 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 @@ -5188,7 +5188,7 @@ CALC_FONCTION=OPER(nom="CALC_FONCTION",op= 91,sd_prod=calc_fonction_prod 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") ), ), @@ -8143,6 +8143,42 @@ regles=(UN_PARMI('TOUT','GROUP_MA','MAILLE','INTERSEC','UNION','DIFFE','OPTION') # 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",)}, @@ -8203,42 +8239,6 @@ DEFI_INTE_SPEC=OPER(nom="DEFI_INTE_SPEC",op= 115,sd_prod=tabl_intsp, # 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", @@ -15247,7 +15247,7 @@ LIRE_TABLE=MACRO(nom="LIRE_TABLE",op=lire_table_ops,sd_prod=lire_table_prod, 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 @@ -15296,8 +15296,8 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada # # 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"), # @@ -16687,76 +16687,6 @@ MACR_ELEM_STAT=OPER(nom="MACR_ELEM_STAT",op=86,sd_prod=macr_elem_stat,reentrant= 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 # ====================================================================== @@ -17136,7 +17066,77 @@ MACR_FIABILITE = MACRO ( nom="MACR_FIABILITE",op=macr_fiabilite_ops, ), # ); -#& 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 @@ -17169,8 +17169,8 @@ MACR_INFO_MAIL=MACRO(nom="MACR_INFO_MAIL",op=macr_adap_mail_ops, # # 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"), # @@ -17291,47 +17291,6 @@ MACR_LIGN_COUPE=MACRO(nom="MACR_LIGN_COUPE",op=macr_lign_coupe_ops,sd_prod=macr_ #& 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 @@ -17788,6 +17747,47 @@ MACRO_PROJ_BASE=MACRO(nom="MACRO_PROJ_BASE",op=macro_proj_base_ops, #& 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 diff --git a/Aster/Cata/cataSTA7/ops.py b/Aster/Cata/cataSTA7/ops.py index 50a805dd..89963674 100644 --- a/Aster/Cata/cataSTA7/ops.py +++ b/Aster/Cata/cataSTA7/ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -136,6 +136,10 @@ def POURSUITE(self,PAR_LOT,CODE,**args): 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 : diff --git a/Aster/Cata/cataSTA8/Macro/calc_precont_ops.py b/Aster/Cata/cataSTA8/Macro/calc_precont_ops.py index 68ddb810..afe030a7 100644 --- a/Aster/Cata/cataSTA8/Macro/calc_precont_ops.py +++ b/Aster/Cata/cataSTA8/Macro/calc_precont_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -25,7 +25,7 @@ def calc_precont_ops(self,reuse,MODELE,CHAM_MATER,CARA_ELEM,EXCIT, CABLE_BP,CABLE_BP_INACTIF, COMP_INCR,ETAT_INIT,NEWTON,RECH_LINEAIRE, CONVERGENCE,INCREMENT,SOLVEUR,SOLV_NON_LOCAL, - LAGR_NON_LOCAL,PARM_THETA,INFO,TITRE,**args): + LAGR_NON_LOCAL,INFO,TITRE,**args): """ @@ -291,12 +291,20 @@ def calc_precont_ops(self,reuse,MODELE,CHAM_MATER,CARA_ELEM,EXCIT, 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 @@ -354,11 +362,11 @@ def calc_precont_ops(self,reuse,MODELE,CHAM_MATER,CARA_ELEM,EXCIT, _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, ) @@ -421,7 +429,6 @@ def calc_precont_ops(self,reuse,MODELE,CHAM_MATER,CARA_ELEM,EXCIT, SOLV_NON_LOCAL = dSolv_nonloc, LAGR_NON_LOCAL = dLagr_nonloc, ARCHIVAGE = _F(INST = __TINT), - PARM_THETA = PARM_THETA, INFO =INFO, TITRE = TITRE, EXCIT = dExcit1, @@ -457,7 +464,6 @@ def calc_precont_ops(self,reuse,MODELE,CHAM_MATER,CARA_ELEM,EXCIT, LAGR_NON_LOCAL = dLagr_nonloc, ARCHIVAGE = _F(NUME_INIT = __no, DETR_NUME_SUIV = 'OUI' ), - PARM_THETA = PARM_THETA, INFO =INFO, TITRE = TITRE, EXCIT =dExcit2, diff --git a/Aster/Cata/cataSTA8/Macro/calc_table_ops.py b/Aster/Cata/cataSTA8/Macro/calc_table_ops.py index cd62da23..74201a01 100644 --- a/Aster/Cata/cataSTA8/Macro/calc_table_ops.py +++ b/Aster/Cata/cataSTA8/Macro/calc_table_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -29,19 +29,23 @@ def calc_table_ops(self, TABLE, ACTION, INFO, **args): 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 @@ -112,7 +116,7 @@ def calc_table_ops(self, TABLE, ACTION, INFO, **args): 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] @@ -157,6 +161,7 @@ def calc_table_ops(self, TABLE, ACTION, INFO, **args): 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 diff --git a/Aster/Cata/cataSTA8/Macro/creation_donnees_homard.py b/Aster/Cata/cataSTA8/Macro/creation_donnees_homard.py index 3c41eccf..ed50681b 100644 --- a/Aster/Cata/cataSTA8/Macro/creation_donnees_homard.py +++ b/Aster/Cata/cataSTA8/Macro/creation_donnees_homard.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -18,11 +18,11 @@ # 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 @@ -109,9 +109,9 @@ class creation_donnees_homard: # 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 # ------------------------------------------------------------------------------ @@ -173,6 +173,8 @@ class creation_donnees_homard: 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 # @@ -269,12 +271,12 @@ class creation_donnees_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 @@ -370,8 +372,8 @@ class creation_donnees_homard: 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 # @@ -409,35 +411,37 @@ class creation_donnees_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") @@ -454,7 +458,7 @@ class creation_donnees_homard: 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") @@ -466,13 +470,16 @@ class creation_donnees_homard: 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") : @@ -482,6 +489,12 @@ class creation_donnees_homard: 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() diff --git a/Aster/Cata/cataSTA8/Macro/defi_cable_bp_ops.py b/Aster/Cata/cataSTA8/Macro/defi_cable_bp_ops.py index 552fe5e0..5d77d5a3 100644 --- a/Aster/Cata/cataSTA8/Macro/defi_cable_bp_ops.py +++ b/Aster/Cata/cataSTA8/Macro/defi_cable_bp_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -54,7 +54,7 @@ def defi_cable_bp_ops(self,MAILLAGE,MODELE,CHAM_MATER,CARA_ELEM,GROUP_MA_BETON, 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 @@ -150,7 +150,12 @@ def defi_cable_bp_ops(self,MAILLAGE,MODELE,CHAM_MATER,CARA_ELEM,GROUP_MA_BETON, 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' ) @@ -166,16 +171,15 @@ def defi_cable_bp_ops(self,MAILLAGE,MODELE,CHAM_MATER,CARA_ELEM,GROUP_MA_BETON, __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) ) @@ -185,7 +189,12 @@ def defi_cable_bp_ops(self,MAILLAGE,MODELE,CHAM_MATER,CARA_ELEM,GROUP_MA_BETON, 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' ) diff --git a/Aster/Cata/cataSTA8/Macro/defi_inte_spec_ops.py b/Aster/Cata/cataSTA8/Macro/defi_inte_spec_ops.py new file mode 100644 index 00000000..63a04aec --- /dev/null +++ b/Aster/Cata/cataSTA8/Macro/defi_inte_spec_ops.py @@ -0,0 +1,153 @@ +#@ 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'] 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 + diff --git a/Aster/Cata/cataSTA8/Macro/impr_oar_ops.py b/Aster/Cata/cataSTA8/Macro/impr_oar_ops.py new file mode 100644 index 00000000..ce3bf2b5 --- /dev/null +++ b/Aster/Cata/cataSTA8/Macro/impr_oar_ops.py @@ -0,0 +1,769 @@ +#@ 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\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 + "\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() diff --git a/Aster/Cata/cataSTA8/Macro/impr_table_ops.py b/Aster/Cata/cataSTA8/Macro/impr_table_ops.py index 4b90940d..fec1bdbb 100644 --- a/Aster/Cata/cataSTA8/Macro/impr_table_ops.py +++ b/Aster/Cata/cataSTA8/Macro/impr_table_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -145,8 +145,9 @@ def impr_table_ops(self, FORMAT, TABLE, INFO, **args): 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() @@ -193,7 +194,7 @@ def impr_table_ops(self, FORMAT, TABLE, INFO, **args): 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: @@ -213,7 +214,6 @@ def impr_table_ops(self, FORMAT, TABLE, INFO, **args): # 99. Traiter le cas des UL réservées UL.EtatInit() - return ier # ------------------------------------------------------------------------------ diff --git a/Aster/Cata/cataSTA8/Macro/info_fonction_ops.py b/Aster/Cata/cataSTA8/Macro/info_fonction_ops.py index 0554e0cd..0fe9c89e 100644 --- a/Aster/Cata/cataSTA8/Macro/info_fonction_ops.py +++ b/Aster/Cata/cataSTA8/Macro/info_fonction_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -27,9 +27,13 @@ def info_fonction_ops(self,RMS,NOCI_SEISME,MAX,NORME,ECART_TYPE,INFO,**args): 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') @@ -41,22 +45,69 @@ def info_fonction_ops(self,RMS,NOCI_SEISME,MAX,NORME,ECART_TYPE,INFO,**args): ### 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): diff --git a/Aster/Cata/cataSTA8/Macro/lire_inte_spec_ops.py b/Aster/Cata/cataSTA8/Macro/lire_inte_spec_ops.py index a2bd9567..e4f1188d 100644 --- a/Aster/Cata/cataSTA8/Macro/lire_inte_spec_ops.py +++ b/Aster/Cata/cataSTA8/Macro/lire_inte_spec_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -106,10 +106,11 @@ def lire_inte_spec_ops(self,UNITE,FORMAT,NOM_PARA,NOM_RESU,INTERPOL, 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() diff --git a/Aster/Cata/cataSTA8/Macro/lire_table_ops.py b/Aster/Cata/cataSTA8/Macro/lire_table_ops.py index 5d4edeff..af24a012 100644 --- a/Aster/Cata/cataSTA8/Macro/lire_table_ops.py +++ b/Aster/Cata/cataSTA8/Macro/lire_table_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -18,160 +18,135 @@ # 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= " NUME_TABLE :le nombre de blocs de tables dans " - message=message+"le fichier est "+str(texte.count(idt_deb)) - return 1,message,None,None,None - for i in range(nume): - texte=texte[texte.index(idt_deb)+1:] - texte=texte[:texte.index(idt_fin)] - - titre_tab=[string.rstrip(elem[7:-1]) for elem in texte if elem.find(idt_tit)!=-1] - texte_tab=[elem.split(separ) for elem in texte if elem.find(idt_tit)==-1] - - if ( separ!=None) : - tab_trav=[] - for line in texte_tab : - ligne=[] - for elem in line : - if ( elem != '' and elem !='\n') : - ligne.append(string.strip(elem)) - tab_trav.append(ligne) - texte_tab=tab_trav - - list_para=texte_tab[0] - list_type=texte_tab[1] - texte_tab.pop(0) - texte_tab.pop(0) - nb_para=len(texte_tab[0]) - - for line in texte_tab : - if len(line)!=nb_para : - message= " incoherence dans le nombre de colonnes " - message=message+"de la table a lire" - return 1,message,None,None,None - texte_tab=transpose(texte_tab) - for i in range(nb_para): - tab_trav=[] - list_val=[] - col_type=list_type[i] - if col_type=='R': - try : - texte_tab[i]=map(float,texte_tab[i]) - nume_lign.append([0]) - except ValueError: -# Presence de - dans la ligne - for indice in range(len(texte_tab[i])): - if texte_tab[i][indice]!='-': - tab_trav.append(indice+1) - list_val.append(float(texte_tab[i][indice])) - - nume_lign.append(tab_trav) - texte_tab[i]=list_val - elif col_type=='I' : - try : - texte_tab[i]=map(int,texte_tab[i]) - nume_lign.append([0]) -# Presence de - dans la ligne - except ValueError: - for indice in range(len(texte_tab[i])): - if texte_tab[i][indice]!='-': - tab_trav.append(indice+1) - list_val.append(float(texte_tab[i][indice])) - nume_lign.append(tab_trav) - texte_tab[i]=list_val - - else : - try : nume_lign.append([0]) - except ValueError: pass - - tab_lue[list_para[i]]=(list_type[i],texte_tab[i],nume_lign[i]) - - return 0,None,titre_tab,list_para,tab_lue - +def 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 diff --git a/Aster/Cata/cataSTA8/Macro/macr_adap_mail_ops.py b/Aster/Cata/cataSTA8/Macro/macr_adap_mail_ops.py index 0d1234c4..32a58b2e 100644 --- a/Aster/Cata/cataSTA8/Macro/macr_adap_mail_ops.py +++ b/Aster/Cata/cataSTA8/Macro/macr_adap_mail_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -19,6 +19,11 @@ # ====================================================================== # 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): @@ -51,7 +56,7 @@ def macr_adap_mail_ops ( self, # # 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é @@ -60,7 +65,7 @@ def macr_adap_mail_ops ( self, # # 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é @@ -73,6 +78,7 @@ def macr_adap_mail_ops ( self, # 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 @@ -80,7 +86,7 @@ def macr_adap_mail_ops ( self, import aster import string import os -#gn import shutil + import shutil # global Liste_Passages # @@ -120,9 +126,9 @@ def macr_adap_mail_ops ( self, 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") @@ -154,11 +160,12 @@ def macr_adap_mail_ops ( self, 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" @@ -175,18 +182,24 @@ def macr_adap_mail_ops ( self, 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 # @@ -207,10 +220,11 @@ def macr_adap_mail_ops ( self, # 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 ) : @@ -220,19 +234,27 @@ def macr_adap_mail_ops ( self, 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 # @@ -249,13 +271,13 @@ def macr_adap_mail_ops ( self, ### 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 # @@ -267,7 +289,7 @@ def macr_adap_mail_ops ( self, 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 # @@ -279,7 +301,7 @@ def macr_adap_mail_ops ( self, 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 @@ -315,8 +337,8 @@ def macr_adap_mail_ops ( self, # 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) @@ -326,8 +348,8 @@ def macr_adap_mail_ops ( self, 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 # @@ -433,21 +455,21 @@ def macr_adap_mail_ops ( self, ## # 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 ) # @@ -459,7 +481,7 @@ def macr_adap_mail_ops ( self, # 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"] @@ -468,7 +490,7 @@ def macr_adap_mail_ops ( self, **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) @@ -490,33 +512,34 @@ def macr_adap_mail_ops ( self, # 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] @@ -526,6 +549,18 @@ def macr_adap_mail_ops ( self, 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.) @@ -543,12 +578,12 @@ def macr_adap_mail_ops ( self, # 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) : @@ -556,14 +591,16 @@ def macr_adap_mail_ops ( self, 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 ) # #==================================================================== @@ -583,25 +620,26 @@ def macr_adap_mail_ops ( self, 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 @@ -611,7 +649,7 @@ def macr_adap_mail_ops ( self, # 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 @@ -625,16 +663,16 @@ def macr_adap_mail_ops ( self, # 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] @@ -663,13 +701,13 @@ def macr_adap_mail_ops ( self, # # 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==============================================================" @@ -690,21 +728,27 @@ def macr_adap_mail_ops ( self, #==================================================================== # # -#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+""+fichier_homard_vers_aster_2_2+" Ecriture de la commande de lecture des resultats med @@ -723,20 +767,24 @@ def macr_adap_mail_ops ( self, # 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"]) @@ -747,8 +795,12 @@ def macr_adap_mail_ops ( self, 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 ) # @@ -756,14 +808,14 @@ def macr_adap_mail_ops ( self, # 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) : diff --git a/Aster/Cata/cataSTA8/Macro/macr_ascouf_calc_ops.py b/Aster/Cata/cataSTA8/Macro/macr_ascouf_calc_ops.py index fcb37351..ac8e6edf 100644 --- a/Aster/Cata/cataSTA8/Macro/macr_ascouf_calc_ops.py +++ b/Aster/Cata/cataSTA8/Macro/macr_ascouf_calc_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -649,10 +649,8 @@ def macr_ascouf_calc_ops(self,TYPE_MAILLAGE,CL_BOL_P2_GV,MAILLAGE,MODELE,CHAM_MA 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); diff --git a/Aster/Cata/cataSTA8/Macro/macr_ascouf_mail_ops.py b/Aster/Cata/cataSTA8/Macro/macr_ascouf_mail_ops.py index 3495d88d..7a4bedb3 100644 --- a/Aster/Cata/cataSTA8/Macro/macr_ascouf_mail_ops.py +++ b/Aster/Cata/cataSTA8/Macro/macr_ascouf_mail_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -412,7 +412,7 @@ def ASCSEP(MCL_SOUS_EPAIS,ALPHA,RM,RC,EP,GEOM,SYME): # texte_final=string.join(echo_mess) aster.affiche('MESSAGE',texte_final) - return ier + return ier,AZIMC # ------------------------------------------------------------------------------ def ASCTCI(MCL_SOUS_EPAIS,RM): @@ -1516,13 +1516,15 @@ def write_file_dgib_ASCFDO(nomFichierDATG,RM,RC,ALPHA,NBTRAN,EP1,EP2,EPI,TETA1, # 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 @@ -1554,7 +1556,8 @@ def write_file_dgib_ASCSQO(nomFichierDATG,TYPELE,RM,RC,ALPHA,NBTRAN,EP1,EP2, 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: @@ -1574,6 +1577,7 @@ def write_file_dgib_ASCSQO(nomFichierDATG,TYPELE,RM,RC,ALPHA,NBTRAN,EP1,EP2, 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 @@ -1741,7 +1745,7 @@ def write_file_dgib_ASCSP1(nomFichierDATG,TYPELE,MCL_SOUS_EPAIS,NIVMAG,loc_datg) 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) @@ -1781,7 +1785,7 @@ def write_file_dgib_ASCSP1(nomFichierDATG,TYPELE,MCL_SOUS_EPAIS,NIVMAG,loc_datg) # 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): @@ -1879,6 +1883,10 @@ def write_file_pgib_ASCSDO(RM,RC,ALPHA,EP,LTCLIM,LTCHAR,NBEP, 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') @@ -1886,7 +1894,6 @@ def write_file_pgib_ASCSDO(RM,RC,ALPHA,EP,LTCLIM,LTCHAR,NBEP, fpgib.close() - ################################################################################ ################################################################################ ################################################################################ @@ -1902,7 +1909,7 @@ def write_file_pgib_ASCSP2(MCL_SOUS_EPAIS,NLX,NLY): 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 @@ -2037,7 +2044,6 @@ def macr_ascouf_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,COUDE, 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') @@ -2455,7 +2461,7 @@ def macr_ascouf_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,COUDE, 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) @@ -2475,6 +2481,7 @@ def macr_ascouf_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,COUDE, 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") # @@ -2496,12 +2503,12 @@ def macr_ascouf_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,COUDE, # 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) @@ -2512,15 +2519,16 @@ def macr_ascouf_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,COUDE, # 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 @@ -2681,8 +2689,8 @@ def macr_ascouf_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,COUDE, CRITERE = CRITER,),) - nomres=DEFI_GROUP(reuse =nomres, - MAILLAGE=nomres, + __nomres=DEFI_GROUP(reuse =__nomres, + MAILLAGE=__nomres, **motscles ) # # DEFI_GROUP 2 @@ -2711,17 +2719,10 @@ def macr_ascouf_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,COUDE, 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': @@ -2741,8 +2742,8 @@ def macr_ascouf_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,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 @@ -2751,25 +2752,21 @@ def macr_ascouf_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,COUDE, 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 diff --git a/Aster/Cata/cataSTA8/Macro/macr_aspic_calc_ops.py b/Aster/Cata/cataSTA8/Macro/macr_aspic_calc_ops.py index eda90f99..ac1b2f66 100644 --- a/Aster/Cata/cataSTA8/Macro/macr_aspic_calc_ops.py +++ b/Aster/Cata/cataSTA8/Macro/macr_aspic_calc_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -670,9 +670,7 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,C 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', @@ -688,9 +686,7 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,C 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', @@ -709,9 +705,7 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,C 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, @@ -733,9 +727,7 @@ def macr_aspic_calc_ops(self,TYPE_MAILLAGE,TUBULURE,MAILLAGE,MODELE,CHAM_MATER,C 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, diff --git a/Aster/Cata/cataSTA8/Macro/macr_aspic_mail_ops.py b/Aster/Cata/cataSTA8/Macro/macr_aspic_mail_ops.py index 783db3ab..d1b14cb6 100644 --- a/Aster/Cata/cataSTA8/Macro/macr_aspic_mail_ops.py +++ b/Aster/Cata/cataSTA8/Macro/macr_aspic_mail_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -216,15 +216,27 @@ def write_file_dgib_ASPID2(nomFichierDATG,UNITD, EPT1, DET1, D1, D2, EPT2, DET2, 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') : @@ -418,9 +430,9 @@ def macr_aspic_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,RAFF_MAIL,TUBULURE, 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) @@ -665,10 +677,12 @@ def macr_aspic_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,RAFF_MAIL,TUBULURE, 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() # @@ -743,12 +757,7 @@ def macr_aspic_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,RAFF_MAIL,TUBULURE, 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'),) @@ -756,7 +765,6 @@ def macr_aspic_mail_ops(self,EXEC_MAILLAGE,TYPE_ELEM,RAFF_MAIL,TUBULURE, motscles['ORIE_PEAU_3D']=_F(GROUP_MA=('PEAUINT','EXCORP1','EXCORP2','EXTUBU',),) __MAPROV=MODI_MAILLAGE(reuse =__MAPROV, MAILLAGE=__MAPROV, - MODELE =__MODELE, **motscles ) # diff --git a/Aster/Cata/cataSTA8/Macro/macr_cabri_calc_ops.py b/Aster/Cata/cataSTA8/Macro/macr_cabri_calc_ops.py index da2fa29f..95ac8187 100644 --- a/Aster/Cata/cataSTA8/Macro/macr_cabri_calc_ops.py +++ b/Aster/Cata/cataSTA8/Macro/macr_cabri_calc_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -107,7 +107,7 @@ def macr_cabri_calc_ops(self,MAILLAGE,MODELE_MECA,MODELE_THER,CHAR_THER, 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,); + ); diff --git a/Aster/Cata/cataSTA8/Macro/macr_cabri_mail_ops.py b/Aster/Cata/cataSTA8/Macro/macr_cabri_mail_ops.py index 92154545..af724996 100644 --- a/Aster/Cata/cataSTA8/Macro/macr_cabri_mail_ops.py +++ b/Aster/Cata/cataSTA8/Macro/macr_cabri_mail_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -129,9 +129,7 @@ def macr_cabri_mail_ops(self,EXEC_MAILLAGE,RAFF_MAILLAGE,VERI_MAIL,GEOM_BRID, # 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( diff --git a/Aster/Cata/cataSTA8/Macro/macr_fiabilite_ops.py b/Aster/Cata/cataSTA8/Macro/macr_fiabilite_ops.py index 62a10eba..fae50474 100644 --- a/Aster/Cata/cataSTA8/Macro/macr_fiabilite_ops.py +++ b/Aster/Cata/cataSTA8/Macro/macr_fiabilite_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -92,18 +92,22 @@ def macr_fiabilite_ops(self, INFO, # 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. @@ -146,7 +150,7 @@ def macr_fiabilite_ops(self, INFO, # valeurs_lois = { } # - for m in VARIABLE : + for la_variable in VARIABLE : # v_moy_physique = None v_moy_loi = None @@ -157,33 +161,33 @@ def macr_fiabilite_ops(self, INFO, # 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) # @@ -191,23 +195,23 @@ def macr_fiabilite_ops(self, INFO, # 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" ) : @@ -225,8 +229,8 @@ def macr_fiabilite_ops(self, INFO, # 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 # @@ -246,12 +250,13 @@ def macr_fiabilite_ops(self, INFO, #____________________________________________________________________ # # - 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 ) @@ -269,16 +274,46 @@ def macr_fiabilite_ops(self, INFO, 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 # @@ -316,8 +351,8 @@ if __name__ == "__main__" : 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) # diff --git a/Aster/Cata/cataSTA8/Macro/macr_lign_coupe_ops.py b/Aster/Cata/cataSTA8/Macro/macr_lign_coupe_ops.py index a2912b6e..639b6685 100644 --- a/Aster/Cata/cataSTA8/Macro/macr_lign_coupe_ops.py +++ b/Aster/Cata/cataSTA8/Macro/macr_lign_coupe_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -218,9 +218,11 @@ def macr_lign_coupe_ops(self,RESULTAT,UNITE_MAILLAGE,LIGN_COUPE,NOM_CHAM, 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); diff --git a/Aster/Cata/cataSTA8/Macro/macr_recal_ops.py b/Aster/Cata/cataSTA8/Macro/macr_recal_ops.py index 40e793af..b067f58c 100644 --- a/Aster/Cata/cataSTA8/Macro/macr_recal_ops.py +++ b/Aster/Cata/cataSTA8/Macro/macr_recal_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -17,150 +17,1009 @@ # 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 RESI_GLOB_RELA) & (iter=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 + + diff --git a/Aster/Cata/cataSTA8/Macro/macr_spectre_ops.py b/Aster/Cata/cataSTA8/Macro/macr_spectre_ops.py new file mode 100644 index 00000000..6fb9a32f --- /dev/null +++ b/Aster/Cata/cataSTA8/Macro/macr_spectre_ops.py @@ -0,0 +1,357 @@ +#@ 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 diff --git a/Aster/Cata/cataSTA8/Macro/macro_elas_mult_ops.py b/Aster/Cata/cataSTA8/Macro/macro_elas_mult_ops.py index bdd9e7df..b9dac9fe 100644 --- a/Aster/Cata/cataSTA8/Macro/macro_elas_mult_ops.py +++ b/Aster/Cata/cataSTA8/Macro/macro_elas_mult_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -242,8 +242,8 @@ def macro_elas_mult_ops(self,MODELE,CHAM_MATER,CARA_ELEM,NUME_DDL, 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: diff --git a/Aster/Cata/cataSTA8/Macro/macro_matr_asse_ops.py b/Aster/Cata/cataSTA8/Macro/macro_matr_asse_ops.py index 60374b6c..ddf508f1 100644 --- a/Aster/Cata/cataSTA8/Macro/macro_matr_asse_ops.py +++ b/Aster/Cata/cataSTA8/Macro/macro_matr_asse_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -21,7 +21,7 @@ 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 """ @@ -104,6 +104,10 @@ def macro_matr_asse_ops(self,MODELE,CHAM_MATER,CARA_ELEM,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)") @@ -145,5 +149,10 @@ def macro_matr_asse_ops(self,MODELE,CHAM_MATER,CARA_ELEM,MATR_ASSE, 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 diff --git a/Aster/Cata/cataSTA8/Macro/macro_miss_3d_ops.py b/Aster/Cata/cataSTA8/Macro/macro_miss_3d_ops.py index 54af120b..97b6bd15 100644 --- a/Aster/Cata/cataSTA8/Macro/macro_miss_3d_ops.py +++ b/Aster/Cata/cataSTA8/Macro/macro_miss_3d_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -44,9 +44,24 @@ def macro_miss_3d_ops(self,UNITE_IMPR_ASTER,UNITE_OPTI_MISS, 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': @@ -65,7 +80,7 @@ def macro_miss_3d_ops(self,UNITE_IMPR_ASTER,UNITE_OPTI_MISS, 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'] @@ -78,47 +93,48 @@ def macro_miss_3d_ops(self,UNITE_IMPR_ASTER,UNITE_OPTI_MISS, 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, ), ) diff --git a/Aster/Cata/cataSTA8/Macro/post_dyna_alea_ops.py b/Aster/Cata/cataSTA8/Macro/post_dyna_alea_ops.py new file mode 100644 index 00000000..db6f62ab --- /dev/null +++ b/Aster/Cata/cataSTA8/Macro/post_dyna_alea_ops.py @@ -0,0 +1,254 @@ +#@ 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 diff --git a/Aster/Cata/cataSTA8/Macro/post_gp_ops.py b/Aster/Cata/cataSTA8/Macro/post_gp_ops.py new file mode 100644 index 00000000..c72135c1 --- /dev/null +++ b/Aster/Cata/cataSTA8/Macro/post_gp_ops.py @@ -0,0 +1,371 @@ +#@ 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) + diff --git a/Aster/Cata/cataSTA8/Macro/post_k1_k2_k3_ops.py b/Aster/Cata/cataSTA8/Macro/post_k1_k2_k3_ops.py index 5f3f5533..a9797446 100644 --- a/Aster/Cata/cataSTA8/Macro/post_k1_k2_k3_ops.py +++ b/Aster/Cata/cataSTA8/Macro/post_k1_k2_k3_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -39,7 +39,13 @@ def cross_product(a,b): 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, @@ -77,9 +83,9 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,MATER,RESULTAT, # 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') # ------------------------------------------------------------------ @@ -177,63 +183,67 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,MATER,RESULTAT, 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': @@ -253,48 +263,84 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,MATER,RESULTAT, 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 @@ -308,7 +354,9 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,MATER,RESULTAT, 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],), @@ -324,14 +372,21 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,MATER,RESULTAT, 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] @@ -366,7 +421,7 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,MATER,RESULTAT, 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) @@ -450,10 +505,14 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,MATER,RESULTAT, 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) @@ -536,8 +595,10 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,MATER,RESULTAT, 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] @@ -855,7 +916,7 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,MATER,RESULTAT, 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))) @@ -878,12 +939,12 @@ def post_k1_k2_k3_ops(self,MODELISATION,FOND_FISS,MATER,RESULTAT, __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')) diff --git a/Aster/Cata/cataSTA8/Macro/post_k_trans_ops.py b/Aster/Cata/cataSTA8/Macro/post_k_trans_ops.py new file mode 100644 index 00000000..6295395b --- /dev/null +++ b/Aster/Cata/cataSTA8/Macro/post_k_trans_ops.py @@ -0,0 +1,245 @@ +#@ 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)=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 diff --git a/Aster/Cata/cataSTA8/Macro/reca_algo.py b/Aster/Cata/cataSTA8/Macro/reca_algo.py index 429de101..4c22e2bf 100644 --- a/Aster/Cata/cataSTA8/Macro/reca_algo.py +++ b/Aster/Cata/cataSTA8/Macro/reca_algo.py @@ -1,5 +1,6 @@ -#@ 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 @@ -18,16 +19,26 @@ # 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): @@ -35,11 +46,18 @@ 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) @@ -48,6 +66,8 @@ class Dimension: 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]): @@ -55,6 +75,7 @@ class Dimension: return A +# ------------------------------------------------------------------------------ def redim_sensi(self,A): for i in range(A.shape[0]): @@ -63,16 +84,29 @@ class Dimension: 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) @@ -84,7 +118,13 @@ def cond(matrix): condi=0.0 return condi,e[size-1],e[0] -#----------------------------------------- + + + + +# ------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------ + def norm(matrix): e=LinearAlgebra.Heigenvalues(matrix) size=len(e) @@ -92,10 +132,14 @@ def norm(matrix): 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): @@ -106,47 +150,20 @@ def lambda_init(matrix): 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 @@ -211,12 +228,15 @@ def Levenberg_bornes(self,val,Dim,val_init,borne_inf,borne_sup,A,erreur,l,ul_out 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) @@ -241,27 +261,45 @@ def actualise_lambda(l,val,new_val,A,erreur,new_J,old_J): 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) diff --git a/Aster/Cata/cataSTA8/Macro/reca_calcul_aster.py b/Aster/Cata/cataSTA8/Macro/reca_calcul_aster.py new file mode 100644 index 00000000..ed78aebd --- /dev/null +++ b/Aster/Cata/cataSTA8/Macro/reca_calcul_aster.py @@ -0,0 +1,909 @@ +#@ 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', '_ALARM', '_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 ---------------------------------------------------------------------------- + + + diff --git a/Aster/Cata/cataSTA8/Macro/reca_controles.py b/Aster/Cata/cataSTA8/Macro/reca_controles.py new file mode 100644 index 00000000..43f8dc3a --- /dev/null +++ b/Aster/Cata/cataSTA8/Macro/reca_controles.py @@ -0,0 +1,228 @@ +#@ 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_infPARAMETRES[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 + diff --git a/Aster/Cata/cataSTA8/Macro/reca_interp.py b/Aster/Cata/cataSTA8/Macro/reca_interp.py index 0d04cc21..d441a5e7 100644 --- a/Aster/Cata/cataSTA8/Macro/reca_interp.py +++ b/Aster/Cata/cataSTA8/Macro/reca_interp.py @@ -1,5 +1,6 @@ -#@ 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 @@ -18,11 +19,20 @@ # 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() + #=========================================================================================== @@ -36,29 +46,66 @@ class Sim_exp : 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 @@ -69,19 +116,31 @@ class Sim_exp : 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)): @@ -97,16 +156,25 @@ class Sim_exp : 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)): @@ -115,54 +183,131 @@ class Sim_exp : 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])) @@ -174,8 +319,7 @@ class Sim_exp : 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 diff --git a/Aster/Cata/cataSTA8/Macro/reca_message.py b/Aster/Cata/cataSTA8/Macro/reca_message.py index 0691b785..ec5d87fa 100644 --- a/Aster/Cata/cataSTA8/Macro/reca_message.py +++ b/Aster/Cata/cataSTA8/Macro/reca_message.py @@ -1,5 +1,6 @@ -#@ 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 @@ -18,7 +19,15 @@ # 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() #=========================================================================================== @@ -28,88 +37,137 @@ import os,Numeric 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(' 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 = ' 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) diff --git a/Aster/Cata/cataSTA8/Macro/reca_utilitaires.py b/Aster/Cata/cataSTA8/Macro/reca_utilitaires.py new file mode 100644 index 00000000..c2c3cd27 --- /dev/null +++ b/Aster/Cata/cataSTA8/Macro/reca_utilitaires.py @@ -0,0 +1,225 @@ +#@ 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) ) + diff --git a/Aster/Cata/cataSTA8/Macro/recal.py b/Aster/Cata/cataSTA8/Macro/recal.py index 2e43b088..684df91c 100644 --- a/Aster/Cata/cataSTA8/Macro/recal.py +++ b/Aster/Cata/cataSTA8/Macro/recal.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -22,24 +22,8 @@ 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 #_____________________________________________ @@ -232,6 +216,21 @@ def compare__dim_rep__dim_RESU_EXP(REPONSES,RESU_EXP): txt="\nVous avez entré " +str(len(REPONSES))+ " réponses et "+str(len(RESU_EXP))+ " expériences ; On doit avoir autant de réponses que de résultats expérimentaux" return txt +def verif_RESU_EXP(RESU_EXP): + # RESU_EXP doit etre une liste de tableaux Numeric de taille Nx2 + # pour éviter l'arret du programme + txt="" + for index,resu in enumerate(RESU_EXP): + if (isinstance(resu,Numeric.ArrayType)): + if (len(Numeric.shape(resu)) != 2): + txt="\nLa courbe experimentale no " +str(index+1)+ " n'est pas un tableau de N lignes et 2 colonnes." + else: + if (Numeric.shape(resu)[1] != 2): + txt="\nLa courbe experimentale no " +str(index+1)+ " n'est pas un tableau de N lignes et 2 colonnes." + 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 @@ -326,6 +325,8 @@ def gestion(UL,PARAMETRES,REPONSES,RESU_EXP,POIDS,GRAPHIQUE,UNITE_RESU): #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 diff --git a/Aster/Cata/cataSTA8/Macro/simu_point_mat_ops.py b/Aster/Cata/cataSTA8/Macro/simu_point_mat_ops.py new file mode 100644 index 00000000..54873925 --- /dev/null +++ b/Aster/Cata/cataSTA8/Macro/simu_point_mat_ops.py @@ -0,0 +1,327 @@ +#@ 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 + + + + diff --git a/Aster/Cata/cataSTA8/Macro/stanley_ops.py b/Aster/Cata/cataSTA8/Macro/stanley_ops.py index 51af193a..761b45fb 100644 --- a/Aster/Cata/cataSTA8/Macro/stanley_ops.py +++ b/Aster/Cata/cataSTA8/Macro/stanley_ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -33,6 +33,9 @@ def stanley_ops(self,RESULTAT,MODELE,CHAM_MATER,CARA_ELEM,DISPLAY,**args): 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 @@ -81,4 +84,6 @@ def stanley_ops(self,RESULTAT,MODELE,CHAM_MATER,CARA_ELEM,DISPLAY,**args): STANLEY(DISPLAY='adresse_ip:0.0');""") + aster.onFatalError(prev_onFatalError) + return ier diff --git a/Aster/Cata/cataSTA8/__init__.py b/Aster/Cata/cataSTA8/__init__.py index ee8be403..ea9a6f6b 100644 --- a/Aster/Cata/cataSTA8/__init__.py +++ b/Aster/Cata/cataSTA8/__init__.py @@ -1,8 +1,8 @@ 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 diff --git a/Aster/Cata/cataSTA8/cata.py b/Aster/Cata/cataSTA8/cata.py index e2497c03..3bfbb254 100755 --- a/Aster/Cata/cataSTA8/cata.py +++ b/Aster/Cata/cataSTA8/cata.py @@ -1,4 +1,4 @@ -#& 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 # ====================================================================== @@ -34,7 +34,7 @@ except: 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) @@ -109,7 +109,6 @@ class listis_sdaster (ASSD):pass 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 @@ -152,12 +151,15 @@ class mater_sdaster(ASSD): 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 @@ -206,7 +208,6 @@ class macr_elem_dyna (ASSD): 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 @@ -453,6 +454,7 @@ class comb_fourier (resultat_sdaster):pass 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 @@ -559,21 +561,23 @@ class fonction_sdaster(fonction_class): 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] @@ -626,28 +630,29 @@ class fonction_c(fonction_class): 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] @@ -1046,6 +1051,11 @@ class table_sdaster(ASSD): 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.""" @@ -1145,7 +1155,7 @@ class vect_elem_pres_c(vect_elem):pass 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 # ====================================================================== @@ -1172,6 +1182,7 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# "VISC_ISOT_TRAC", "VMIS_ISOT_LINE", "VISC_ISOT_LINE", + "VMIS_ISOT_PUIS", "VMIS_ECMI_TRAC", "VMIS_ECMI_LINE", "LABORD_1D", @@ -1215,7 +1226,6 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# "VMIS_CIN2_CHAB", "VISC_CIN1_CHAB", "VISC_CIN2_CHAB", - "POLY_CFC", "LMARC", "LMARC_IRRA", "ROUSSELIER", @@ -1268,7 +1278,8 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# "VMIS_ASYM_LINE", "ELAS_THER", "KIT_DDI", - "GLRC", + "GLRC_DAMAGE", + "GLRC_DM", "SANS", "CORR_ACIER", "MONOCRISTAL", @@ -1284,6 +1295,7 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# 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,)), @@ -1291,7 +1303,7 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# 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,)), @@ -1326,7 +1338,6 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# 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,)), @@ -1378,7 +1389,8 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# 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' ", @@ -1429,6 +1441,7 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# "VMIS_ISOT_TRAC", "VMIS_ISOT_LINE", "VMIS_ISOT_CINE", + "VMIS_ISOT_PUIS", "GRANGER_FP", "GRANGER_FP_INDT", "GRANGER_FP_V", @@ -1454,7 +1467,7 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# 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'),), @@ -1466,8 +1479,9 @@ def C_COMP_INCR() : return FACT(statut='f',min=1,max='**', #COMMUN# 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 @@ -1492,6 +1506,8 @@ def C_NOM_CHAM_INTO() : return ("ACCE", #COMMUN# "ACCE_ABSOLU", "ALPH0_ELGA_EPSP", "ALPHP_ELGA_ALPH0", + "ARCO_ELNO_SIGM", + "ARCO_NOEU_SIGM", "COMPORTEMENT", "COMPORTHER", "CRIT_ELNO_RUPT", @@ -1525,8 +1541,12 @@ def C_NOM_CHAM_INTO() : return ("ACCE", #COMMUN# "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", @@ -1853,7 +1873,7 @@ def C_TYPE_CHAM_INTO() : #COMMUN# 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 @@ -1980,6 +2000,7 @@ AFFE_CARA_ELEM=OPER(nom="AFFE_CARA_ELEM",op= 19,sd_prod=cara_elem, 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 ), @@ -2013,99 +2034,127 @@ AFFE_CARA_ELEM=OPER(nom="AFFE_CARA_ELEM",op= 19,sd_prod=cara_elem, # 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 ),), ), #============================================================================ @@ -2123,99 +2172,127 @@ AFFE_CARA_ELEM=OPER(nom="AFFE_CARA_ELEM",op= 19,sd_prod=cara_elem, # 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 ),), ), #============================================================================ @@ -2267,17 +2344,20 @@ AFFE_CARA_ELEM=OPER(nom="AFFE_CARA_ELEM",op= 19,sd_prod=cara_elem, #============================================================================ 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'),), @@ -2433,7 +2513,7 @@ AFFE_CHAR_ACOU=OPER(nom="AFFE_CHAR_ACOU",op= 68,sd_prod=char_acou, 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 @@ -2470,12 +2550,7 @@ AFFE_CHAR_CINE=OPER(nom="AFFE_CHAR_CINE",op= 101,sd_prod=affe_char_cine_prod 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='**'), @@ -2491,60 +2566,6 @@ AFFE_CHAR_CINE=OPER(nom="AFFE_CHAR_CINE",op= 101,sd_prod=affe_char_cine_prod 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'), @@ -2633,7 +2654,7 @@ AFFE_CHAR_CINE_F=OPER(nom="AFFE_CHAR_CINE_F",op= 108,sd_prod=affe_char_cine_f_pr ), 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 @@ -2661,10 +2682,9 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, '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'), ), @@ -2672,10 +2692,6 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, 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 ), @@ -3025,7 +3041,7 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, 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", @@ -3041,7 +3057,8 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, 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) ), ), @@ -3059,10 +3076,6 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, 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' ", @@ -3088,9 +3101,7 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, ), 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'), @@ -3099,7 +3110,6 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, ), 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), @@ -3138,7 +3148,6 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, 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), @@ -3178,7 +3187,6 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, 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' ", @@ -3186,6 +3194,9 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, ), 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), @@ -3199,6 +3210,17 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, 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',), @@ -3215,10 +3237,6 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, 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"), @@ -3249,8 +3267,6 @@ AFFE_CHAR_MECA=OPER(nom="AFFE_CHAR_MECA",op= 7,sd_prod=char_meca, 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'), @@ -3738,7 +3754,7 @@ AFFE_CHAR_MECA_C=OPER(nom="AFFE_CHAR_MECA_C",op= 7,sd_prod=char_meca, ), 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 @@ -3860,11 +3876,12 @@ AFFE_CHAR_MECA_F=OPER(nom="AFFE_CHAR_MECA_F",op=7,sd_prod=char_meca, 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) ), ), @@ -3950,7 +3967,7 @@ AFFE_CHAR_MECA_F=OPER(nom="AFFE_CHAR_MECA_F",op=7,sd_prod=char_meca, +" 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")), @@ -3980,10 +3997,6 @@ AFFE_CHAR_MECA_F=OPER(nom="AFFE_CHAR_MECA_F",op=7,sd_prod=char_meca, 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' ", @@ -4010,9 +4023,7 @@ AFFE_CHAR_MECA_F=OPER(nom="AFFE_CHAR_MECA_F",op=7,sd_prod=char_meca, ), 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)), @@ -4020,7 +4031,6 @@ AFFE_CHAR_MECA_F=OPER(nom="AFFE_CHAR_MECA_F",op=7,sd_prod=char_meca, ), 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), @@ -4055,7 +4065,6 @@ AFFE_CHAR_MECA_F=OPER(nom="AFFE_CHAR_MECA_F",op=7,sd_prod=char_meca, ),), 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), @@ -4092,7 +4101,6 @@ AFFE_CHAR_MECA_F=OPER(nom="AFFE_CHAR_MECA_F",op=7,sd_prod=char_meca, 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' ", @@ -4127,10 +4135,6 @@ AFFE_CHAR_MECA_F=OPER(nom="AFFE_CHAR_MECA_F",op=7,sd_prod=char_meca, 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"), @@ -4161,8 +4165,6 @@ AFFE_CHAR_MECA_F=OPER(nom="AFFE_CHAR_MECA_F",op=7,sd_prod=char_meca, 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)), @@ -4868,7 +4870,7 @@ AFFE_CHAR_THER_F=OPER(nom="AFFE_CHAR_THER_F",op=33,sd_prod=char_ther, 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 @@ -4894,8 +4896,8 @@ AFFE_MATERIAU=OPER(nom="AFFE_MATERIAU",op=6,sd_prod=cham_mater, 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",) ), @@ -4903,41 +4905,53 @@ AFFE_MATERIAU=OPER(nom="AFFE_MATERIAU",op=6,sd_prod=cham_mater, 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 : @@ -5009,13 +5023,32 @@ AFFE_MATERIAU=OPER(nom="AFFE_MATERIAU",op=6,sd_prod=cham_mater, 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 @@ -5042,9 +5075,9 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster, 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='**', @@ -5057,7 +5090,7 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster, 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", @@ -5071,7 +5104,6 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster, "3D_FLUI_ABSO", "3D_FLUIDE", "3D_INCO", - "3D_JOINT_CT", "3D_SI", "3D_GRAD_EPSI", "3D_GRAD_VARI", @@ -5152,6 +5184,7 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster, "D_PLAN_THH2MS", "D_PLAN_THHMS", "D_PLAN_THMS", + "D_PLAN_HM_P", "AXIS_THH", "AXIS_THHM", "AXIS_THM", @@ -5199,11 +5232,10 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster, "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", @@ -5218,7 +5250,7 @@ AFFE_MODELE=OPER(nom="AFFE_MODELE",op=18,sd_prod=modele_sdaster, ),),), 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" @@ -5373,18 +5405,14 @@ ASSE_MATRICE=OPER(nom="ASSE_MATRICE",op=12,sd_prod=asse_matrice_prod, # 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 @@ -5404,14 +5432,18 @@ ASSE_VECT_GENE=OPER(nom="ASSE_VECT_GENE",op= 140,sd_prod=vect_asse_gene, # 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 @@ -5604,7 +5636,7 @@ CALC_CHAR_SEISME=OPER(nom="CALC_CHAR_SEISME",op= 92,sd_prod=calc_char_seisme_pr ), 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 @@ -5636,7 +5668,7 @@ CALC_ELEM=OPER(nom="CALC_ELEM",op=58,sd_prod=calc_elem_prod,reentrant='f', 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"), @@ -5665,7 +5697,33 @@ CALC_ELEM=OPER(nom="CALC_ELEM",op=58,sd_prod=calc_elem_prod,reentrant='f', 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,\ @@ -5673,17 +5731,18 @@ CALC_ELEM=OPER(nom="CALC_ELEM",op=58,sd_prod=calc_elem_prod,reentrant='f', 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", @@ -5702,15 +5761,8 @@ CALC_ELEM=OPER(nom="CALC_ELEM",op=58,sd_prod=calc_elem_prod,reentrant='f', # 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 \ @@ -5781,53 +5833,15 @@ CALC_ELEM=OPER(nom="CALC_ELEM",op=58,sd_prod=calc_elem_prod,reentrant='f', 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 \ @@ -5862,15 +5876,6 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ "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) ),), ), @@ -5890,7 +5895,7 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ 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", @@ -5907,7 +5912,7 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ 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) ),), @@ -5920,19 +5925,20 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ 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 @@ -5950,13 +5956,8 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ 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 \ @@ -6001,48 +6002,20 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ # 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) ),), ), @@ -6053,24 +6026,8 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ 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"),), @@ -6093,9 +6050,6 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ "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'", @@ -6108,7 +6062,7 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ ), - 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", @@ -6138,8 +6092,8 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ ), # 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", @@ -6155,9 +6109,6 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ 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 @@ -6184,7 +6135,7 @@ b_charge =BLOC( condition = "OPTION in ('EPME_ELNO_DEPL','EPSI_ELGA_DEPL','EPME_ 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 @@ -6249,13 +6200,19 @@ CALC_FATIGUE=OPER(nom="CALC_FATIGUE",op= 151,sd_prod=calc_fatigue_prod,reentrant 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 ), @@ -6366,7 +6323,7 @@ CALC_FONC_INTERP=OPER(nom="CALC_FONC_INTERP",op= 134,sd_prod=calc_fonc_interp_pr 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 @@ -6462,7 +6419,7 @@ CALC_FONCTION=MACRO(nom="CALC_FONCTION",op=calc_fonction_ops,sd_prod=calc_foncti 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") ), ), @@ -6593,7 +6550,7 @@ CALC_FORC_AJOU=OPER(nom="CALC_FORC_AJOU",op=199,sd_prod=vect_asse_gene, ), ) ; -#& 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 @@ -6616,14 +6573,12 @@ CALC_G=OPER(nom="CALC_G",op=100,sd_prod=table_sdaster, +" 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),), @@ -6634,7 +6589,8 @@ CALC_G=OPER(nom="CALC_G",op=100,sd_prod=table_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'), @@ -6646,32 +6602,26 @@ CALC_G=OPER(nom="CALC_G",op=100,sd_prod=table_sdaster, ), ), - 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",) ), ), @@ -6708,13 +6658,14 @@ CALC_G=OPER(nom="CALC_G",op=100,sd_prod=table_sdaster, 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='**', @@ -6723,6 +6674,13 @@ CALC_G=OPER(nom="CALC_G",op=100,sd_prod=table_sdaster, 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), @@ -6733,7 +6691,7 @@ CALC_G=OPER(nom="CALC_G",op=100,sd_prod=table_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 @@ -6751,7 +6709,7 @@ CALC_G=OPER(nom="CALC_G",op=100,sd_prod=table_sdaster, # 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",)}, @@ -6762,7 +6720,7 @@ CALC_INTE_SPEC=OPER(nom="CALC_INTE_SPEC",op= 120,sd_prod=table_sdaster, 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 @@ -7069,7 +7027,7 @@ CALC_META=OPER(nom="CALC_META",op=194,sd_prod=evol_ther,reentrant='o', 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 @@ -7098,7 +7056,7 @@ CALC_NO=OPER(nom="CALC_NO",op= 106,sd_prod=calc_no_prod,reentrant='o', 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"), @@ -7136,6 +7094,7 @@ CALC_NO=OPER(nom="CALC_NO",op= 106,sd_prod=calc_no_prod,reentrant='o', "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", @@ -7173,7 +7132,7 @@ CALC_NO=OPER(nom="CALC_NO",op= 106,sd_prod=calc_no_prod,reentrant='o', 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 @@ -7218,9 +7177,43 @@ CALC_PRECONT=MACRO(nom="CALC_PRECONT",op=calc_precont_ops,sd_prod=evol_noli, 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', @@ -7311,8 +7304,6 @@ CALC_PRECONT=MACRO(nom="CALC_PRECONT",op=calc_precont_ops,sd_prod=evol_noli, 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='**' ), @@ -7322,7 +7313,7 @@ CALC_PRECONT=MACRO(nom="CALC_PRECONT",op=calc_precont_ops,sd_prod=evol_noli, 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 @@ -7344,19 +7335,26 @@ CALC_PRECONT=MACRO(nom="CALC_PRECONT",op=calc_precont_ops,sd_prod=evol_noli, # 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='**', @@ -7571,7 +7569,7 @@ CALC_VECT_ELEM=OPER(nom="CALC_VECT_ELEM",op=8,sd_prod=calc_vect_elem_prod,reentr 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 @@ -7590,33 +7588,15 @@ CALC_VECT_ELEM=OPER(nom="CALC_VECT_ELEM",op=8,sd_prod=calc_vect_elem_prod,reentr # 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 @@ -7634,130 +7614,51 @@ COMB_CHAM_ELEM=OPER(nom="COMB_CHAM_ELEM",op= 139,sd_prod=cham_elem,reentrant='f' # 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 @@ -7871,7 +7772,7 @@ COMB_SISM_MODAL=OPER(nom="COMB_SISM_MODAL",op= 109,sd_prod=mode_stat, ), 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 # ====================================================================== @@ -7918,7 +7819,7 @@ CREA_CHAMP=OPER(nom="CREA_CHAMP",op= 195,sd_prod=crea_champ_prod, # ------------------------------------------------------------------ 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'", @@ -7969,6 +7870,7 @@ CREA_CHAMP=OPER(nom="CREA_CHAMP",op= 195,sd_prod=crea_champ_prod, 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), ), ), # ------------------------------------------------------------------ @@ -7976,6 +7878,15 @@ CREA_CHAMP=OPER(nom="CREA_CHAMP",op= 195,sd_prod=crea_champ_prod, 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) ), @@ -8048,7 +7959,8 @@ CREA_CHAMP=OPER(nom="CREA_CHAMP",op= 195,sd_prod=crea_champ_prod, ), # fin bloc b_extr - ), + + ), # FIN DU CATALOGUE : INFO,TITRE ET TYPAGE DU RESULTAT : #----------------------------------------------------- INFO =SIMP(statut='f',typ='I',defaut= 1,into=(1,2,) ), @@ -8210,7 +8122,7 @@ CREA_MAILLAGE=OPER(nom="CREA_MAILLAGE",op= 167,sd_prod=maillage_sdaster, # 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 @@ -8234,6 +8146,7 @@ def crea_resu_prod(TYPE_RESU,**args): 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") @@ -8248,7 +8161,7 @@ CREA_RESU=OPER(nom="CREA_RESU",op=124,sd_prod=crea_resu_prod,reentrant='f', 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='**', @@ -8270,7 +8183,7 @@ CREA_RESU=OPER(nom="CREA_RESU",op=124,sd_prod=crea_resu_prod,reentrant='f', 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") ), ), @@ -8343,7 +8256,7 @@ CREA_RESU=OPER(nom="CREA_RESU",op=124,sd_prod=crea_resu_prod,reentrant='f', ), ) ; -#& 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 @@ -8361,7 +8274,16 @@ CREA_RESU=OPER(nom="CREA_RESU",op=124,sd_prod=crea_resu_prod,reentrant='f', # 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",)}, @@ -8390,28 +8312,31 @@ CREA_TABLE=OPER(nom="CREA_TABLE",op= 36,sd_prod=table_sdaster, 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",)}, @@ -8423,7 +8348,7 @@ DEBUT=MACRO(nom="DEBUT",op=ops.build_debut ,repetable='n', 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', @@ -8457,6 +8382,8 @@ DEBUT=MACRO(nom="DEBUT",op=ops.build_debut ,repetable='n', 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", @@ -8660,7 +8587,7 @@ DEFI_CABLE_OP=OPER(nom="DEFI_CABLE_OP",op= 180,sd_prod=cabl_precont,reentrant='n 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 # ====================================================================== @@ -8697,14 +8624,16 @@ DEFI_COMPOR=OPER(nom="DEFI_COMPOR",op=59,sd_prod=compor_sdaster, 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"), ), @@ -9476,7 +9405,7 @@ regles=(UN_PARMI('TOUT','GROUP_MA','MAILLE','INTERSEC','UNION','DIFFE','OPTION') 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 @@ -9494,9 +9423,49 @@ regles=(UN_PARMI('TOUT','GROUP_MA','MAILLE','INTERSEC','UNION','DIFFE','OPTION') # 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 ), @@ -9554,43 +9523,6 @@ DEFI_INTE_SPEC=OPER(nom="DEFI_INTE_SPEC",op= 115,sd_prod=table_sdaster, # 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", @@ -9646,7 +9578,7 @@ DEFI_LIST_REEL=OPER(nom="DEFI_LIST_REEL",op=24,sd_prod=listr8_sdaster, 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 @@ -9669,9 +9601,9 @@ DEFI_MAILLAGE=OPER(nom="DEFI_MAILLAGE",op= 88,sd_prod=maillage_sdaster, 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", @@ -9679,14 +9611,14 @@ DEFI_MAILLAGE=OPER(nom="DEFI_MAILLAGE",op= 88,sd_prod=maillage_sdaster, ), ), 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'", @@ -9705,18 +9637,18 @@ DEFI_MAILLAGE=OPER(nom="DEFI_MAILLAGE",op= 88,sd_prod=maillage_sdaster, 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"), @@ -9725,7 +9657,7 @@ DEFI_MAILLAGE=OPER(nom="DEFI_MAILLAGE",op= 88,sd_prod=maillage_sdaster, 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 @@ -9751,7 +9683,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, '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'), @@ -9759,7 +9691,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, 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'), @@ -9775,9 +9706,9 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, 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 @@ -10036,6 +9967,17 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, 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'), @@ -10217,39 +10159,6 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, 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'), @@ -10734,30 +10643,46 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, 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), @@ -12105,15 +12030,15 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, 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), @@ -12126,14 +12051,7 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, 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), @@ -12260,23 +12178,39 @@ DEFI_MATERIAU=OPER(nom="DEFI_MATERIAU",op=5,sd_prod=mater_sdaster, 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'), ), @@ -12407,7 +12341,7 @@ DEFI_NAPPE=OPER(nom="DEFI_NAPPE",op= 4,sd_prod=nappe_sdaster, 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 @@ -12425,10 +12359,10 @@ DEFI_NAPPE=OPER(nom="DEFI_NAPPE",op= 4,sd_prod=nappe_sdaster, # 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", @@ -12651,7 +12585,7 @@ DEFI_PART_PA_OPS=OPER(nom="DEFI_PART_PA_OPS",op=29,sd_prod=sd_feti_sdaster, 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 @@ -12732,7 +12666,7 @@ DEFI_SPEC_TURB=OPER(nom="DEFI_SPEC_TURB",op= 145,sd_prod=spectre_sdaster, 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), @@ -12741,7 +12675,7 @@ DEFI_SPEC_TURB=OPER(nom="DEFI_SPEC_TURB",op= 145,sd_prod=spectre_sdaster, ), 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 @@ -12853,37 +12787,6 @@ DEFI_SQUELETTE=OPER(nom="DEFI_SQUELETTE",op= 110,sd_prod=squelette, # 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" @@ -12902,7 +12805,7 @@ DEFI_TRC=OPER(nom="DEFI_TRC",op=94,sd_prod=table_sdaster,reentrant='n', 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 @@ -12920,11 +12823,20 @@ DEFI_TRC=OPER(nom="DEFI_TRC",op=94,sd_prod=table_sdaster,reentrant='n', # 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 @@ -12965,7 +12877,7 @@ DETRUIRE=MACRO(nom="DETRUIRE",op=-7, 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 @@ -12983,8 +12895,8 @@ DETRUIRE=MACRO(nom="DETRUIRE",op=-7, # 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', @@ -13003,7 +12915,7 @@ DYNA_ALEA_MODAL=OPER(nom="DYNA_ALEA_MODAL",op= 131,sd_prod=table_sdaster # 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") ), @@ -13141,7 +13053,7 @@ DYNA_LINE_HARM=OPER(nom="DYNA_LINE_HARM",op= 60,sd_prod=dyna_line_harm_prod, # 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 @@ -13254,12 +13166,13 @@ DYNA_LINE_TRAN=OPER(nom="DYNA_LINE_TRAN",op= 48,sd_prod=dyna_trans, 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='**', @@ -13297,7 +13210,7 @@ DYNA_LINE_TRAN=OPER(nom="DYNA_LINE_TRAN",op= 48,sd_prod=dyna_trans, 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 @@ -13439,9 +13352,43 @@ DYNA_NON_LINE=OPER(nom="DYNA_NON_LINE",op= 70,sd_prod=evol_noli,reentrant='f', 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',), @@ -13468,7 +13415,6 @@ DYNA_NON_LINE=OPER(nom="DYNA_NON_LINE",op= 70,sd_prod=evol_noli,reentrant='f', 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", @@ -13482,11 +13428,13 @@ DYNA_NON_LINE=OPER(nom="DYNA_NON_LINE",op= 70,sd_prod=evol_noli,reentrant='f', 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), @@ -13504,7 +13452,7 @@ DYNA_NON_LINE=OPER(nom="DYNA_NON_LINE",op= 70,sd_prod=evol_noli,reentrant='f', 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'),), @@ -13539,16 +13487,20 @@ DYNA_NON_LINE=OPER(nom="DYNA_NON_LINE",op= 70,sd_prod=evol_noli,reentrant='f', ), #------------------------------------------------------------------- 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, @@ -13644,10 +13596,12 @@ into=("DEPL","VITE","ACCE","SIEF_ELGA","VARI_ELGA","DEPL_ABSOLU","VITE_ABSOLU"," 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" ), @@ -13668,7 +13622,7 @@ into=("DEPL","VITE","ACCE","SIEF_ELGA","VARI_ELGA","DEPL_ABSOLU","VITE_ABSOLU"," 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 @@ -13686,34 +13640,34 @@ into=("DEPL","VITE","ACCE","SIEF_ELGA","VARI_ELGA","DEPL_ABSOLU","VITE_ABSOLU"," # 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",)}, @@ -13724,7 +13678,7 @@ DYNA_TRAN_EXPLI=OPER(nom="DYNA_TRAN_EXPLI",op= 70,sd_prod=evol_noli,reentrant='f 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'), @@ -13756,7 +13710,7 @@ DYNA_TRAN_EXPLI=OPER(nom="DYNA_TRAN_EXPLI",op= 70,sd_prod=evol_noli,reentrant='f 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='**' ), ), @@ -13768,7 +13722,7 @@ DYNA_TRAN_EXPLI=OPER(nom="DYNA_TRAN_EXPLI",op= 70,sd_prod=evol_noli,reentrant='f 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",) ), @@ -13818,9 +13772,43 @@ DYNA_TRAN_EXPLI=OPER(nom="DYNA_TRAN_EXPLI",op= 70,sd_prod=evol_noli,reentrant='f 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',), @@ -13841,7 +13829,6 @@ DYNA_TRAN_EXPLI=OPER(nom="DYNA_TRAN_EXPLI",op= 70,sd_prod=evol_noli,reentrant='f 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", @@ -13897,7 +13884,7 @@ DYNA_TRAN_EXPLI=OPER(nom="DYNA_TRAN_EXPLI",op= 70,sd_prod=evol_noli,reentrant='f 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'), @@ -13919,7 +13906,7 @@ DYNA_TRAN_EXPLI=OPER(nom="DYNA_TRAN_EXPLI",op= 70,sd_prod=evol_noli,reentrant='f 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", @@ -13942,7 +13929,7 @@ DYNA_TRAN_EXPLI=OPER(nom="DYNA_TRAN_EXPLI",op= 70,sd_prod=evol_noli,reentrant='f 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")), ), ), #------------------------------------------------------------------- @@ -14009,7 +13996,7 @@ into=("DEPL","VITE","ACCE","SIEF_ELGA","VARI_ELGA","DEPL_ABSOLU","VITE_ABSOLU"," 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 @@ -14082,12 +14069,12 @@ DYNA_TRAN_MODAL=OPER(nom="DYNA_TRAN_MODAL",op= 74,sd_prod=tran_gene, 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) ), @@ -14110,13 +14097,13 @@ DYNA_TRAN_MODAL=OPER(nom="DYNA_TRAN_MODAL",op= 74,sd_prod=tran_gene, 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' ), @@ -14151,7 +14138,7 @@ DYNA_TRAN_MODAL=OPER(nom="DYNA_TRAN_MODAL",op= 74,sd_prod=tran_gene, 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' ), @@ -14248,7 +14235,7 @@ ENGENDRE_TEST=PROC(nom="ENGENDRE_TEST",op=178, 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 @@ -14266,14 +14253,37 @@ ENGENDRE_TEST=PROC(nom="ENGENDRE_TEST",op=178, # 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 # ====================================================================== @@ -14329,7 +14339,7 @@ EXTR_MODE=OPER(nom="EXTR_MODE",op= 168,sd_prod=extr_mode_prod, 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 @@ -14356,10 +14366,9 @@ def extr_resu_prod(RESULTAT,**args): 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") @@ -14371,7 +14380,7 @@ EXTR_RESU=OPER(nom="EXTR_RESU",op=176,sd_prod=extr_resu_prod,reentrant='f', 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é.", @@ -14625,7 +14634,7 @@ FORMULE=FORM(nom="FORMULE",op_init=form_pyth_ops,op=-5, 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 @@ -14644,11 +14653,11 @@ FORMULE=FORM(nom="FORMULE",op_init=form_pyth_ops,op=-5, # 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", @@ -15287,7 +15296,7 @@ IMPR_MISS_3D=PROC(nom="IMPR_MISS_3D",op= 162, 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 @@ -15305,35 +15314,59 @@ IMPR_MISS_3D=PROC(nom="IMPR_MISS_3D",op= 162, # 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 @@ -15386,7 +15419,7 @@ IMPR_RESU=PROC(nom="IMPR_RESU",op=39, ), 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)), ), @@ -15732,7 +15765,7 @@ INFO_EXEC_ASTER=OPER(nom="INFO_EXEC_ASTER",op=35,sd_prod=table_sdaster, 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 @@ -15803,7 +15836,7 @@ INFO_FONCTION=MACRO(nom="INFO_FONCTION",op=info_fonction_ops,sd_prod=info_foncti ), ), 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), @@ -16097,7 +16130,7 @@ LIRE_FORC_MISS=OPER(nom="LIRE_FORC_MISS",op= 179,sd_prod=vect_asse_gene, 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 @@ -16123,9 +16156,10 @@ LIRE_IMPE_MISS=OPER(nom="LIRE_IMPE_MISS",op= 164,sd_prod=matr_asse_gene_c, 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 @@ -16146,7 +16180,7 @@ LIRE_IMPE_MISS=OPER(nom="LIRE_IMPE_MISS",op= 164,sd_prod=matr_asse_gene_c, 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",)}, @@ -16162,7 +16196,7 @@ LIRE_INTE_SPEC=MACRO(nom="LIRE_INTE_SPEC",op=lire_inte_spec_ops,sd_prod=table_sd 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 @@ -16203,19 +16237,24 @@ LIRE_MAILLAGE=OPER(nom="LIRE_MAILLAGE",op= 1,sd_prod=maillage_sdaster, ), # 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) ), # @@ -16528,7 +16567,7 @@ MAC_MODES=OPER(nom="MAC_MODES",op= 141,sd_prod=table_sdaster, 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 @@ -16582,8 +16621,8 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada # # 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"), # @@ -16659,7 +16698,19 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada 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", @@ -16671,7 +16722,7 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada # ), # -# 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", @@ -16679,20 +16730,20 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada # 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", @@ -16706,6 +16757,18 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada ), # ), +# +# 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" ), +# + ), # ) , # @@ -16752,7 +16815,6 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada ) , # # 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", @@ -16763,8 +16825,12 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada # 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 # @@ -16894,7 +16960,13 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada # ), # -# 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", @@ -16902,20 +16974,20 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada # 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", @@ -16974,7 +17046,7 @@ MACR_ADAP_MAIL=MACRO(nom="MACR_ADAP_MAIL",op=macr_adap_mail_ops,sd_prod=macr_ada 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 @@ -17136,9 +17208,43 @@ MACR_ASCOUF_CALC=MACRO(nom="MACR_ASCOUF_CALC",op=macr_ascouf_calc_ops,sd_prod=ma 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='**', @@ -17333,7 +17439,7 @@ MACR_ASCOUF_MAIL=MACRO(nom="MACR_ASCOUF_MAIL",op=macr_ascouf_mail_ops,sd_prod=ma 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 @@ -17521,9 +17627,43 @@ MACR_ASPIC_CALC=MACRO(nom="MACR_ASPIC_CALC",op=macr_aspic_calc_ops,sd_prod=macr_ 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), @@ -17653,7 +17793,7 @@ MACR_ASPIC_MAIL=MACRO(nom="MACR_ASPIC_MAIL",op= macr_aspic_mail_ops,sd_prod=mail 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 @@ -17777,9 +17917,43 @@ MACR_CABRI_CALC=MACRO(nom="MACR_CABRI_CALC", 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',), @@ -18053,7 +18227,7 @@ MACR_ELEM_DYNA=OPER(nom="MACR_ELEM_DYNA",op= 81,sd_prod=macr_elem_dyna, 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 @@ -18077,6 +18251,7 @@ MACR_ELEM_STAT=OPER(nom="MACR_ELEM_STAT",op=86,sd_prod=macr_elem_stat,reentrant= 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), @@ -18084,6 +18259,8 @@ MACR_ELEM_STAT=OPER(nom="MACR_ELEM_STAT",op=86,sd_prod=macr_elem_stat,reentrant= 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'),), @@ -18100,78 +18277,9 @@ MACR_ELEM_STAT=OPER(nom="MACR_ELEM_STAT",op=86,sd_prod=macr_elem_stat,reentrant= 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 @@ -18502,7 +18610,7 @@ MACR_FIABILITE = MACRO ( nom="MACR_FIABILITE",op=macr_fiabilite_ops, 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."), # @@ -18550,7 +18658,77 @@ MACR_FIABILITE = MACRO ( nom="MACR_FIABILITE",op=macr_fiabilite_ops, ), # ); -#& 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 @@ -18583,8 +18761,8 @@ MACR_INFO_MAIL=MACRO(nom="MACR_INFO_MAIL",op=macr_adap_mail_ops, # # 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"), # @@ -18644,7 +18822,7 @@ MACR_INFO_MAIL=MACRO(nom="MACR_INFO_MAIL",op=macr_adap_mail_ops, # # 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." ), # @@ -18708,51 +18886,7 @@ MACR_LIGN_COUPE=MACRO(nom="MACR_LIGN_COUPE",op=macr_lign_coupe_ops,sd_prod=table ) ; -#& 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 @@ -18943,7 +19077,7 @@ MACRO_MATR_AJOU=MACRO(nom="MACRO_MATR_AJOU",op=macro_matr_ajou_ops,sd_prod=macro 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 @@ -18998,6 +19132,7 @@ MACRO_MATR_ASSE=MACRO(nom="MACRO_MATR_ASSE",op=macro_matr_asse_ops, 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", @@ -19040,7 +19175,7 @@ MACRO_MATR_ASSE=MACRO(nom="MACRO_MATR_ASSE",op=macro_matr_asse_ops, 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 @@ -19091,6 +19226,7 @@ MACRO_MISS_3D=MACRO(nom="MACRO_MISS_3D",op=macro_miss_3d_ops, 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'), @@ -19249,6 +19385,140 @@ MACRO_PROJ_BASE=MACRO(nom="MACRO_PROJ_BASE",op=macro_proj_base_ops, ), 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 # ====================================================================== @@ -19274,7 +19544,7 @@ MAJ_CATA=PROC(nom="MAJ_CATA",op=20, 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 @@ -19365,11 +19635,13 @@ MECA_STATIQUE=OPER(nom="MECA_STATIQUE",op=46,sd_prod=evol_elas, 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) ), ) ; @@ -19831,7 +20103,7 @@ MODI_BASE_MODALE=OPER(nom="MODI_BASE_MODALE",op= 149,sd_prod=mode_meca, 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 @@ -19931,9 +20203,6 @@ MODI_MAILLAGE=OPER(nom="MODI_MAILLAGE",op= 154,sd_prod=maillage_sdaster, 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' ), @@ -19978,7 +20247,7 @@ MODI_MAILLAGE=OPER(nom="MODI_MAILLAGE",op= 154,sd_prod=maillage_sdaster, ), 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 @@ -20003,11 +20272,11 @@ MODI_MODELE_XFEM=OPER(nom="MODI_MODELE_XFEM",op= 113,sd_prod=modele_sdaster,docu 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 @@ -20025,20 +20294,21 @@ MODI_MODELE_XFEM=OPER(nom="MODI_MODELE_XFEM",op= 113,sd_prod=modele_sdaster,docu # 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 @@ -20124,7 +20394,7 @@ MODI_REPERE=OPER(nom="MODI_REPERE",op=191,sd_prod=modi_repere_prod,reentrant='n' 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 @@ -20146,6 +20416,7 @@ def norm_mode_prod(MODE,**args ): 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, @@ -20155,7 +20426,7 @@ 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"), @@ -20175,10 +20446,15 @@ NORM_MODE=OPER(nom="NORM_MODE",op= 37,sd_prod=norm_mode_prod, 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 @@ -20214,8 +20490,8 @@ NUME_DDL=OPER(nom="NUME_DDL",op=11,sd_prod=nume_ddl_sdaster,reentrant='n', 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" ), @@ -20282,7 +20558,7 @@ POST_CHAM_XFEM=OPER(nom="POST_CHAM_XFEM",op= 196,sd_prod=resultat_sdaster, 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 @@ -20300,12 +20576,14 @@ POST_CHAM_XFEM=OPER(nom="POST_CHAM_XFEM",op= 196,sd_prod=resultat_sdaster, # 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='**' ), @@ -20319,36 +20597,6 @@ POST_DYNA_ALEA=OPER(nom="POST_DYNA_ALEA",op= 132,sd_prod=table_sdaster, 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) ), @@ -20395,7 +20643,7 @@ POST_DYNA_MODA_T=OPER(nom="POST_DYNA_MODA_T",op= 130,sd_prod=table_sdaster, 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 @@ -20916,6 +21164,94 @@ POST_FATIGUE=OPER(nom="POST_FATIGUE",op=136,sd_prod=table_sdaster,reentrant='n', 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 # ====================================================================== @@ -21028,6 +21364,69 @@ POST_K_BETA=OPER(nom="POST_K_BETA",op=198,sd_prod=table_sdaster, ), 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 # ====================================================================== @@ -21052,7 +21451,7 @@ POST_MAIL_XFEM=OPER(nom="POST_MAIL_XFEM",op= 187,sd_prod=maillage_sdaster, 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 @@ -21085,6 +21484,8 @@ POST_RCCM=OPER(nom="POST_RCCM",op= 165,sd_prod=table_sdaster, 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'),), @@ -21094,6 +21495,8 @@ POST_RCCM=OPER(nom="POST_RCCM",op= 165,sd_prod=table_sdaster, 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 ), @@ -21110,6 +21513,8 @@ POST_RCCM=OPER(nom="POST_RCCM",op= 165,sd_prod=table_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", @@ -21298,7 +21703,7 @@ POST_RCCM=OPER(nom="POST_RCCM",op= 165,sd_prod=table_sdaster, ), ), ) ; -#& 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 @@ -21320,7 +21725,7 @@ POST_RCCM=OPER(nom="POST_RCCM",op= 165,sd_prod=table_sdaster, 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'),), @@ -21332,9 +21737,17 @@ POST_RELEVE_T=OPER(nom="POST_RELEVE_T",op=51,sd_prod=table_sdaster,reentrant='f' 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(), @@ -21342,6 +21755,27 @@ POST_RELEVE_T=OPER(nom="POST_RELEVE_T",op=51,sd_prod=table_sdaster,reentrant='f' 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", @@ -21589,23 +22023,23 @@ POST_ZAC=OPER(nom="POST_ZAC",op= 175,sd_prod=mult_elas,reentrant='n', 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", @@ -21613,7 +22047,7 @@ POURSUITE=MACRO(nom="POURSUITE",op=ops.build_poursuite,repetable='n', 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", @@ -21643,6 +22077,8 @@ POURSUITE=MACRO(nom="POURSUITE",op=ops.build_poursuite,repetable='n', 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", @@ -21769,7 +22205,7 @@ PROD_MATR_CHAM=OPER(nom="PROD_MATR_CHAM",op= 156,sd_prod=cham_no_sdaster, 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 @@ -21794,6 +22230,7 @@ def proj_champ_prod(RESULTAT=None,CHAM_NO_REFE=None,**args ): 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 @@ -21818,7 +22255,7 @@ PROJ_CHAMP=OPER(nom="PROJ_CHAMP",op= 166,sd_prod=proj_champ_prod,reentrant='f', 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é.", @@ -21826,6 +22263,7 @@ PROJ_CHAMP=OPER(nom="PROJ_CHAMP",op= 166,sd_prod=proj_champ_prod,reentrant='f', 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='**'), @@ -21844,9 +22282,14 @@ PROJ_CHAMP=OPER(nom="PROJ_CHAMP",op= 166,sd_prod=proj_champ_prod,reentrant='f', 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",), @@ -21872,6 +22315,9 @@ PROJ_CHAMP=OPER(nom="PROJ_CHAMP",op= 166,sd_prod=proj_champ_prod,reentrant='f', 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='**' ), @@ -21913,7 +22359,7 @@ PROJ_MATR_BASE=OPER(nom="PROJ_MATR_BASE",op= 71,sd_prod=matr_asse_gene_prod, 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 @@ -21960,6 +22406,7 @@ PROJ_MESU_MODAL=OPER(nom="PROJ_MESU_MODAL",op= 193, 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'", @@ -21974,7 +22421,7 @@ PROJ_MESU_MODAL=OPER(nom="PROJ_MESU_MODAL",op= 193, ), ); -#& 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 @@ -21992,12 +22439,13 @@ PROJ_MESU_MODAL=OPER(nom="PROJ_MESU_MODAL",op= 193, # 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), @@ -22043,7 +22491,7 @@ PROJ_VECT_BASE=OPER(nom="PROJ_VECT_BASE",op= 72,sd_prod=vect_asse_gene, 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 @@ -22076,9 +22524,14 @@ PROPA_XFEM=OPER(nom="PROPA_XFEM",op=10,sd_prod=fiss_xfem,reentrant='n', 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 @@ -22126,7 +22579,7 @@ RECA_WEIBULL=OPER(nom="RECA_WEIBULL",op= 197,sd_prod=table_sdaster, 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 @@ -22145,38 +22598,29 @@ RECA_WEIBULL=OPER(nom="RECA_WEIBULL",op= 197,sd_prod=table_sdaster, # 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", @@ -22222,17 +22666,16 @@ RECU_FONCTION=OPER(nom="RECU_FONCTION",op=90,sd_prod=recu_fonction_prod, 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", @@ -22350,10 +22793,11 @@ RECU_FONCTION=OPER(nom="RECU_FONCTION",op=90,sd_prod=recu_fonction_prod, 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 ================================================= @@ -22488,7 +22932,7 @@ RESO_LDLT=OPER(nom="RESO_LDLT",op=15,sd_prod=cham_no_sdaster,reentrant='f', 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 @@ -22564,6 +23008,8 @@ REST_BASE_PHYS=OPER(nom="REST_BASE_PHYS",op= 75,sd_prod=rest_base_phys_prod, 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 ), @@ -22580,7 +23026,7 @@ REST_BASE_PHYS=OPER(nom="REST_BASE_PHYS",op= 75,sd_prod=rest_base_phys_prod, 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 @@ -22598,7 +23044,7 @@ REST_BASE_PHYS=OPER(nom="REST_BASE_PHYS",op= 75,sd_prod=rest_base_phys_prod, # 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",)}, @@ -22607,7 +23053,7 @@ REST_SPEC_PHYS=OPER(nom="REST_SPEC_PHYS",op= 148,sd_prod=table_sdaster, 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='**'), @@ -22624,6 +23070,118 @@ REST_SPEC_PHYS=OPER(nom="REST_SPEC_PHYS",op= 148,sd_prod=table_sdaster, 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 # ====================================================================== @@ -22658,7 +23216,7 @@ STANLEY=MACRO(nom="STANLEY",op=stanley_ops,sd_prod=None, 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 @@ -22772,9 +23330,43 @@ STAT_NON_LINE=OPER(nom="STAT_NON_LINE",op=70,sd_prod=evol_noli, 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',), @@ -22796,7 +23388,7 @@ STAT_NON_LINE=OPER(nom="STAT_NON_LINE",op=70,sd_prod=evol_noli, 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'),), @@ -22829,7 +23421,6 @@ STAT_NON_LINE=OPER(nom="STAT_NON_LINE",op=70,sd_prod=evol_noli, 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", @@ -22850,11 +23441,13 @@ STAT_NON_LINE=OPER(nom="STAT_NON_LINE",op=70,sd_prod=evol_noli, 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") ), @@ -22906,16 +23499,20 @@ STAT_NON_LINE=OPER(nom="STAT_NON_LINE",op=70,sd_prod=evol_noli, ), 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, @@ -22975,10 +23572,12 @@ STAT_NON_LINE=OPER(nom="STAT_NON_LINE",op=70,sd_prod=evol_noli, 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" ), @@ -23040,7 +23639,7 @@ TEST_FICHIER=MACRO(nom="TEST_FICHIER", op=test_fichier_ops, 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 @@ -23073,8 +23672,8 @@ TEST_FONCTION=PROC(nom="TEST_FONCTION",op= 135, 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") ), @@ -23105,7 +23704,7 @@ TEST_FONCTION=PROC(nom="TEST_FONCTION",op= 135, 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", @@ -23118,7 +23717,7 @@ TEST_FONCTION=PROC(nom="TEST_FONCTION",op= 135, ), 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", @@ -23130,7 +23729,7 @@ TEST_FONCTION=PROC(nom="TEST_FONCTION",op= 135, ), ), ) ; -#& 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 # ====================================================================== @@ -23167,9 +23766,9 @@ TEST_RESU=PROC(nom="TEST_RESU",op=23, 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), @@ -23193,9 +23792,9 @@ TEST_RESU=PROC(nom="TEST_RESU",op=23, 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 ), @@ -23235,9 +23834,9 @@ TEST_RESU=PROC(nom="TEST_RESU",op=23, 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), @@ -23270,9 +23869,9 @@ TEST_RESU=PROC(nom="TEST_RESU",op=23, 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), @@ -23299,7 +23898,7 @@ TEST_RESU=PROC(nom="TEST_RESU",op=23, 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 @@ -23336,9 +23935,9 @@ TEST_TABLE=PROC(nom="TEST_TABLE",op= 177, "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") ), @@ -23346,9 +23945,9 @@ TEST_TABLE=PROC(nom="TEST_TABLE",op= 177, ), 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 ), @@ -23359,7 +23958,7 @@ TEST_TABLE=PROC(nom="TEST_TABLE",op= 177, 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 @@ -23431,11 +24030,13 @@ THER_LINEAIRE=OPER(nom="THER_LINEAIRE",op=25,sd_prod=evol_ther,reentrant='f', 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', @@ -23452,7 +24053,7 @@ THER_LINEAIRE=OPER(nom="THER_LINEAIRE",op=25,sd_prod=evol_ther,reentrant='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 @@ -23544,11 +24145,13 @@ THER_NON_LINE=OPER(nom="THER_NON_LINE",op= 186,sd_prod=evol_ther,reentrant='f', 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 ), diff --git a/Aster/Cata/cataSTA8/ops.py b/Aster/Cata/cataSTA8/ops.py index 088e9561..6e6ab0f7 100644 --- a/Aster/Cata/cataSTA8/ops.py +++ b/Aster/Cata/cataSTA8/ops.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -121,6 +121,7 @@ def POURSUITE(self,PAR_LOT,IMPR_MACRO,CODE,DEBUG,**args): 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) @@ -144,6 +145,10 @@ def POURSUITE(self,PAR_LOT,IMPR_MACRO,CODE,DEBUG,**args): 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 : @@ -403,7 +408,6 @@ def INCLUDE_MATERIAU(self,NOM_AFNOR,TYPE_MODELE,VARIANTE,TYPE_VALE,NOM_MATER, # 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' diff --git a/Aster/Cata/ops.py b/Aster/Cata/ops.py deleted file mode 100644 index 088e9561..00000000 --- a/Aster/Cata/ops.py +++ /dev/null @@ -1,448 +0,0 @@ -#@ 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 diff --git a/Aster/NEWS b/Aster/NEWS index 1c80a9f9..60749235 100644 --- a/Aster/NEWS +++ b/Aster/NEWS @@ -1,3 +1,7 @@ +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. diff --git a/Aster/alphasdist.py b/Aster/alphasdist.py index af05afb8..719747e7 100644 --- a/Aster/alphasdist.py +++ b/Aster/alphasdist.py @@ -38,6 +38,7 @@ def main(): 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']) diff --git a/Aster/editeur.ini b/Aster/editeur.ini index 09c41684..bd1b7297 100644 --- a/Aster/editeur.ini +++ b/Aster/editeur.ini @@ -42,7 +42,8 @@ rep_mat=os.path.join(rep_cata,'..','materiau') 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'), ) diff --git a/Aster/prefs.py b/Aster/prefs.py index 28a5c8ed..13b16d0d 100644 --- a/Aster/prefs.py +++ b/Aster/prefs.py @@ -50,9 +50,9 @@ lang='fr' encoding='iso-8859-1' labels= ('Fichier','Edition','Jeu de commandes', -# 'Catalogue','Browsers', 'Options', 'Aide', + 'Traduction', ) appli_composants=['readercata','bureau', @@ -84,6 +84,10 @@ menu_defs={ 'bureau': [ #('Paramètres Eficas','affichage_fichier_ini'), ] ), + ('Traduction',[ + ('Traduction v7 en v8','TraduitFichier','','Ctrl+T'), + ] + ), ('Aide',[ ('Aide EFICAS','aideEFICAS','','Ctrl+A'), ] diff --git a/Aster/sdist.py b/Aster/sdist.py index c4786355..d4563e63 100644 --- a/Aster/sdist.py +++ b/Aster/sdist.py @@ -37,6 +37,7 @@ def main(): 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']) @@ -50,6 +51,7 @@ def main(): 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']) @@ -74,7 +76,7 @@ def main(): 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") @@ -83,7 +85,7 @@ def main(): 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) diff --git a/Editeur/appli.py b/Editeur/appli.py index c6e348f2..1b6f17a7 100644 --- a/Editeur/appli.py +++ b/Editeur/appli.py @@ -51,7 +51,7 @@ import session 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) : @@ -61,6 +61,7 @@ class APPLI: 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) @@ -318,6 +319,7 @@ class STANDALONE(APPLI): 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) diff --git a/Editeur/bureau.py b/Editeur/bureau.py index 4d5dfedf..cc3fc933 100644 --- a/Editeur/bureau.py +++ b/Editeur/bureau.py @@ -34,11 +34,13 @@ import prefs 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 @@ -69,6 +71,10 @@ class BUREAU: ('Mots-clés inconnus','mc_inconnus'), ] ), + ('Traduction',[ + ('Traduction v7 en v8','TraduitFichier','','Ctrl+T') + ] + ), ('Aide',[ ('Aide EFICAS','aideEFICAS'), ] @@ -293,6 +299,7 @@ class BUREAU: """ 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() @@ -724,3 +731,35 @@ class BUREAU: 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) + diff --git a/Editeur/compomacro.py b/Editeur/compomacro.py index 543391d6..ba423070 100644 --- a/Editeur/compomacro.py +++ b/Editeur/compomacro.py @@ -37,7 +37,7 @@ from widgets import showinfo,showerror # __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): @@ -206,9 +206,17 @@ class INCLUDETreeItemBase(MACROTreeItem): #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, @@ -216,8 +224,10 @@ class INCLUDETreeItemBase(MACROTreeItem): 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: @@ -242,11 +252,19 @@ class INCLUDETreeItem(INCLUDETreeItemBase): 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, diff --git a/Editeur/composimp.py b/Editeur/composimp.py index ea4b9909..4a456b91 100644 --- a/Editeur/composimp.py +++ b/Editeur/composimp.py @@ -123,8 +123,9 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem): 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): @@ -308,16 +309,9 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem): 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 @@ -354,7 +348,7 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem): 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() diff --git a/Editeur/macrodisplay.py b/Editeur/macrodisplay.py index 7d769e9f..464d59a8 100644 --- a/Editeur/macrodisplay.py +++ b/Editeur/macrodisplay.py @@ -49,7 +49,7 @@ class MacroDisplay: 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') diff --git a/Editeur/menubar.py b/Editeur/menubar.py index 0ba21ec3..b1aea087 100644 --- a/Editeur/menubar.py +++ b/Editeur/menubar.py @@ -35,7 +35,7 @@ class MENUBAR: 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={} diff --git a/Editeur/panelsSalome.py b/Editeur/panelsSalome.py index 6e18abeb..6381ba7e 100644 --- a/Editeur/panelsSalome.py +++ b/Editeur/panelsSalome.py @@ -94,30 +94,29 @@ class SALOME_PLUSIEURS_BASE_Panel(PLUSIEURS_BASE_Panel): 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 ) @@ -191,9 +190,10 @@ class SALOME_UNIQUE_BASE_Panel(UNIQUE_BASE_Panel): 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() @@ -215,113 +215,56 @@ class SALOME_UNIQUE_BASE_Panel(UNIQUE_BASE_Panel): 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("",lambda e,s=self,a=bulle_aide : s.parent.appli.affiche_aide(e,a)) - self.frame_valeur.bind("",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("",lambda e,c=self.valid_valeur:c()) - self.entry.bind("",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 diff --git a/Editeur/plusieursbasepanel.py b/Editeur/plusieursbasepanel.py index 7483cfbd..f1d65a9e 100644 --- a/Editeur/plusieursbasepanel.py +++ b/Editeur/plusieursbasepanel.py @@ -59,11 +59,7 @@ class PLUSIEURS_BASE_Panel(PLUSIEURS_Panel): 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() @@ -91,7 +87,6 @@ class PLUSIEURS_BASE_Panel(PLUSIEURS_Panel): 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): @@ -288,7 +283,8 @@ class PLUSIEURS_BASE_Panel(PLUSIEURS_Panel): 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 diff --git a/Editeur/plusieursintopanel.py b/Editeur/plusieursintopanel.py index ef2003e1..1854e865 100644 --- a/Editeur/plusieursintopanel.py +++ b/Editeur/plusieursintopanel.py @@ -108,6 +108,7 @@ class PLUSIEURS_INTO_Panel(PLUSIEURS_Panel): 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("",lambda e,s=self,a=bulle_aide : s.parent.appli.affiche_aide(e,a)) diff --git a/Editeur/plusieurspanel.py b/Editeur/plusieurspanel.py index 72161e0f..2b59b339 100644 --- a/Editeur/plusieurspanel.py +++ b/Editeur/plusieurspanel.py @@ -108,9 +108,9 @@ class PLUSIEURS_Panel(newSIMPPanel): 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) : diff --git a/Editeur/readercata.py b/Editeur/readercata.py index a68dff62..39a58ae0 100644 --- a/Editeur/readercata.py +++ b/Editeur/readercata.py @@ -174,6 +174,11 @@ class READERCATA: 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): """ diff --git a/Editeur/uniquebasepanel.py b/Editeur/uniquebasepanel.py index 4c6f89e9..74e3d87b 100644 --- a/Editeur/uniquebasepanel.py +++ b/Editeur/uniquebasepanel.py @@ -74,13 +74,18 @@ class UNIQUE_BASE_Panel(UNIQUE_Panel): 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="" diff --git a/Editeur/uniqueintopanel.py b/Editeur/uniqueintopanel.py index da05fdce..6532e3fa 100644 --- a/Editeur/uniqueintopanel.py +++ b/Editeur/uniqueintopanel.py @@ -66,6 +66,8 @@ class UNIQUE_INTO_Panel(UNIQUE_Panel): 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 = (("",self.selectChoix), ("",self.deselectChoix), ("",self.record_valeur)) @@ -73,6 +75,15 @@ class UNIQUE_INTO_Panel(UNIQUE_Panel): 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): """ diff --git a/Editeur/uniquepanel.py b/Editeur/uniquepanel.py index 777fa77b..a622b8a6 100644 --- a/Editeur/uniquepanel.py +++ b/Editeur/uniquepanel.py @@ -87,7 +87,7 @@ class UNIQUE_Panel(newSIMPPanel): 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() diff --git a/Editeur/widgets.py b/Editeur/widgets.py index 9fba89dc..ad8c3b66 100644 --- a/Editeur/widgets.py +++ b/Editeur/widgets.py @@ -55,11 +55,12 @@ def askyesno(title=None, message=None, **options): 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') @@ -68,10 +69,11 @@ class Fenetre : # 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("", self.page_up) self.zone_texte.bind("", self.page_down) self.zone_texte.bind("", self.unit_up) @@ -83,10 +85,18 @@ class Fenetre : 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('',self.quit) #dismiss window + # affichage du texte self.affiche_texte(self.texte) self.zone_texte.config(state=DISABLED) @@ -95,20 +105,25 @@ class Fenetre : 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""" @@ -147,6 +162,27 @@ class Fenetre : 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 @@ -305,7 +341,7 @@ class FenetreDeSelection(Fenetre): 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 @@ -394,16 +430,14 @@ class FenetreDeSelection(Fenetre): 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): diff --git a/Extensions/jdc_include.py b/Extensions/jdc_include.py index 8a74ee42..580be8eb 100644 --- a/Extensions/jdc_include.py +++ b/Extensions/jdc_include.py @@ -27,6 +27,7 @@ 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 @@ -53,6 +54,9 @@ class JDC_POURSUITE(JDC): 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 @@ -64,6 +68,28 @@ class JDC_POURSUITE(JDC): #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) diff --git a/Ihm/I_MACRO_ETAPE.py b/Ihm/I_MACRO_ETAPE.py index 258f44ca..0ab72b58 100644 --- a/Ihm/I_MACRO_ETAPE.py +++ b/Ihm/I_MACRO_ETAPE.py @@ -26,9 +26,13 @@ import traceback,types,string # 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 @@ -41,6 +45,10 @@ class MACRO_ETAPE(I_ETAPE.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): @@ -99,13 +107,22 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): # 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, @@ -132,6 +149,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): # 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)) @@ -140,6 +158,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): # 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) @@ -157,6 +176,9 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): 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 @@ -168,6 +190,20 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): 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 @@ -788,7 +824,7 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): """ 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 @@ -807,14 +843,22 @@ class MACRO_ETAPE(I_ETAPE.ETAPE): 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={} diff --git a/Ihm/I_MCSIMP.py b/Ihm/I_MCSIMP.py index b2363984..694bc83a 100644 --- a/Ihm/I_MCSIMP.py +++ b/Ihm/I_MCSIMP.py @@ -539,6 +539,7 @@ class MCSIMP(I_OBJECT.OBJECT): if self.definition.validators: valid=self.definition.validators.verif_item(item) except ValError,e: + #traceback.print_exc() valid=0 return valid @@ -547,10 +548,18 @@ class MCSIMP(I_OBJECT.OBJECT): 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 #-------------------------------------------------------------------------------- diff --git a/Noyau/N_ETAPE.py b/Noyau/N_ETAPE.py index dde08f5b..2e96ccfc 100644 --- a/Noyau/N_ETAPE.py +++ b/Noyau/N_ETAPE.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -37,6 +37,7 @@ import N_MCCOMPO from N_Exception import AsException import N_utils from N_utils import AsType +from N_ASSD import ASSD class ETAPE(N_MCCOMPO.MCCOMPO): """ @@ -190,6 +191,14 @@ 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): diff --git a/Noyau/N_MACRO_ETAPE.py b/Noyau/N_MACRO_ETAPE.py index 43ff1d7d..7b3f3454 100644 --- a/Noyau/N_MACRO_ETAPE.py +++ b/Noyau/N_MACRO_ETAPE.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -37,6 +37,7 @@ from N_Exception import AsException import N_utils from N_utils import AsType from N_CO import CO +from N_ASSD import ASSD class MACRO_ETAPE(N_ETAPE.ETAPE): """ @@ -209,6 +210,14 @@ 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): diff --git a/Noyau/N_MCLIST.py b/Noyau/N_MCLIST.py index 6c7ab567..cbf60d43 100644 --- a/Noyau/N_MCLIST.py +++ b/Noyau/N_MCLIST.py @@ -1,4 +1,4 @@ -#@ 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 # ====================================================================== @@ -205,3 +205,17 @@ class MCList(UserList.UserList): 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 diff --git a/Noyau/N_SENSIBILITE.py b/Noyau/N_SENSIBILITE.py index 29ffc1de..3501df17 100644 --- a/Noyau/N_SENSIBILITE.py +++ b/Noyau/N_SENSIBILITE.py @@ -161,6 +161,9 @@ class DERIVABLE(REGLE): 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'): diff --git a/Tests/config.py b/Tests/config.py index b6711092..b6edf378 100644 --- a/Tests/config.py +++ b/Tests/config.py @@ -1,8 +1,5 @@ - 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" diff --git a/Tests/editeur.ini b/Tests/editeur.ini new file mode 100644 index 00000000..4f495120 --- /dev/null +++ b/Tests/editeur.ini @@ -0,0 +1,53 @@ +# 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'), + ) + diff --git a/Tests/eficas_aster.py b/Tests/eficas_aster.py new file mode 100755 index 00000000..1d298b58 --- /dev/null +++ b/Tests/eficas_aster.py @@ -0,0 +1,32 @@ +#!/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() diff --git a/Tests/prefs.py b/Tests/prefs.py index e69de29b..28a5c8ed 100644 --- a/Tests/prefs.py +++ b/Tests/prefs.py @@ -0,0 +1,104 @@ +# -*- 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','','Ctrl+N'), + ('Nouvel INCLUDE','newJDC_include'), + ('Ouvrir','openJDC','','Ctrl+O'), + ('Enregistrer','saveJDC','','Ctrl+S'), + ('Enregistrer sous','saveasJDC','','Ctrl+E'), + None, + ('Fermer','closeJDC','','Ctrl+W'), + ('Quitter','exitEFICAS','','Ctrl+Q'), + ] + ), + ('Edition',[ + ('Copier','copy','','Ctrl+C'), + ('Couper','cut','','Ctrl+X'), + ('Coller','paste','','Ctrl+V'), + ] + ), + ('Jeu de commandes',[ + ('Rapport de validation','visuCRJDC','','Ctrl+R'), + ('Fichier source','visu_txt_brut_JDC','','Ctrl+B'), + #('Paramètres Eficas','affichage_fichier_ini'), + ] + ), + ('Aide',[ + ('Aide EFICAS','aideEFICAS','','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] diff --git a/Tests/properties.py b/Tests/properties.py new file mode 100644 index 00000000..c174e28e --- /dev/null +++ b/Tests/properties.py @@ -0,0 +1,25 @@ +#@ 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 diff --git a/Tests/style.py b/Tests/style.py new file mode 100644 index 00000000..0d387727 --- /dev/null +++ b/Tests/style.py @@ -0,0 +1,63 @@ +# -*- 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) diff --git a/Tests/testastest/basetest.py b/Tests/testastest/basetest.py new file mode 100644 index 00000000..a8f2a068 --- /dev/null +++ b/Tests/testastest/basetest.py @@ -0,0 +1,67 @@ +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 diff --git a/Tests/testastest/erreu01a.err b/Tests/testastest/erreu01a.err new file mode 100644 index 00000000..7bdc2e9b --- /dev/null +++ b/Tests/testastest/erreu01a.err @@ -0,0 +1,4 @@ +Compilation impossible : File "erreu01a.comm", line 44 + UELAS=MECA_STATIQUE(MODELE=MOD, + ^ + SyntaxError: invalid syntax diff --git a/Tests/testastest/testaster1.py b/Tests/testastest/testaster1.py new file mode 100644 index 00000000..7aa1d9ed --- /dev/null +++ b/Tests/testastest/testaster1.py @@ -0,0 +1,5 @@ +import basetest + +files="[a-l]*.comm" +TestCase=basetest.make_tests(files) +class TestCase(TestCase):pass diff --git a/Tests/testastest/testaster10.py b/Tests/testastest/testaster10.py new file mode 100644 index 00000000..febe8cab --- /dev/null +++ b/Tests/testastest/testaster10.py @@ -0,0 +1,5 @@ +import basetest + +files="z*.comm" +TestCase=basetest.make_tests(files) +class TestCase(TestCase):pass diff --git a/Tests/testastest/testaster2.py b/Tests/testastest/testaster2.py new file mode 100644 index 00000000..72c6892f --- /dev/null +++ b/Tests/testastest/testaster2.py @@ -0,0 +1,6 @@ +import basetest + +files="[m-r]*.comm" +TestCase=basetest.make_tests(files) +class TestCase(TestCase):pass + diff --git a/Tests/testastest/testaster3.py b/Tests/testastest/testaster3.py new file mode 100644 index 00000000..230a79c1 --- /dev/null +++ b/Tests/testastest/testaster3.py @@ -0,0 +1,5 @@ +import basetest + +files="s[a-d]*.comm" +TestCase=basetest.make_tests(files) +class TestCase(TestCase):pass diff --git a/Tests/testastest/testaster4.py b/Tests/testastest/testaster4.py new file mode 100644 index 00000000..c3217c72 --- /dev/null +++ b/Tests/testastest/testaster4.py @@ -0,0 +1,5 @@ +import basetest + +files="s[e-r]*.comm" +TestCase=basetest.make_tests(files) +class TestCase(TestCase):pass diff --git a/Tests/testastest/testaster5.py b/Tests/testastest/testaster5.py new file mode 100644 index 00000000..26851b9b --- /dev/null +++ b/Tests/testastest/testaster5.py @@ -0,0 +1,5 @@ +import basetest + +files="ssl[a-l]*.comm" +TestCase=basetest.make_tests(files) +class TestCase(TestCase):pass diff --git a/Tests/testastest/testaster6.py b/Tests/testastest/testaster6.py new file mode 100644 index 00000000..c779a122 --- /dev/null +++ b/Tests/testastest/testaster6.py @@ -0,0 +1,5 @@ +import basetest + +files="ssl[m-z]*.comm" +TestCase=basetest.make_tests(files) +class TestCase(TestCase):pass diff --git a/Tests/testastest/testaster7.py b/Tests/testastest/testaster7.py new file mode 100644 index 00000000..99f426c1 --- /dev/null +++ b/Tests/testastest/testaster7.py @@ -0,0 +1,6 @@ +import basetest + +files="ss[m-z]*.comm" +TestCase=basetest.make_tests(files) +class TestCase(TestCase):pass + diff --git a/Tests/testastest/testaster8.py b/Tests/testastest/testaster8.py new file mode 100644 index 00000000..04f45616 --- /dev/null +++ b/Tests/testastest/testaster8.py @@ -0,0 +1,5 @@ +import basetest + +files="s[t-z]*.comm" +TestCase=basetest.make_tests(files) +class TestCase(TestCase):pass diff --git a/Tests/testastest/testaster9.py b/Tests/testastest/testaster9.py new file mode 100644 index 00000000..4c561729 --- /dev/null +++ b/Tests/testastest/testaster9.py @@ -0,0 +1,5 @@ +import basetest + +files="[t-y]*.comm" +TestCase=basetest.make_tests(files) +class TestCase(TestCase):pass diff --git a/Tests/testcomm/hplp101b.comm b/Tests/testcomm/hplp101b.comm new file mode 100755 index 00000000..ef2790a1 --- /dev/null +++ b/Tests/testcomm/hplp101b.comm @@ -0,0 +1,189 @@ +# 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() + diff --git a/Tests/testcomm/hsnv100h.comm b/Tests/testcomm/hsnv100h.comm new file mode 100755 index 00000000..976dc604 --- /dev/null +++ b/Tests/testcomm/hsnv100h.comm @@ -0,0 +1,46 @@ +# 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() diff --git a/Tests/testcomm/param1.err b/Tests/testcomm/param1.err deleted file mode 100644 index 758a38b6..00000000 --- a/Tests/testcomm/param1.err +++ /dev/null @@ -1 +0,0 @@ -erreur sur defi_materiau diff --git a/Tests/testcomm/param2.com0 b/Tests/testcomm/param2.com0 new file mode 100644 index 00000000..2d32a387 --- /dev/null +++ b/Tests/testcomm/param2.com0 @@ -0,0 +1,4 @@ +POURSUITE(); +l1=DEFI_LIST_ENTI(DEBUT=mon_param,); +FIN(); + diff --git a/Tests/testcomm/param2.comm b/Tests/testcomm/param2.comm new file mode 100644 index 00000000..19c8eeb2 --- /dev/null +++ b/Tests/testcomm/param2.comm @@ -0,0 +1,4 @@ +DEBUT(); +mon_param = 2; +m=LIRE_MAILLAGE() +FIN(); diff --git a/Tests/testcomm/param3.11 b/Tests/testcomm/param3.11 new file mode 100644 index 00000000..236ca5ca --- /dev/null +++ b/Tests/testcomm/param3.11 @@ -0,0 +1,2 @@ +x=45 +y=77 diff --git a/Tests/testcomm/param3.12 b/Tests/testcomm/param3.12 new file mode 100644 index 00000000..2c2a2157 --- /dev/null +++ b/Tests/testcomm/param3.12 @@ -0,0 +1 @@ +d=5;f=7 diff --git a/Tests/testcomm/param3.com0 b/Tests/testcomm/param3.com0 new file mode 100644 index 00000000..d5a0bbf5 --- /dev/null +++ b/Tests/testcomm/param3.com0 @@ -0,0 +1,11 @@ +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(); + diff --git a/Tests/testcomm/param3.comm b/Tests/testcomm/param3.comm new file mode 100644 index 00000000..b7a38ea2 --- /dev/null +++ b/Tests/testcomm/param3.comm @@ -0,0 +1,5 @@ +DEBUT(); +mon_param = 2; +m=LIRE_MAILLAGE() +a=[1,2,3,4];b=2 +FIN(); diff --git a/Tests/testcomm/parseur.comm b/Tests/testcomm/parseur.comm index 6f42e785..92aaf898 100644 --- a/Tests/testcomm/parseur.comm +++ b/Tests/testcomm/parseur.comm @@ -69,6 +69,6 @@ FL_INT05 = FORMULE(NOM_PARA='TEMP',VALE=''' zz=8.9; #ne marche pas avec le parseur actuel -zz=8.9;aa=10 #position +#zz=8.9;aa=10 #position FIN() diff --git a/Tests/testcomm/testaster1.py b/Tests/testcomm/testaster1.py deleted file mode 100644 index 00b63ddb..00000000 --- a/Tests/testcomm/testaster1.py +++ /dev/null @@ -1,40 +0,0 @@ -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) diff --git a/Tests/testcomm/testaster10.py b/Tests/testcomm/testaster10.py deleted file mode 100644 index 8e7a4053..00000000 --- a/Tests/testcomm/testaster10.py +++ /dev/null @@ -1,40 +0,0 @@ -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) - diff --git a/Tests/testcomm/testaster2.py b/Tests/testcomm/testaster2.py deleted file mode 100644 index b9bcb3a5..00000000 --- a/Tests/testcomm/testaster2.py +++ /dev/null @@ -1,40 +0,0 @@ -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) - diff --git a/Tests/testcomm/testaster3.py b/Tests/testcomm/testaster3.py deleted file mode 100644 index fc412fc4..00000000 --- a/Tests/testcomm/testaster3.py +++ /dev/null @@ -1,40 +0,0 @@ -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) - diff --git a/Tests/testcomm/testaster4.py b/Tests/testcomm/testaster4.py deleted file mode 100644 index 9994411b..00000000 --- a/Tests/testcomm/testaster4.py +++ /dev/null @@ -1,40 +0,0 @@ -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) - diff --git a/Tests/testcomm/testaster5.py b/Tests/testcomm/testaster5.py deleted file mode 100644 index 0b65fb3e..00000000 --- a/Tests/testcomm/testaster5.py +++ /dev/null @@ -1,44 +0,0 @@ -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) - diff --git a/Tests/testcomm/testaster6.py b/Tests/testcomm/testaster6.py deleted file mode 100644 index cfa59a34..00000000 --- a/Tests/testcomm/testaster6.py +++ /dev/null @@ -1,40 +0,0 @@ -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) - diff --git a/Tests/testcomm/testaster7.py b/Tests/testcomm/testaster7.py deleted file mode 100644 index df4fab18..00000000 --- a/Tests/testcomm/testaster7.py +++ /dev/null @@ -1,44 +0,0 @@ -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) - diff --git a/Tests/testcomm/testaster8.py b/Tests/testcomm/testaster8.py deleted file mode 100644 index 8111717b..00000000 --- a/Tests/testcomm/testaster8.py +++ /dev/null @@ -1,40 +0,0 @@ -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) - diff --git a/Tests/testcomm/testaster9.py b/Tests/testcomm/testaster9.py deleted file mode 100644 index 890a42a1..00000000 --- a/Tests/testcomm/testaster9.py +++ /dev/null @@ -1,40 +0,0 @@ -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) - diff --git a/Tests/testcomm/testcomm.py b/Tests/testcomm/testcomm.py index 4d540b15..f0c97101 100644 --- a/Tests/testcomm/testcomm.py +++ b/Tests/testcomm/testcomm.py @@ -26,14 +26,15 @@ class TestCase(unittest.TestCase): 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 diff --git a/Tests/testelem/az.comm b/Tests/testelem/az.comm index 9e784232..b7f540d5 100644 --- a/Tests/testelem/az.comm +++ b/Tests/testelem/az.comm @@ -58,13 +58,11 @@ CARA=AFFE_CARA_ELEM(MODELE=MOD, # '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 diff --git a/Tests/testelem/azv6.comm b/Tests/testelem/azv6.comm index 1302702b..8e076310 100644 --- a/Tests/testelem/azv6.comm +++ b/Tests/testelem/azv6.comm @@ -56,13 +56,11 @@ CARA=AFFE_CARA_ELEM(MODELE=MOD, # '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 diff --git a/Tests/testelem/testaz76.py b/Tests/testelem/testaz76.py index 2dd8a129..44401008 100644 --- a/Tests/testelem/testaz76.py +++ b/Tests/testelem/testaz76.py @@ -35,7 +35,7 @@ class TestCase(unittest.TestCase): 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) @@ -322,7 +322,7 @@ class TestCase(unittest.TestCase): 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) diff --git a/Tests/testelem/testitem1.py b/Tests/testelem/testitem1.py index 3b46a8f8..5c73b925 100644 --- a/Tests/testelem/testitem1.py +++ b/Tests/testelem/testitem1.py @@ -24,7 +24,7 @@ def add_mcsimp(obj,nom,valeur): 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 """ diff --git a/Tests/testelem/testjdc1.py b/Tests/testelem/testjdc1.py index e77bbf61..ea403fb0 100644 --- a/Tests/testelem/testjdc1.py +++ b/Tests/testelem/testjdc1.py @@ -25,7 +25,7 @@ def add_mcsimp(obj,nom,valeur): 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): diff --git a/Tests/testelem/testjdc3.py b/Tests/testelem/testjdc3.py index 2048b576..842be867 100644 --- a/Tests/testelem/testjdc3.py +++ b/Tests/testelem/testjdc3.py @@ -25,7 +25,7 @@ def add_mcsimp(obj,nom,valeur): 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): diff --git a/Tests/testelem/testjdc4.py b/Tests/testelem/testjdc4.py index 9f43130f..eaa59483 100644 --- a/Tests/testelem/testjdc4.py +++ b/Tests/testelem/testjdc4.py @@ -25,7 +25,7 @@ def add_mcsimp(obj,nom,valeur): 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): diff --git a/Tests/testelem/testzzz6az.py b/Tests/testelem/testzzz6az.py index d2b519ca..a29eebcd 100644 --- a/Tests/testelem/testzzz6az.py +++ b/Tests/testelem/testzzz6az.py @@ -35,7 +35,7 @@ class TestCase(unittest.TestCase): 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) @@ -322,7 +322,7 @@ class TestCase(unittest.TestCase): 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) diff --git a/Tests/testihm/common.py b/Tests/testihm/common.py index fbd438a2..ebad6afc 100644 --- a/Tests/testihm/common.py +++ b/Tests/testihm/common.py @@ -1,5 +1,6 @@ # -*- coding: utf-8 -*- +from tkMessageBox import showinfo root=None jdcdisplay=None @@ -179,6 +180,8 @@ def set_complexe(valeur,panel): 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() diff --git a/Tests/testihm/testihm1.py b/Tests/testihm/testihm1.py index 5b79c45e..52e49e83 100644 --- a/Tests/testihm/testihm1.py +++ b/Tests/testihm/testihm1.py @@ -16,7 +16,7 @@ from Editeur import eficas from Editeur import images from common import * -version='v8.3' +version='v8' class TestCase(unittest.TestCase): def setUp(self): diff --git a/Tests/testihm/testihm2.py b/Tests/testihm/testihm2.py index 06c14ec8..b701fbb0 100644 --- a/Tests/testihm/testihm2.py +++ b/Tests/testihm/testihm2.py @@ -23,7 +23,7 @@ class TestCase(unittest.TestCase): 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): diff --git a/Tests/testihm/testihm4.py b/Tests/testihm/testihm4.py index ae7a0920..3d384921 100644 --- a/Tests/testihm/testihm4.py +++ b/Tests/testihm/testihm4.py @@ -23,7 +23,7 @@ class TestCase(unittest.TestCase): 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): diff --git a/Traducteur/__init__.py b/Traducteur/__init__.py new file mode 100644 index 00000000..28da2d3d --- /dev/null +++ b/Traducteur/__init__.py @@ -0,0 +1,20 @@ +# -*- 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. +# +# +# ====================================================================== diff --git a/Traducteur/calcG.py b/Traducteur/calcG.py new file mode 100644 index 00000000..05c76a6f --- /dev/null +++ b/Traducteur/calcG.py @@ -0,0 +1,139 @@ +# -*- 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 + + diff --git a/Traducteur/changeValeur.py b/Traducteur/changeValeur.py new file mode 100644 index 00000000..85934252 --- /dev/null +++ b/Traducteur/changeValeur.py @@ -0,0 +1,270 @@ +# -*- 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 diff --git a/Traducteur/dictErreurs.py b/Traducteur/dictErreurs.py new file mode 100644 index 00000000..46e37dd8 --- /dev/null +++ b/Traducteur/dictErreurs.py @@ -0,0 +1,101 @@ +# -*- 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) + diff --git a/Traducteur/inseremocle.py b/Traducteur/inseremocle.py index b8d345b4..ff8a3357 100644 --- a/Traducteur/inseremocle.py +++ b/Traducteur/inseremocle.py @@ -1,84 +1,137 @@ # -*- 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 @@ -90,12 +143,12 @@ def chercheDebut1mot(jdc,command): 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] @@ -104,7 +157,6 @@ def chercheDebutfacteur(jdc,facteur): return debut - #----------------------------------- def chercheAlignement(jdc,command): #----------------------------------- @@ -115,4 +167,79 @@ 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) diff --git a/Traducteur/jdcparser.py b/Traducteur/jdcparser.py deleted file mode 100644 index d6a1651d..00000000 --- a/Traducteur/jdcparser.py +++ /dev/null @@ -1,75 +0,0 @@ -# -*- 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() diff --git a/Traducteur/load.py b/Traducteur/load.py index ca1f4c50..b8f0a5aa 100644 --- a/Traducteur/load.py +++ b/Traducteur/load.py @@ -1,6 +1,7 @@ # -*- coding: utf-8 -*- import os +import re import parseur from mocles import parseKeywords @@ -19,7 +20,7 @@ class JDC: 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): @@ -57,8 +58,7 @@ class JDC: Lmilieu=[ligne,] Lfin=self.lines[numero:] self.lines=Ldebut+Lmilieu+Lfin - src=self.getSource() - self.reset(src) + def splitLine(self,numeroLigne,numeroColonne) : #---------------------------------------------- @@ -77,8 +77,6 @@ class JDC: Lmilieu=[LigneSplitDebut,LigneSplitFin] self.lines=Ldebut+Lmilieu+Lfin - src=self.getSource() - self.reset(src) def joinLineandNext(self,numeroLigne) : #-------------------------------------- @@ -100,8 +98,16 @@ class JDC: 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): #---------------------------_ diff --git a/Traducteur/log.py b/Traducteur/log.py index 80396639..3e440867 100644 --- a/Traducteur/log.py +++ b/Traducteur/log.py @@ -2,9 +2,15 @@ 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) diff --git a/Traducteur/mocles.py b/Traducteur/mocles.py index f9429ad8..7d2aafeb 100644 --- a/Traducteur/mocles.py +++ b/Traducteur/mocles.py @@ -2,13 +2,16 @@ 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: @@ -61,21 +64,32 @@ def parseFact(match,c,kw): 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]) @@ -90,8 +104,12 @@ def parseKeywords(root): 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 @@ -107,8 +125,10 @@ def parseKeywords(root): 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 diff --git a/Traducteur/movemocle.py b/Traducteur/movemocle.py index 8e07cbe7..fef05893 100644 --- a/Traducteur/movemocle.py +++ b/Traducteur/movemocle.py @@ -4,11 +4,19 @@ import logging 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 @@ -18,21 +26,32 @@ def movemoclefromfacttofather(jdc,command,fact,mocle): 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: @@ -42,8 +61,6 @@ def movemoclefromfacttofact(jdc,oper,factsource,mocle,factcible): 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 @@ -55,8 +72,6 @@ def movemoclefromfacttofact(jdc,oper,factsource,mocle,factcible): 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 @@ -66,7 +81,49 @@ def movemoclefromfacttofact(jdc,oper,factsource,mocle,factcible): 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) diff --git a/Traducteur/parseur.py b/Traducteur/parseur.py index 5b4a223f..fead5e6c 100644 --- a/Traducteur/parseur.py +++ b/Traducteur/parseur.py @@ -11,8 +11,11 @@ allchars = string.maketrans("", "") 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 @@ -36,9 +39,13 @@ implicitContinuationChars = (('(', ')'), ('[', ']'), ('{', '}')) linecontinueRE = re.compile(r"\\\s*(#.*)?$") emptyHangingBraces = [0,0,0,0,0] +#-------------------------------------- class UnbalancedBracesException: pass +#-------------------------------------- +#----------- class Node: +#----------- def __init__(self): self.childNodes=[] @@ -46,13 +53,22 @@ class Node: 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 @@ -60,7 +76,9 @@ class Command(Node): self.colno=colno self.firstparen=firstparen +#------------------- class Keyword(Node): +#------------------- def __init__(self,name,lineno,colno,endline,endcol): Node.__init__(self) self.name=name @@ -71,12 +89,11 @@ class Keyword(Node): 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 : @@ -87,7 +104,9 @@ class Keyword(Node): 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 ; @@ -95,7 +114,9 @@ def chaineBlanche(texte) : if texte[i] != " " : bool = 0 return bool +#------------------- def printNode(node): +#------------------- if hasattr(node,'name'): print node.name else: @@ -103,7 +124,9 @@ def printNode(node): 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) @@ -114,8 +137,9 @@ def parser(src,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 @@ -129,16 +153,16 @@ def parser(src,atraiter): 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 @@ -183,11 +207,14 @@ def parser(src,atraiter): 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) @@ -204,7 +231,9 @@ def lastparen(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 diff --git a/Traducteur/regles.py b/Traducteur/regles.py new file mode 100644 index 00000000..9cddcfda --- /dev/null +++ b/Traducteur/regles.py @@ -0,0 +1,160 @@ +# -*- 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() diff --git a/Traducteur/removemocle.py b/Traducteur/removemocle.py index 4af3caee..5f633578 100644 --- a/Traducteur/removemocle.py +++ b/Traducteur/removemocle.py @@ -1,43 +1,107 @@ # -*- 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: @@ -47,11 +111,40 @@ def removemocleinfact(jdc,command,fact,mocle): 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 @@ -60,6 +153,15 @@ def fusionne(jdc,numLigne): 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) diff --git a/Traducteur/renamemocle.py b/Traducteur/renamemocle.py index 871c07a9..e4f8448d 100644 --- a/Traducteur/renamemocle.py +++ b/Traducteur/renamemocle.py @@ -1,24 +1,88 @@ # -*- 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: @@ -29,20 +93,52 @@ def renamemocleinfact(jdc,command,fact,mocle,new_name): 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) diff --git a/Traducteur/traduitV7V8.py b/Traducteur/traduitV7V8.py new file mode 100644 index 00000000..e74f31a1 --- /dev/null +++ b/Traducteur/traduitV7V8.py @@ -0,0 +1,430 @@ +#!/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() + diff --git a/Traducteur/utils.py b/Traducteur/utils.py index b78a4b07..e01f74bf 100644 --- a/Traducteur/utils.py +++ b/Traducteur/utils.py @@ -9,8 +9,9 @@ def indexToCoordinates(src, index): 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 @@ -19,7 +20,7 @@ def linetodict(line): 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() diff --git a/Traducteur/visiteur.py b/Traducteur/visiteur.py index 0d1030f9..1b3144e2 100644 --- a/Traducteur/visiteur.py +++ b/Traducteur/visiteur.py @@ -6,7 +6,8 @@ from compiler import visitor 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 @@ -25,7 +26,7 @@ class MatchFinder: 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)] @@ -36,28 +37,31 @@ class KeywordFinder(MatchFinder): 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) diff --git a/convert/parseur_python.py b/convert/parseur_python.py index 07824016..aa4a5d43 100644 --- a/convert/parseur_python.py +++ b/convert/parseur_python.py @@ -63,7 +63,8 @@ pattern_comment = re.compile(r"^\s*#.*") #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 @@ -84,14 +85,16 @@ number_kw_pattern=re.compile(r""" #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'} """ @@ -419,7 +422,9 @@ class PARSEUR_PYTHON: 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) @@ -431,7 +436,9 @@ class PARSEUR_PYTHON: 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 @@ -469,7 +476,9 @@ class PARSEUR_PYTHON: 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 @@ -481,7 +490,9 @@ class PARSEUR_PYTHON: 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) @@ -614,6 +625,12 @@ class PARSEUR_PYTHON: 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' diff --git a/generator/Formatage.py b/generator/Formatage.py index e7f0abf2..1eaf04b4 100644 --- a/generator/Formatage.py +++ b/generator/Formatage.py @@ -78,6 +78,7 @@ class Formatage : 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 @@ -170,6 +171,7 @@ class Formatage : # # 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() : @@ -180,10 +182,14 @@ class Formatage : 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 ... @@ -215,7 +221,8 @@ class Formatage : 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 diff --git a/generator/generator_python.py b/generator/generator_python.py index 0bdaa78a..309d12be 100644 --- a/generator/generator_python.py +++ b/generator/generator_python.py @@ -112,6 +112,7 @@ class PythonGenerator: 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) @@ -134,7 +135,7 @@ class PythonGenerator: 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) @@ -154,6 +155,7 @@ class PythonGenerator: return self.generFormula(obj) else: raise "Type d'objet non prévu",obj + premier=0 def generJDC(self,obj): """ @@ -208,7 +210,7 @@ class PythonGenerator: """ 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 @@ -220,11 +222,17 @@ class PythonGenerator: 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): @@ -241,7 +249,8 @@ class PythonGenerator: return repr(obj) def generFormula(self,obj): - return repr(obj) + #return repr(obj) + return str(obj) def generPARAMETRE(self,obj): """ @@ -476,13 +485,10 @@ class PythonGenerator: # 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 diff --git a/generator/generator_vers3DSalome.py b/generator/generator_vers3DSalome.py index f9bf541e..e16722af 100644 --- a/generator/generator_vers3DSalome.py +++ b/generator/generator_vers3DSalome.py @@ -26,6 +26,7 @@ """ import traceback import types,string,re +import math from Noyau import N_CR from Noyau.N_utils import repr_float @@ -169,8 +170,8 @@ class vers3DSalomeGenerator(PythonGenerator): 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] -- 2.39.2